Java collection Map interface

Map interface

Features (JDK8)

1. Map and Collection exist side by side. Used to save data with mapping relationship: key value
2. The key and value in the Map can make data of any reference type encapsulated in the HashMap$Node object
3. The key in the Map cannot be repeated, and is willing to be the same as the HashSet
4. The value in the Map can be repeated
5. The key and value of Map can be null. Note that there can only be one null key
6. String class is often used as the key of Map
7. There is a one-way one-to-one relationship between key and value, that is, the corresponding value can always be found through the specified key
8. put elements with the same key will be replaced

Map system inheritance diagram

data structure

1. The key value of the data stored in the Map is placed in a HashMap$Node (the Entry interface is implemented)

   static class Node<K,V> implements Map.Entry<K,V> {
           final int hash;
           final K key;
           V value;
           Node<K,V> next;
   
           Node(int hash, K key, V value, Node<K,V> next) {
               this.hash = hash;
               this.key = key;
               this.value = value;
               this.next = next;
           }
   
           public final K getKey()        { return key; }
           public final V getValue()      { return value; }
           public final String toString() { return key + "=" + value; }
   
           public final int hashCode() {
               return Objects.hashCode(key) ^ Objects.hashCode(value);
           }
   
           public final V setValue(V newValue) {
               V oldValue = value;
               value = newValue;
               return oldValue;
           }
   
           public final boolean equals(Object o) {
               if (o == this)
                   return true;
               if (o instanceof Map.Entry) {
                   Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                   if (Objects.equals(key, e.getKey()) &&
                       Objects.equals(value, e.getValue()))
                       return true;
               }
               return false;
           }
       }
   

2. The Map.Entryj interface in set < map. Entry < K, V > > obtained by entrySet() method directly refers to the data in Node and is not copied (so modification will affect the original data)

   interface Entry<K,V> {
           K getKey();
           V getValue();
           V setValue(V value);
       
           int hashCode();
       
           public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
               return (Comparator<Map.Entry<K, V>> & Serializable)
                   (c1, c2) -> c1.getKey().compareTo(c2.getKey());
           }
   
           public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
               return (Comparator<Map.Entry<K, V>> & Serializable)
                   (c1, c2) -> c1.getValue().compareTo(c2.getValue());
           }
   
           public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
               Objects.requireNonNull(cmp);
               return (Comparator<Map.Entry<K, V>> & Serializable)
                   (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
           }
   
           public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
               Objects.requireNonNull(cmp);
               return (Comparator<Map.Entry<K, V>> & Serializable)
                   (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
           }
       }
   

3. Like keySet(), it returns an internal class (which implements Set) and directly references the key in the original Node

   final class KeySet extends AbstractSet<K> {
       public final int size()                 { return size; }
       public final void clear()               { HashMap.this.clear(); }
       public final Iterator<K> iterator()     { return new KeyIterator(); }
       public final boolean contains(Object o) { return containsKey(o); }
       public final boolean remove(Object key) {
           return removeNode(hash(key), key, null, false, true) != null;
       }
       public final Spliterator<K> spliterator() {
           return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
       }
       public final void forEach(Consumer<? super K> action) {
           Node<K,V>[] tab;
           if (action == null)
               throw new NullPointerException();
           if (size > 0 && (tab = table) != null) {
               int mc = modCount;
               for (int i = 0; i < tab.length; ++i) {
                   for (Node<K,V> e = tab[i]; e != null; e = e.next)
                       action.accept(e.key);
               }
               if (modCount != mc)
                   throw new ConcurrentModificationException();
           }
       }
   }
   

4. values() also returns an internal class (implementing the Collection interface) that directly references the value in the Node

   final class Values extends AbstractCollection<V> {
       public final int size()                 { return size; }
       public final void clear()               { HashMap.this.clear(); }
       public final Iterator<V> iterator()     { return new ValueIterator(); }
       public final boolean contains(Object o) { return containsValue(o); }
       public final Spliterator<V> spliterator() {
           return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
       }
       public final void forEach(Consumer<? super V> action) {
           Node<K,V>[] tab;
           if (action == null)
               throw new NullPointerException();
           if (size > 0 && (tab = table) != null) {
               int mc = modCount;
               for (int i = 0; i < tab.length; ++i) {
                   for (Node<K,V> e = tab[i]; e != null; e = e.next)
                       action.accept(e.value);
               }
               if (modCount != mc)
                   throw new ConcurrentModificationException();
           }
       }
   }
   

method

Map interface traversal mode

1. Take out all keys, and then take out the corresponding value through the key

   Set keySet = map.keySet();
   //Enhanced for
   for(Object key:keySet){
       System.out.println(key + "=" + map.get(key));
   }
   //iterator 
   Iterator iterator = keySet.iterator();
   while(iterator.hasNext()){
       Object key = iterator.next();
       System.out.println(key + "=" + map.get(key));
   }
   

2. Take out all the values

Collection values = map.values();
//Enhanced for
for(Object value:values){
    System.out.println(value);
}
//iterator 
Iterator iterator = keyset.iterator();
while(iterator.hasNext()){
    Object value = iterator.next();
    System.out.println(value);
}

1. Get k-v through EntrySet

   Set entrySet = map.entrySet();
   //Enhanced for
   for(Object entry:entrySet){
       //Convert entry to Map.Entry
       Map.Entry m = (Map.Entry) entry;
       System.out.println(m.getKey() + "=" + m.getValue(key));
   }
   //iterator 
   Iterator iterator = entrySet.iterator();
   while(iterator.hasNext()){
       Object entry = iterator.next();//HashMap&Node implement Map.Entry
       Map.Entry m = (Map.Entry) entry;
       System.out.println(m.getKey() + "=" + m.getValue(key));
   }