java集合-Map

摘要：增强的集合都可以是任何引用类型的数据，的不允许重复即同一个对象的任何两个通过方法比较总是返回。的这些实现类和子接口中集的存储形式和对应集合中元素的存储形式完全相同。根据的自然顺序，即枚举值的定义顺序，来维护对的顺序。

Key-value都可以是任何引用类型的数据，Map的Key不允许重复即同一个Map对象的任何两个key通过equals方法比较总是返回false。

如果把Map里的所有key放在一起来看，他们就组成了一个Set集合：所有key没有顺序，key与key之间不能重复，实际上Map确实包含了一个keySet方法，用来返回Map里所有key组成的Set集合。

Map的这些实现类和子接口中key集的存储形式和对应Set集合中元素的存储形式完全相同。

Set与Map之间的关系非常密切。虽然Map中放的元素时key-value对，Set集合中放的元素时单个对象，但如果把key-value对中的value当成key的附庸：key在那里，value就跟在那里，这样就可以像对待Set一样来对待Map了。事实上，Map提供了一个Entry内部类来封装key-value对，而计算Entry存储时则只考虑Entry封装的key。从java源码来看，java是先实现了Map，然后通过包装一个所有value都为null的Map就实现了Set集合。

如果把Map里的所有value放在一起来看，他们又非常类似于一个List：元素与元素之间可以重复，但每个元素可以根据索引来查找，只是Map中的索引不再使用整数值，而是以另一个对象作为索引。

public class MapTest {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("java", 1);
        map.put("python", 2);
        map.put("hadoop", 3);
        //{python=2, java=1, hadoop=3}
        System.out.println(map);
        //如果当前Map中已经有一个与该Key相等的key-value对，则新的key-value会覆盖原来的key-value对。并返回之前被覆盖的value
        Integer put = map.put("java", 4);
        System.out.println(put);//1
        for(Entry map2:map.entrySet()) {
            System.out.println(map2);
            //python=2
            //java=4
            //hadoop=3
        }
        
        for(Object obj : map.keySet()) {
            System.out.println(obj);//python java hadoop
        }
    }
}

public class NewMapTest {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("123", 456);
        //{123=456}
        System.out.println(map);
        
        /**
         * compute 和 computeIfAbsent 和 computeIfPresent总结
         * 
         * compute 如果函数式接口中的返回值不为null，那就是用接口中返回值来覆盖原value
         *                 如果接口中返回值为null，那么就删除此map对
         *                 如果原value为null，那就用接口中返回值覆盖原value
         * computeIfAbsent
         *                 如果函数式接口中的返回值不为null，而且原value不为null，那么不做改变
         *              如果接口中返回值为null，不做改变
         *              如果原value为null，那么就使用接口中的返回值覆盖原value
         */
        /**
         * map.compute(key, remappingFunction)
         * 该方法使用remappingFunction根据原来key-value对计算一个新value
         * 只要新value不为null，就使用新value覆盖原来value；
         * 如果原来value不为null，但新value为null，则删除原key-value对；
         * 如果原value，新value同时为null，那么方法不改变任何key-value对，直接返回null；
         */
        /*
        Integer compute = map.compute("123", (key,value) -> Integer.parseInt(key));
        System.out.println(compute);//123
        System.out.println(map);//{123=123}
        
        Integer compute = map.compute("123", (key,value) -> null);
        System.out.println(map);//{}
         */
        /*
        map.put("1234", null);
        Integer compute = map.compute("1234", (key,value) -> 0);
        System.out.println(compute);//0
        System.out.println(map);//{123=456, 1234=0}
        */
        
