Java集合框架(二)之 Map集合

一、Map接口概述

Collection集合的特点是每次进行单个对象的保存，如果现在要进行一对对象(偶对象)的保存就只能使用Map集合来完成，即Map集合中会一次性保存两个对象，且这两个对象的关系:key，value结构。这种结构最大的特点是可以通过key找到对应的value内容。 Map本身是一个接口，要使用Map需要通过子类进行对象实例化。Map接口的常用子类有如下四个： HashMap、Hashtable、TreeMap、ConcurrentHashMap。

二、HashMap子类

//HashMap 

        Map<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        // key重复
        map.put(1, "Hello");
        map.put(2, "Java");
        map.put(2, "Bi");
        map.put(3, "B");
        System.out.println(map.get(2));//Bi
        System.out.println(map.get(5));//null
        // 取得Map中所有的key信息1,2,3
        Set<Integer> set = map.keySet();
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //打印所有的key
        for (Integer a : set) {
            System.out.println(a);
        }
        //打印所有的value
        //Hello
        //Bi
        //B
        for (String b : map.values()) {
            System.out.println(b);
        }
        //按照key-value映射的方式打印
        //1=Hello
        //2=Bi
        //3=B
        for(Map.Entry<Integer,String> entry:map.entrySet()){
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }

二、Hashtable子类

比较低效，本身的实现就是将put、getsize等各种方法加上“synchronized”，导致所有的并发操作都要竞争同一把锁，一个线程在进行同步操作的时候，其他线程只能等待，降低了并发操作的效率。

Map<Integer ,String> map=new Hashtable<>();
        map.put(1,"Hello") ;
        map.put(3,"Java") ;
        map.put(2,"Bit") ;
        System.out.println(map);
 结果：{3=Java, 2=Bit, 1=Hello}

HashMap与Hashtable的区别

三、ConcurrentHashMap子类

早期的ConcurrentHashMap，其实现基于：

• 分离锁，将内部进行分段(segment)，里面是HashEntry 的数组，和HashMap类似，哈希
  相同的条目也是以链表形式存放。
• HashEntry 内部使用 volatile 的 value 字段来保证可见性，
  Segment 的数量由所谓的 concurrentcyLevel 决定，默认是 16，也可以在相应构造函数直接指定。注意，Java 需要它是 2 的幂数值，如果输入是类似 15 这种非幂值，会被自动调整到 16 之类 2 的幂数值。

在进行并发写操作时：

• ConcurrentHashMap 会获取再入锁，以保证数据一致性，Segment 本身就是基于ReentrantLock(可重入锁) 的扩展实现，所以，在并发修改期间，相应 Segment 是被锁定的。
• 在最初阶段，进行重复性的扫描，以确定相应 key 值是否已经在数组里面，进而决定是更新还是放置操作。重复扫描、检测冲突是ConcurrentHashMap 的常见技巧。
• 在 ConcurrentHashMap中扩容同样存在。不过有一个明显区别，就是它进行的不是整体的扩容，而是单独对 Segment 进行扩容。
• 另外一个 Map 的 size 方法同样需要关注，它的实现涉及分离锁的一个副作用。
  试想，如果不进行同步，简单的计算所有 Segment 的总值，可能会因为并发 put，导致结果不准确，但是直接锁定所有 Segment 进行计算，就会变得非常昂贵。其实，分离锁也限制了 Map的初始化等操作。所以，ConcurrentHashMap 的实现是通过重试机制（RETRIES_BEFORE_LOCK，指定重试次数 2），来试图获得
  可靠值。如果没有监控到发生变化（通过对比 Segment.modCount），就直接返回，否则获取锁进行操作。

Java 8 和之后的版本中，ConcurrentHashMap 发生了哪些变化呢？

• 总体结构上，它的内部存储变得和HashMap 结构非常相似，同样是大的桶（bucket）数组，然后内部也是一个个所谓的链表结构（bin），同步的粒度要更细致一些。
• 其内部仍然有 Segment 定义，但仅仅是为了保证序列化时的兼容性而已，不再有任何结构上的用处。
• 因为不再使用 Segment，初始化操作大大简化，修改为 lazy-load 形式，这样可以有效避免初始开销，
• 解决了老版本很多人抱怨的这一点。
• 数据存储利用 volatile 来保证可见性。
• 使用 CAS 等操作，在特定场景进行无锁并发操作。
• 使用 Unsafe、LongAdder 之类底层手段，进行极端情况的优化。

四、 TreeMap子类

是按照Key的内容排序

Map<Integer,String> map = new TreeMap<>() ;
        map.put(2,"C") ;
        map.put(0,"A") ;
        map.put(1,"D") ;
        System.out.println(map);
       结果：{0=A, 1=D, 2=C} 

Collection保存的数据一般用于输出，Map保存的数据目的是更具key来查找，Map使用Iterator输出（Map.Entry）

五、 Map集合使用Iterator输出(重点)

Map接口与Collection接口不同，Collection接口有iterator()方法可以很方便的取得Iterator对象来输出，而Map接口本身并没有此方法。Collection是通过对象来保存的，Map是通过key，value组成一个Map.Entry来保存的在Map接口里面有一个重要的方法，将Map集合转为Set集合:public Set<Map.Entry<K, V>> entrySet();

public class TestMapIterator {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>() ;
        map.put(1,"Hello") ;
        map.put(2,"Bit") ;
        map.put(3,"Java") ;
        // 1.将Map集合转为Set集合
        Set<Map.Entry<Integer,String>> set = map.entrySet() ;
        // 2.获取Iterator对象
        Iterator<Map.Entry<Integer,String>> iterator = set.iterator() ;
        // 3.输出
        while (iterator.hasNext()) {
            // 4.取出每一个Map.Entry对象
            Map.Entry<Integer,String> entry = iterator.next() ;
            // 5.取得key和value
            System.out.println(entry.getKey()+" = " +entry.getValue()) ;
        }
    }
}