多种Map简单使用和测试

向右看齐 2022-06-08 03:43 97阅读 0赞

所有的测试都是在main方法里面 注释也直接写在代码里 这里不是很深入，只是初步了解一下。

package com.listAndmap;
    
    import java.util.*;
    import java.util.concurrent.ConcurrentHashMap;
    
    /** * Created by ming on 17/9/12. */
    
    enum Operate {
        ADD, UPDATE, DELETE;
    }
    
    class comparator1 implements Comparator {
        @Override
        public int compare(Object o1, Object o2) {
            return Integer.parseInt(o1.toString()) - Integer.parseInt(o2.toString());
        }
    }
    
    public class TestMap {
    
        private static Map<String, String> hashMap = new HashMap<String, String>();//效率最快的 线程不安全
        private static Map<Integer, String> hashtable = new Hashtable<Integer, String>();//效率最差 线程安全
        private static Map<Integer, String> concurrentHashMap = new ConcurrentHashMap<Integer, String>(); //效率一般 线程安全
        //它的父类是HashMap，使用双向链表来维护键值对的次序，迭代顺序与键值对的插入顺序保持一致。LinkedHashMap需要维护元素的插入顺序，
        //so性能略低于HashMap，但在迭代访问元素时有很好的性能，因为它是以链表来维护内部顺序。
        //简单来说就是存进去的顺序和输出顺序是一致的
        private static Map<String, String> linkedHashMap = new LinkedHashMap<String, String>();
        //Map接口派生了一个SortMap子接口，SortMap的实现类为TreeMap。TreeMap也是基于红黑树对所有的key进行排序，有两种排序方式：
        //自然排序和定制排序。Treemap的key以TreeSet的形式存储，对key的要求与TreeSet对元素的要求基本一致。
        private static Map<String, String> treeMap = new TreeMap<String, String>(new comparator1());
        //WeakHashMap与HashMap的用法基本相同，区别在于：后者的key保留对象的强引用，即只要HashMap对象不被销毁，其对象所有key所引用的对象不会被垃圾回收，
        //HashMap也不会自动删除这些key所对应的键值对对象。但WeakHashMap的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被回收。
        //WeakHashMap中的每个key对象保存了实际对象的弱引用，当回收了该key所对应的实际对象后，WeakHashMap会自动删除该key所对应的键值对。
        private static Map<String, String> weakHashMap = new WeakHashMap<String, String>();
        //IdentityHashMap与HashMap基本相似，只是当两个key严格相等时，即key1==key2时，它才认为两个key是相等的 。
        //IdentityHashMap也允许使用null，但不保证键值对之间的顺序
        private static Map<String, String> identityHashMap = new IdentityHashMap<String, String>();
        //1、EnumMap中所有key都必须是单个枚举类的枚举值，创建EnumMap时必须显示或隐式指定它对应的枚举类。
        //2、EnumMap根据key的自然顺序，即枚举值在枚举类中定义的顺序，来维护键值对的次序。
        //3、EnumMap不允许使用null作为key值，但value可以
        //4、其原理就是一个对象数组，数组的下标索引就是根据Map中的key直接获取，即枚举中的ordinal值；效率比HashMap高，可以直接获取数组下标索引并访问到元素
        private static Map<Operate, String> enumMap = new EnumMap<Operate, String>(Operate.class);
    
        //TreeMap的自定义排序
        static Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return Integer.parseInt(o1.toString()) - Integer.parseInt(o2.toString());
            }
        };
    
    
        public static void main(String[] args) {
            //遍历的速度
            // TestMap.cycle();
    
            //比较linkedHashMap与hashMap的区别
            //TestMap.linkedHashMap();
    
            //枚举类map遍历
            //TestMap.enumMap();
    
            //WeakHashMap与hashMap的区别
            //TestMap.weakHashMap();
    
            //TreeMap的使用
            //TestMap.treepMap();
    
            //identityHashMap 主要就是key可以重复
            //TestMap.identityHashMap();
    
            //hashMap线程安全测试 hashtable和concurrentHashMap也可以用类似的方法
            //TestMap.hashMap();
        }
    
        //hashMap线程安全测试
        public static void hashMap() {
            Map<Integer, String> hashMap1 = new HashMap<Integer, String>();//效率最快的 线程不安全
            Thread t1 = new Thread() {
                public void run() {
                    for (int i = 0; i < 200; i++) {
                        hashMap1.put(i, String.valueOf(i));
                    }
                }
            };
            Thread t2 = new Thread() {
                public void run() {
                    for (int i = 200; i < 400; i++) {
                        hashMap1.put(i, String.valueOf(i));
                    }
                }
            };
            Thread t3 = new Thread() {
                public void run() {
                    for (int i = 400; i < 600; i++) {
                        hashMap1.put(i, String.valueOf(i));
                    }
                }
            };
            Thread t4 = new Thread() {
                public void run() {
                    for (int i = 600; i < 800; i++) {
                        hashMap1.put(i, String.valueOf(i));
                    }
                }
            };
            t1.start();
            t2.start();
            t3.start();
            t4.start();
            //放完数据后，从map中取出数据，如果map是线程安全的，那么取出的entry应该和放进去的一一对应
            for (int i = 0; i < 800; i++) {
                System.out.println(i + "=" + hashMap1.get(i));
            }
        }
    
    
        /** * 两者最主要的区别是IdentityHashMap使用的是==比较key的值，而HashMap使用的是equals() * HashMap使用的是hashCode()查找位置，IdentityHashMap使用的是System.identityHashCode(object) * IdentityHashMap理论上来说速度要比HashMap快一点 * 另外一点呢就是IdentityHashMap中key能重复，但需要注意一点的是key比较的方法是==，所以若要存放两个相同的key，就需要存放不同的地址， * <p> * 在比较以String c1=”i am good”;方式建立的字符数组时，==和以equals的比较结果是一样的，而在以String c4=new String(“i am good”); * 方式建立的数组时，两者结果却是不一样的，这是因为==比较的是内存位置，不适合拿来比较字符串，而整型等可以用==比较。equals和==的区别就在这里， * 它比较的是内存中的内容。 * <p> * 注意使用int类型的时候 俩个键值就是相等的 相同键值的就会被覆盖 而且字符串要是new出来的 不然地址一样的话还是会覆盖 */
        public static void identityHashMap() {
            identityHashMap.put(new String("xx"), "first");
            identityHashMap.put(new String("xx"), "second");
            for (Map.Entry<String, String> entry : identityHashMap.entrySet()) {
                System.out.print(entry.getKey() + " ");
                System.out.println(entry.getValue());
            }
        }
    
    
        public static void treepMap() {
            treeMap.put("2", "2");
            treeMap.put("1", "1");
            treeMap.put("3", "3");
            treeMap.put("6", "6");
            treeMap.put("5", "5");
            treeMap.put("4", "4");
            treeMap.put("8", "8");
            treeMap.put("7", "7");
            Set<Map.Entry<String, String>> entrySet = treeMap.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
    
            System.out.println("**************************************");
            TreeMap<String, String> treeMap1 = new TreeMap<String, String>(TestMap.comparator);
            treeMap1.put("2", "2");
            treeMap1.put("1", "1");
            treeMap1.put("3", "3");
            treeMap1.put("6", "6");
            treeMap1.put("5", "5");
            treeMap1.put("4", "4");
            treeMap1.put("8", "8");
            treeMap1.put("7", "7");
            Set<Map.Entry<String, String>> entrySet1 = treeMap.entrySet();
            for (Map.Entry<String, String> e : entrySet1) {
                System.out.println(e.getKey() + "=" + e.getValue());
            }
        }
    
        //WeakHashMap与hashMap的区别
        public static void weakHashMap() {
    
            String w1 = new String("W1");
            String w2 = new String("W2");
            String h1 = new String("H1");
            String h2 = new String("H2");
    
            weakHashMap.put(w1, "w1");
            weakHashMap.put(w2, "w2");
    
            hashMap.put(h1, "h1");
            hashMap.put(h2, "h2");
    
            //移除掉h1 hashMap中就只有h2了
            hashMap.remove(h1);
            // 将WeakHashMap中的w1设置null，并执行gc()。系统会回收w1
            // 结果：w1是“弱键”，被GC回收后，WeakHashMap中w1对应的键值对，也会被从WeakHashMap中删除。
            // w2是“弱键”，但它不是null，不会被GC回收；也就不会被从WeakHashMap中删除。
            // 因此，WeakHashMap中只有 w2
            // 注意：若去掉“w1=null” 或者“System.gc()”，结果都会不一样！
            w1 = null;
    
            System.gc();
    
            for (Iterator it = hashMap.keySet().iterator(); it.hasNext(); ) {
                Object key = it.next();
                System.out.println(key + "=" + hashMap.get(key));
            }
    
            for (Iterator it = weakHashMap.keySet().iterator(); it.hasNext(); ) {
                Object key = it.next();
                System.out.println(key + "=" + weakHashMap.get(key));
            }
    
        }
    
        //比较linkedHashMap与hashMap的区别
        public static void linkedHashMap() {
            hashMap.put("1", "1");
            hashMap.put("5", "5");
            hashMap.put("4", "4");
            hashMap.put("3", "3");
            hashMap.put("2", "2");
            System.out.println("*************************HashMap*************");
            for (Iterator it = hashMap.keySet().iterator(); it.hasNext(); ) {
                Object key = it.next();
                System.out.println(key + "=" + hashMap.get(key));
            }
            System.out.println("*************************LinkedHashMap*************");
            linkedHashMap.put("1", "1");
            linkedHashMap.put("5", "5");
            linkedHashMap.put("4", "4");
            linkedHashMap.put("3", "3");
            linkedHashMap.put("2", "2");
            Set<Map.Entry<String, String>> entrySet = linkedHashMap.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
    
        }
    
    
        /** * 1.Collection只能获取到值 不常用 * 2.entrySet()方式遍历之所以快与keySet()，一个原因是keySet相当与遍历了2次，一次是对key的Set集合的遍历，二次是每次遍历过程都要通过key和map.get(key) * 来获取value值。第二个原因是map.get(key)获取的时候，底层其实根据key的hashcode值经过哈希算法得到一个hash值然后作为索引映射到对应table数组的索引位置， * 这是一次密集型计算，很耗费CPU，如果有大量的元素，则会使CPU使用率飙升，影响响应速度，而entrySet()返回的set里边元素都是Map.Entry类型， * key和value就是这个类的一个属性，entry.getKey()和entry.getValue()效率肯定很高。 */
        public static void cycle() {
            for (int i = 0; i < 10000; i++) {
                hashMap.put(String.valueOf(i), String.valueOf(i));
            }
            //keySet()方法遍历
            long start = System.nanoTime();
            Set<String> setEach = hashMap.keySet();
            for (String key : setEach) {
                String value = hashMap.get(key);
            }
            long end = System.nanoTime();
            System.out.println("keySet遍历map耗时" + (end - start) / 1000 + "微秒");
    
            start = System.nanoTime();
            Collection<String> collection = hashMap.values();
            for (String value : collection) {
    
            }
            end = System.nanoTime();
            System.out.println("values遍历map(只得到值)耗时" + (end - start) / 1000 + "微秒");
    
            start = System.nanoTime();
            Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                String key = entry.getKey();
                String value = entry.getValue();
            }
            end = System.nanoTime();
            System.out.println("entrySet遍历map耗时" + (end - start) / 1000 + "微秒");
    
        }
    
    
        public static void enumMap() {
            //put方法
            enumMap.put(Operate.ADD, "add operate");
            enumMap.put(Operate.UPDATE, "update operate");
            enumMap.put(Operate.DELETE, "delete operate");
    
            //重写了toString方法
            System.out.println(enumMap);
    
            //size方法
            System.out.println(enumMap.size());
            System.out.println(enumMap.containsKey(Operate.UPDATE));
            System.out.println(enumMap.containsValue("update operate"));
            System.out.println(enumMap.get(Operate.DELETE));
    
            //remove
            enumMap.remove(Operate.UPDATE);
            System.out.println(enumMap);
    
            //key集合
            for (Operate operate : enumMap.keySet()) {
                System.out.print(operate + " ");
            }
    
            System.out.println();
            //value集合
            for (String obj : enumMap.values()) {
                System.out.print(obj + ",");
            }
    
            System.out.println();
            //key-value集合
            for (Map.Entry<Operate, String> entry : enumMap.entrySet()) {
                System.out.print(entry.getKey() + ": " + entry.getValue() + ", ");
            }
        }
    
    }