Java开发---类集（Map）

Map集合

保存一对对象的最大父接口，键值对(key值唯一,当key值重复时，覆盖value值)

Map接口的定义

public interface Map<K,V>

Map接口的重要方法

获取Map集合所存储数据大小：int size();
判断Map集合是否为空：boolean isEmpty();
判断是否包含key值：boolean containsKey(Object key);
判断是否包含value值：boolean containsValue(Object value);
根据key取得对应的value，如果没有返回null：V get(Object key);
向Map 中追加数据：V put(K key, V value);
据key值删除元素：V remove(Object key)；
取得key值信息：Set<K> keySet()；
取得所以value信息，可以重复：Collection<V> values();
将Map集合变为Set集合：Set<Map.Entry<K, V>> entrySet();

Map集合的三个实现类

HashMap子类（lazy-load（resize()进行扩容和初始化））

Hash表的插入方式

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 哈希表初始化流程
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 要插入的数组元素为空，直接将要插入的元素插入到该数组下标位置处
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 表初始化完成、要插入的数组元素下标已经有元素
        else {
            Node<K,V> e; K k;
            // 数组元素的key与要插入的元素key相等，将value做替换即可
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 使用红黑树插入元素
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            // 使用链表插入元素
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

具体键值对在哈希表中的位置（数组index取决下面的位运算），它并不是key本身hashCode，而是来自于HashMap内部的另外一个hash方法，保留哈希值的高位进行插入

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    (h = key.hashCode()) ^ (h >>> 16)


    i = (n - 1) & hash   //保证得到的数组下标一定在哈希表长度范围内

负载因子设置（不超过0.75），并且负载因子*容量>元素数量，若设置过大性能降低，设置过小造成空间上的浪费

树化（消除链表的存取性能带来的问题，解决安全问题，防止服务器被恶意崩溃）

final void treeifyBin(Node<K,V>[] tab, int hash) {   
     int n, index; Node<K,V> e; 
     if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)   //简单链表扩容
        resize();   
     else if ((e = tab[index = (n - 1) & hash]) != null) {          //树化改造
}

• 如果容量大于MIN_TREEIFY_CAPACITY,就会进行树化改造

Hashtable子类

与HashMap的区别：

ConcurrentHashMap子类

JDK1.8之前

利用分段设计，在进行并发操作的时候，只需要锁定相应段，避免了HashTable整体同步的问题（分离锁）

一张表16把锁，支持的并发线程数为16

在进行并发写操作时

• ConcurrentHashMap会获取重入锁，以保证数据一致性，Segment本身就是基于ReentrantLock的扩展实现。所以在并发修改期间，相应Segment时被锁定的
• 在最初阶段，进行重复性扫描，以确定相应key值是否已在数组里面
• 在ConcurrentHashMap中扩容只是单独对Segment进行扩容

缺点：会影响Map的size（）方法

改进：通过重试机制（RETRIES_BEFORE_LOCK，指定重试次数为2）， Segment.modCount，看两次的值是否发生变化

而在JDK1.8之后

• 一张表有多个锁(初始化为16，随着哈希表的扩容而不断增加，支持的并发线程数也不断增加)
• 总体结构上，他的内部存储和HashMap结构相似，同步的粒度更细致
• 其内部任然有Segment定义，但仅仅是保证序列化的兼容性而已
• 初始化操作大大简化，修改为Lazy——load形式
• 使用CAS等操作，在特定场景进行无锁并发操作
• 使用Unsafe，longAdder之类底层手段，进行极端情况简化

TreeMap子类

TreeMap是一个可以排序的Map子类，他是按照Key的内容排序的

public class TestDemo { 
   public static void main(String[] args) { 
      Map<Integer,String> map = new TreeMap<>() ;
      map.put(2,"C") ;  
      map.put(0,"A") ;  
      map.put(1,"B") ;  
      System.out.println(map);
    } 
}

Integer类实现了Comparable接口，所以就依靠compareTo（）方法完成，不再需要equals（）与hashCode（）；

Map集合使用Iterator输出

public Set<Map.Entry<K, V>> entrySet();

package www.bit.java.test;
import java.util.HashMap;
import java.util.Iterator; 
import java.util.Map;
import java.util.Set;
public class TestDemo{
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"he");    
        map.put(2,"ha");
        map.put(2,"java");
        //将Map集合转为Set集合
        Set<Map.Entry<Integer,String>> set=map.entrySet();
        //获得Iterator对象
        Iterator<Map.Entry<Integer,String>> iterator=set.iterator();
        //输出
        while(iter.hasNext()) {
            //取得每一个Map.Entry对象
            Map.Entry<Integer,String> entry=iterator.next();
            //取得key和value
            System.out.println(entry,getKey()+"="+entry.getValue());
        }

    }    
}

关于Map中key的说明

因为key值唯一属于一个set集合，所以在key值使用用户自定义的类时需要给出比较相等的方法，即覆写hashCode（）方法和equals（）方法，以用户自定义的Person类为例，在Person类中覆写hashCode和equals方法；

     @Override    
    public boolean equals(Object o) {   
         if (this == o) return true;  
         if (o == null || getClass() != o.getClass()) return false;  
         Person person = (Person) o;    
         return Objects.equals(age, person.age) &&
                               Objects.equals(name, person.name);  
    }
    @Override
    public int hashCode() {
        return Objects.hash(age, name); 
    }

在我们经常用的系统类（String，Integer）作为key值时，这些类中已经覆写好hashCode（）与equals（）方法

Map中关于null总结

• HashMap key与value均可为null,JDK1.2,线程不安全，哈希表+红黑树(JDK8)
• Treemap key不允许为null，value可以为null,JDK1.2,线程不安全，红黑树
• Hashtable key与value均不为null,线程安全，JDK1.0，基于哈希表

fail-fast策略(java.util 除了TreeSet外的所有集合),

fail-safe策略（juc包下所有线程安全的集合）

•  copyOnWriteArrayList
• copyOnWriteArraySet
• coucurrentHashMap