        /**
         * Absent 缺席
         *         map.computeIfAbsent(key, mappingFunction)
         * 如果传给该方法的key参数在Map中对应的value为null，则使用mappingFunction根据原来key，value计算一个新的结果
         * 如果计算结果不为null，则用计算结果覆盖原有的value。如果原Map原来不包括该Key，那么该方法可能会添加一组key-value对。
         */
        /*
        map.put("1234", null);
        map.computeIfAbsent("1234", (key) -> Integer.parseInt(key));
        System.out.println(map);//{123=456, 1234=1234}
        */
        /*
        Integer computeIfAbsent = map.computeIfAbsent("1231", (e) -> Integer.parseInt(e));
        System.out.println(computeIfAbsent);//1231
        System.out.println(map);//{123=456, 1231=1231}
        */
        
        /*
        Integer computeIfAbsent = map.computeIfAbsent("123", (e) -> Integer.parseInt("123123123"));
        System.out.println(computeIfAbsent);//456
        System.out.println(map);//{123=456}
        */
        
        
        /**
         * Present 提出；介绍；呈现；赠送
         * map.computeIfPresent(key, remappingFunction)
         * 如果传给该方法的key参数在Map中对应的value不为null，该方法使用remappingFunction根据原key-value计算一个新结果，
         * 如果计算结果不为null，则使用该结果覆盖原来的value，
         * 如果计算结果为null，则删除原key-value对
         */
        /*
        Integer computeIfPresent = map.computeIfPresent("123", (key,value) -> 0);
        System.out.println(computeIfPresent);//0
        System.out.println(map);//{123=0}
        */
        /*
        Integer computeIfPresent = map.computeIfPresent("1234", (Key,value) -> 0);
        System.out.println(computeIfPresent);//null
        System.out.println(map);//{123=456}
        */
        /*
        map.put("1234", null);
        Integer computeIfPresent = map.computeIfPresent("1234", (key,value) -> 12);
        System.out.println(computeIfPresent);//null
        System.out.println(map);//{123=456, 1234=null}
        */
        /*
        Integer computeIfPresent = map.computeIfPresent("123", (key,value) -> null);
        System.out.println(computeIfPresent);//null
        System.out.println(map);//{}
        */
        //获取指定key对应的value，如果key不存在那么就返回指定value
        Integer orDefault = map.getOrDefault("1234", 452);
        System.out.println(orDefault);//452
        
        /**
         * 该方法会先根据key参数获取该Map中对应的value，如果获取的value为null
         * 则直接用传入的value覆盖原有的value，在这种情况下，可能要添加一组map对，
         * 如果value不为null，则使用函数接口根据value，新value计算出一个新的结果，并用得到的结果去覆盖原有的value
         */
        Integer merge = map.merge("123", 123123, (key,value) -> value+1000);
        System.out.println(merge);//124123
        System.out.println(map);//{123=124123}
    }
}

Hashtable和HashMap区别

Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点，但如果有多个线程访问同一个Map对象时，使用Hashtable实现类会更好、

Hashtable不允许使用null作为key和value，如果试图把null值放入Hashtable里，将引发空指针异常，但HashMap可是使用null作为key和value、

为了成功的在HashMap，Hashtable中存储，获取对象，用作key的对象必须实现hashCode方法和equals方法。

类似于HashSet，HashMap，Hashtable判断两个key相等的标准也是：两个key通过equals方法返回true，两个key的hashCode值也相等。

HashMap和Hashtable判断两个value相等的标准是：只要两个对象通过equals方法比较返回true即可。

public class ABHashtable {
    public static void main(String[] args) {
        Hashtable hashtable = new Hashtable<>();
        hashtable.put(new A(123), "123");
        hashtable.put(new A(1234), "1234");
        hashtable.put(new A(1236), new B());
        System.out.println(hashtable);
        
        System.out.println(hashtable.containsValue("32342342"));//true
        System.out.println(hashtable.containsKey(new A(123)));//true
        System.out.println(hashtable.containsKey(new A(123123)));//false
    }
}    

