Java 集合-Map接口和三个子类实现

2017-10-31 22:05:59

• Map

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

HashMap是基于散列表实现的，插入、删除和定位元素时间复杂度平均能达到O(1)。

TreeMap基于红黑树（一种自平衡二叉查找树）实现的，时间复杂度平均能达到O(log n)。

Map的数据结构针对键值有效和值无关。

*常用方法

   public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();

        //添加元素
        //如果键是第一次存储，则返回null
        //如果键不是第一次了，则替换旧的值，并返回旧的值
        map.put("刘亦菲","20");
        map.put("章子怡", "22");
        map.put("田馥甄", "24");
        map.put("陈绮贞","22");

        //remove(key),根据键值进行删除,返回值，如果不存在，返回null
        map.remove("章子怡");

        //containsKey()
        map.containsKey("刘亦菲");

        //get(key)根据键得到值，如果没有返回null
        System.out.println(map.get("刘亦菲"));

        //keySet(),获取所有键值组成的集合
        Set<String> set = map.keySet();
        for(String s:set)
        {
            System.out.println(s+" ");
        }

        //values,获取所有值组成的集合
        Collection<String> collection= map.values();
        for(String s:collection) System.out.println(s);

        //输出
        System.out.println(map);
    }

Map集合的遍历：

A：首先获得所有的键的集合，通过键的集合来获取值；

B：直接获得键值对的集合

public class MapDemo2 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();

        //添加元素
        //如果键是第一次存储，则返回null
        //如果键不是第一次了，则替换旧的值，并返回旧的值
        map.put("刘亦菲","20");
        map.put("章子怡", "22");
        map.put("田馥甄", "24");
        map.put("陈绮贞","22");

        //遍历方法1:通过键来找值
        Set<String> set= map.keySet();
        for(String s:set) {
            String value= map.get(s);
            System.out.println(s+"="+value);
        }

        //遍历方法2:直接得到键值对的集合
        Set<Map.Entry<String,String>> set2 = map.entrySet();
        for(Map.Entry<String,String> m:set2){
            System.out.println(m.getKey()+"="+m.getValue());
        }

    }
}

Map的三个子类实现：

　　　　　　　　　　HashMap

　　　　　　　　　　LinkedHashMap

　　　　　　　　　　TreeMap

~ HashMap

HashMap：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。

注意：HashMap底层依赖hashcode和equals，在键值为对象的时候需要重写这两个方法，这两个方法都可以通过右键直接生成。

*构造方法

*常用方法

public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String,String>();

        //添加元素
        //如果键是第一次存储，则返回null
        //如果键不是第一次了，则替换旧的值，并返回旧的值
        map.put("刘亦菲","20");
        map.put("章子怡", "22");
        map.put("田馥甄", "24");
        map.put("陈绮贞","22");

        //遍历方法1:通过键来找值
        Set<String> set= map.keySet();
        for(String s:set) {
            String value= map.get(s);
            System.out.println(s+"="+value);
        }

        //遍历方法2:直接得到键值对的集合
        Set<Map.Entry<String,String>> set2 = map.entrySet();
        for(Map.Entry<String,String> m:set2){
            System.out.println(m.getKey()+"="+m.getValue());
        }

    }
}

~ LinkedHashMap

LinkedHashMap：是Map接口的哈系表和链表的实现，具有可预知的迭代顺序。

用法和HashMap完全一致。

public class MapDemo2 {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String,String>();

        //添加元素
        //如果键是第一次存储，则返回null
        //如果键不是第一次了，则替换旧的值，并返回旧的值
        map.put("刘亦菲","20");
        map.put("章子怡", "22");
        map.put("田馥甄", "24");
        map.put("陈绮贞","22");

        //遍历方法1:通过键来找值
        Set<String> set= map.keySet();
        for(String s:set) {
            String value= map.get(s);
            System.out.println(s+"="+value);
        }

        //遍历方法2:直接得到键值对的集合
        Set<Map.Entry<String,String>> set2 = map.entrySet();
        for(Map.Entry<String,String> m:set2){
            System.out.println(m.getKey()+"="+m.getValue());
        }

    }
}

~ TreeMap

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

此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。这些算法是 Cormen、Leiserson 和 Rivest 的 Introduction to Algorithms 中的算法的改编。

注意，此实现不是同步的。如果多个线程同时访问一个映射，并且其中至少一个线程从结构上修改了该映射，则其必须 外部同步。

注意：类为键值的话需要注意，如果是无参构造，则类需要实现Comparable接口；或者使用带比较器的构造方法。

public class Demo3 {
    public static void main(String[] args) {
        TreeMap<Student,String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 主要条件,这样的话是递增排序
                int num = o1.getAge() - o2.getAge();

                // 次要条件
                int num2 = num==0?o1.getName().compareTo(o2.getName()):num;
                return num2;

            }
        });

        Student s1 = new Student("刘亦菲", 29);
        Student s2 = new Student("章子怡", 25);
        Student s3 = new Student("刘亦菲", 28);

        treeMap.put(s1,"01");
        treeMap.put(s2,"02");
        treeMap.put(s3,"03");

        Set<Student> set= treeMap.keySet();
        for(Student s:set) {
            String value= treeMap.get(s);
            System.out.println(s+"="+value);
        }

    }
}

~ Hashtable 和 HashMap 的区别

Hashtable：线程安全，效率低。不允许null键和null值；（显然这养的命名是不规范的，但是由于其出现太早，改的话很不方便，于是就没有修改）

HashMap：线程不安全，效率高。允许null键和null值；（是用来替代Hashtable的）