Java集合Map

 

几种常用的Map：HashMap、TreeMap、WeakHashMap、IdentityHashMap、LinkedHashMap

    Map--将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
    HashMap---无序：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
    TreeMap--有序：基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
    SortedMap--该映射是根据其键的自然顺序进行排序的，或者根据通常在创建有序映射时提供的 Comparator 进行排序
    EnterySet--返回此映射中包含的映射关系的 Set 视图；
    IdentityHashMap--此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。
    LinkedHashMap--Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）
  

    /**
     *  Map--将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
     * 	HashMap---无序：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
     */
    private static void mapOps() {
        Map<String,Integer> data = null;
        data = new HashMap<String,Integer>();
        data.put("Hadoop",10);
        data.put("Spark",6);
        data.put("Scala",14);
        data.put("Kafka",4);
        data.put("Tachyon",5);
        System.out.println(data.get("Spark"));//根据key获取value
        if (data.containsKey("Hadoop")){//判断key是否存在
            System.out.println(data.get("Hadoop"));
        }
        if (data.containsValue(14)){ //判断key是否存在
            System.out.println("Spark is here!");
        }
        //获取key的集合
        Set<String> keys = data.keySet();
        Iterator<String> keyIterator=keys.iterator();
        while (((Iterator) keyIterator).hasNext()){
            System.out.println(((Iterator) keyIterator).next());
        }
        //获取values的集合
        Collection<Integer> values = data.values();
        Iterator<Integer> valuesIerator = values.iterator();
        while (valuesIerator.hasNext()){
            System.out.println(valuesIerator.next());
        }
    }

    1.使用TreeMap构建的集合元素会按照key进行排序，所以要确保key已经实现了Comparable接口，例如Java中的String类型已经实现了Comparable接口，所以就可以直接使用，如果只用一个自定义的key则必须实现Comparable接口；

 

    /**
     * TreeMap
     *TreeMap--有序：基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
     *
     */

    private static void treeMapOps() {
        Map<String,Integer> data = null;
        data = new TreeMap<String,Integer>();
        data.put("Hadoop",10);
        data.put("Spark",6);
        data.put("Scala",14);
        data.put("Kafka",4);
        data.put("Tachyon",5);
        System.out.println(data.get("Spark"));//根据key获取value
        if (data.containsKey("Hadoop")){//判断key是否存在
            System.out.println(data.get("Hadoop"));
        }
        if (data.containsValue(14)){ //判断key是否存在
            System.out.println("Spark is here!");
        }
        //获取key的集合
        Set<String> keys = data.keySet();
        Iterator<String> keyIterator=keys.iterator();
        while (((Iterator) keyIterator).hasNext()){
            System.out.println(((Iterator) keyIterator).next());
        }
        //获取values的集合
        Collection<Integer> values = data.values();
        Iterator<Integer> valuesIerator = values.iterator();
        while (valuesIerator.hasNext()){
            System.out.println(valuesIerator.next());
        }
    }

    2.WeakHashMap能够在具体元素不被使用的情况下通过垃圾回收来自动清理暂时不使用的数据，这可以极大减少内存的浪费！
    3.Java中引用的四种类型：
        a）强引用：在内存不足时JVM即使出现OOM错误也不回收当前的引用的对象
        b）软引用：在内存不足是会回收对象来实现内存敏感的高速缓存
        c）弱引用：无论内存是否紧张，被GC发现就会立即被回收
        d）虚引用：和没有引用是一样的；
    4.WeakHashMap在实例化元素的时候，key的设置必须是new出来的引用对象，例如 new String。这样在System.gc()时候就会立即触发回收行为；

     /**
     * 以弱键实现的基于哈希表的 Map。在 WeakHashMap 中，当某个键不再正常使用时，
     * 将自动移除其条目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收
     * 器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收
     */

    private static void weakHashMap() {
        Map<String,Integer> data = null;
        data = new WeakHashMap<>();
        data.put(new String("Hadoop"),10);
        data.put(new String("Spark"),6);
        data.put(new String("Scala"),14);
        data.put(new String("Kafka"),4);
        data.put(new String("Tachyon"),5);
        System.gc();
        System.out.println(data);

    }

    5.使用IdentityHashMap可以允许Map中的key重复；

    /**
     * IdentityHashMap--此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。
     */
    private static void indentiyHashMapOps() {
        Map<Coder,String> data = null;
        data = new IdentityHashMap<>();
        data.put(new Coder("Spark",6),"Spark6");
        data.put(new Coder("Spark",6),"Spark66");
        data.put(new Coder("Hadoop",10),"Hadoop10");
        Set<Map.Entry<Coder,String>> entrySet = null;
        entrySet = data.entrySet();
        Iterator<Map.Entry<Coder,String>> iterator = null;
        iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<Coder, String> item = iterator.next();
            System.out.println(item.getKey()+" -> "+item.getValue());
        }

    }

    6.使用SortedMap接口的具体实现类可以实现Map中元素的key的规则进行排序；

     /**
     * SortedMap--该映射是根据其键的自然顺序进行排序的，或者根据通常在创建有序映射时提供的 Comparator 进行排序
     */
    private static void sortedHashMapOps() {
        SortedMap<String,Integer> data = null;
        data = new TreeMap<String,Integer>();
        data.put("Hadoop",10);
        data.put("Spark",6);
        data.put("Scala",14);

        data.put("Tachyon",5);
        data.put("Kafka",4);
        System.out.println("First key： "+data.firstKey());
        System.out.println("First Value： "+data.get(data.firstKey()));
        System.out.println("Last key： "+data.lastKey());
        System.out.println("Last value： "+data.get(data.lastKey()));
        System.out.println(((TreeMap<String, Integer>) data).headMap("Kafka"));
        System.out.println(((TreeMap<String, Integer>) data).tailMap("Spark"));
        System.out.println(((TreeMap<String, Integer>) data).subMap("Hadoop","Spark"));

    }

    7.在实际的开发工作中，Map一般都是作为查询来使用；如果要输出key-value的全部内容，需要使用基于Map.EntrySet构建的集合来访问其中的key-value；

    /**
     * EnterySet--返回此映射中包含的映射关系的 Set 视图；
     */
    private static void foreachHashMapOps() {
        SortedMap<String,Integer> data = null;
        data = new TreeMap<String,Integer>();
        data.put("Hadoop",10);
        data.put("Spark",6);
        data.put("Scala",14);

        data.put("Tachyon",5);
        data.put("Kafka",4);
        for (Map.Entry<String,Integer> item :data.entrySet()){
            System.out.println(item.getKey() +" -> "+item.getValue());
        }

    }