上述代码解释：上述Hashtable中包含了B对象，而且重写了B对象的equals方法，它与任何对象通过equals都会返回true，所以在第一个输出是true。根据Hashtable判断两个key相等的标准，在第二个输出的时候，因为通过equals和hashCode都返回true，所以Hashtable判断这两个key相等，所以为true。

与HashSet类似的是，如果使用可变对象作为HashMap，Hashtable的key，如果程序修改了可变对象，那么程序再也无法准确访问到Map中被修改过的key。

public class ABHashtable2 {
    public static void main(String[] args) {
        HashMap hashtable = new HashMap();
        hashtable.put(new A(123), "123");
        hashtable.put(new A(1234), "1234");
        //{mapTest.A@4d2=1234, mapTest.A@7b=123}
        System.out.println(hashtable);
        A next = (A) hashtable.keySet().iterator().next();
        System.out.println(next.count);//1234
        next.count = 123;
        //{mapTest.A@7b=1234, mapTest.A@7b=123}
        System.out.println(hashtable);
        
        hashtable.remove(new A(123));
        //只能删除没有被修改的key所对应的key-value对
        System.out.println(hashtable);//{mapTest.A@7b=1234}
        System.out.println(hashtable.get(new A(123)));//null
    }
}

尽量不要使用可变对象作为key，如果确实需要，则尽量不要在程序中修改作为key的对象。

LinkedHashMap也使用双向链表来维护key-value对的次序，其实只需要考虑key的次序，该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。

因为他使用链表来维护内部顺序，所以在迭代访问Map里的全部元素时将有较好的性能，迭代输出LinkedHashMap的元素时，将会安添加key-value的顺序输出。

public class LinkedHashMapS {
    public static void main(String[] args) {
        LinkedHashMap map = new LinkedHashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        System.out.println(map);//{1=1, 2=2, 3=3}
    }
}

Properties是Hashtable类的子类

Properties相当于一个key，value都是String的Map

public class PropertiesTest {
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Properties properties = new Properties();
        properties.setProperty("w","zq");
        properties.setProperty("w1","zq1");
        properties.setProperty("w2","zq2");
        //输出文件目录，文件说明
        properties.store(new FileOutputStream(new File("myProperties.properties")), "comment");
        properties.storeToXML(new FileOutputStream(new File("myProperties1.xml")), "comment");
    }
}
myProperties
#comment
#Fri Mar 09 10:11:42 CST 2018
w=zq
w1=zq1
w2=zq2

myProperties1



comment
zq
zq1
zq2

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。TreeMap也可以自然排序和定制排序。

TreeMap中判断两个key相等的标准是：两个key通过compareTo方法返回0，TreeMap即认为这两个key是相等的。

如果使用自定义类作为TreeMap的key，且想让TreeMap良好的工作，则重写该类的equals方法和compareTo方法时保持一致的返回结果。

Set和Map的关系十分密切，java源代码就是先实现了HashMap，TreeMMap等集合，然后通过包装一个所有的value都为null的Map集合实现了Set集合类。

public class TreeMapTest {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap<>();
        treeMap.put(12, 34);
        treeMap.put(-12, 34);
        treeMap.put(122, 34);
        treeMap.put(0, 34);
        //{-12=34, 0=34, 12=34, 122=34}
        System.out.println(treeMap);
    }
}

WeakHashMap与HashMap的区别是：HashMap的key保留对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap的所有key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对；但WeakHashMap的key只保留了实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些key所对应的key-value对。

public class WeakHashMapTets {
    public static void main(String[] args) {
        WeakHashMap weakHashMap = new WeakHashMap<>();
        weakHashMap.put(new String("1"), new String("1"));
        weakHashMap.put(new String("2"), new String("2"));
        weakHashMap.put(new String("3"), new String("3"));
        weakHashMap.put("4", new String("4"));
        //{4=4, 1=1, 2=2, 3=3}
        System.out.println(weakHashMap);
        System.gc();
        System.runFinalization();
        //{4=4}
        System.out.println(weakHashMap);
        //第四组key-value对的key是一个字符串直接量，系统会自动保留对该字符串对象的强引用，所以垃圾回收时不会回收他
    }
}    

如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让该key所引用的对象具有任何强引用了否则将失去WeakHashMap的意义。

在IdentityHashMap中，当且仅当两个key严格相等key1 == key2时，IdentityHashMap才认为两个key相等，对于普通的HashMap而言，只要key1和key2通过equals方法比较返回true，且他们的hashCode值相等即可。

public class IdentityHashMapTest {
    public static void main(String[] args) {
        IdentityHashMap identityHashMap = new IdentityHashMap<>();
        identityHashMap.put(new String("r"),"r");
        identityHashMap.put(new String("r"),"r");
        identityHashMap.put("java", 0);
        identityHashMap.put("java", 1);
        //{java=1, r=r, r=r}
        System.out.println(identityHashMap);
        /**
         * 由于上面new String()的地址值不一样，IdentityHashCode返回值会不一样
         * 所以第一个String与第二个String并不一样
         * 但是java字符串直接量是一样的，所以第二次put就会覆盖原来的value
         */
    }
}

EnumMap中的所有key都必须是单个枚举类的枚举值，创建EnumMap时必须显示或隐式指定它对应的枚举类。

EnumMap具有如下特征

EnumMap在内部以数组形式保存，所以这种实现形式非常紧凑，高效。

EnumMap根据key的自然顺序，即枚举值的定义顺序，来维护key-value对的顺序。

EnumMap不允许使用null作为key，但允许使用null作为value，如果试图使用null作为key时将抛出空指针异常。如果只是查询是否包含值为null的key，或只是删除值为null的key，都不会抛出异常。

创建EnumMap时必须指定一个枚举类，从而将该EnumMap和指定的枚举类关联起来。

public class EnumMapTest {
    public static void main(String[] args) {
        EnumMap enumMap = new EnumMap(EnumMaps.class);
        System.out.println(enumMap);//{}
        enumMap.put(WINTER, "4");
        enumMap.put(SPRING, "4");
        enumMap.put(SUMMER, "4");
        //{SPRING=4, SUMMER=4, WINTER=4}
        System.out.println(enumMap);
    }
}

HashMap和Hashtable的实现机制几乎一样，但由于Hashtable是一个古老的，线程安全的集合，因此HashMap通常比Hashtable要快。

TreeMap通常比HashMap，Hashtable要慢，尤其在插入删除key-value对时更慢，因为TreeMap底层采用红黑树来管理key-value对，红黑树的每个节点就是一个key-value对。

使用TreeMap有一个好处：TreeMap中的key-value对总是处于有序状态，无需专门进行排序操作。当TreeMap被填充之后，就可以调用keySet()，去的由key组成的Set，然后使用toArry()方法生成key的数组，接下来使用Arrays的binarySearch()方法在已排序的数组中快速地查询对象。

对于一般的应用场景，程序应该多考虑使用HashMap，因为HashMap正是为快速查询设计的：HashMap底层其实也是采用数组来存储key-value对。但如果程序需要一个总是排序好的Map时，则可以考虑使用TreeMap。

LinkedHashMap比HashMap慢一点，因为他需要维护链表来保持Map中key-value时的添加顺序。IdentityHashMap心梗没有特别出色之处，因为他采用与HashMap基本相似的实现，只是它使用==而不是equals方法来判断元素相等。EnumMap的性能最好，但它只能使用同一个枚举类的枚举值作为key。

对于HashSet及其子类而言，它们采用hash算法来决定集合中元素的存储位置，并通过hash算法来控制集合的代销；对于HashMap，Hashtable及其子类而言，他们采用hash算法来决定Map中key的存储，并通过hash算法

public class NoModifyCollections {
    //不可变对象都不可以增加和删除操作
    public static void main(String[] args) {
        //创建一个空的不可变的List对象
        List