java 集合Map

1. Map集合

特点：将键映射到值的对象，一个映射不能包含重复的键; 每个键可以映射到最多一个值。无序。

Map 与 Collection集合的区别：

Map集合存储元素成对出现，双列，Collection是单列的

Map的键是唯一的，Collection 的子体系Set是唯一的

Map集合的数据结构针对键有效，与值无关

Collection的集合的数据结构只针对元素有效

功能概述：

1. 添加功能

V put(K key, V value):添加（修改）功能： 如果该键已经存在，则将值替换，并返回前一个键对应的值，第一次存储，返回Null

2. 删除功能：

void clear():移除所有的键值对元素

V remove(Object key):根据键值对删除元素，并把值返回

3. 判断功能

boolean containsKey(Object key):判断集合是否包含指定的键

boolean containsValue(Object value):判断集合是否包含指定的值

boolean isEmpty():判断集合是否为空

4. 获取功能

Set<Map,Entry<K,V>> entrySet():返回键值对对象

V get(Object key):根据键获取值

set<E> keySet():获取集合中所有键的集合

Collection<V> values():获取集合中所有值的集合

5. 长度功能

int size():返回集合键值对的个数

测试：

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        System.out.println("put:" + map.put("文章", "马伊利"));
        System.out.println("put:" + map.put("文章", "姚笛")); // 如果该键已经存在，则将值修改，并返回前一个键对应的值
        map.put("wangwang", "xiaojingzi");
        map.put("wangzi", "xiaojunzi");
        map.put("hage", "xiaoha");
        System.out.println("map:" + map);
        System.out.println(map.remove("wangwang")); // 返回键所对应的值："xiaojingzi"
        System.out.println(map.containsKey("wangzi")); // 存在返回true,不存在返回false
        System.out.println(map.size());
        
        System.out.println(map.get("文章")); // 根据键返回值，不存在返回Null

        Set<String> set = map.keySet();        // 返回集合中所有键的结合
        for (String key : set) {
            System.out.println(key);
        }

        Collection<String> con = map.values();    // 返回集合中所有值的集合
        for (String value : con) {
            System.out.println(value);
        }
        
        for(String key : set) {                    // map集合的遍历方式1
            System.out.println(key + "=" + map.get(key));
        }
        
        Set<Map.Entry<String, String>> set1 = map.entrySet();　　// map集合的遍历方式2
        for(Map.Entry<String, String> me : set1) {
            System.out.println(me.getKey() + ":" + me.getValue());
        }
    }

2. HashMap类

特点：键是哈希表的结构，可以保证键的唯一性（依赖hashCode()和equals()方法）

public static void main(String[] args) {
        HashMap<String, String> hm = new HashMap<String, String>();
        hm.put("it001", "马云");
        hm.put("it002", "马化腾");
        hm.put("it003", "乔布斯");
        hm.put("it004", "张朝阳");
        hm.put("it005", "加伯爵)");
        hm.put("it001", "比尔盖茨");

        Set<String> set = hm.keySet();
        for(String key : set) {
            String value = hm.get(key);
            System.out.println(key + "------" + value);
        }
    }

3. LinkedHashMap类

map接口的哈希表（唯一性）和链表（键有序性）实现，具有可预知的迭代顺序（存储取出顺序一致）

public static void main(String[] args) {
        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
        hm.put("1234", "hello");
        hm.put("2345", "java");
        hm.put("3456", "android");
        hm.put("1234", "hello");
        hm.put("2345", "xiaojingzi");
        
        Set<String> set = hm.keySet();
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "------" + value);
        }
    }

4. TreeMap类

特点：TreeMap是基于红黑树的Map接口的实现，可以使用自然排序和比较器排序

public static void main(String[] args) {
        TreeMap<Student, String> tm = new TreeMap<Student, String>(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("潘安", 30);
        Student s2 = new Student("诸葛亮", 38);
        Student s3 = new Student("唐伯虎", 39);
        Student s4 = new Student("春香", 50);
        Student s5 = new Student("唐伯虎", 3);
        
        tm.put(s1, "宋朝");
        tm.put(s2, "唐朝");
        tm.put(s3, "明朝");
        tm.put(s4, "清朝");
        tm.put(s5, "清朝");
        
        System.out.println(tm);
        Set<Map.Entry<Student, String>> set = tm.entrySet();
        for (Map.Entry map : set) {
            System.out.println(map.getKey() + "-------" + map.getValue());
        }
    }

例：统计输入字符串的字符的个数:

    public static void main(String[] args) {
        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        char[] chs = line.toCharArray();
        for (char ch : chs) {
            Integer i = tm.get(ch);
            if(i == null) {
                tm.put(ch, 1);
            }else {
                i++;
                tm.put(ch, i);
            }
        }
        StringBuilder sb = new StringBuilder();
        Set<Character> set = tm.keySet();
        for (Character key : set) {
            Integer value = tm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        
        String result = sb.toString();
        System.out.println("result:" + result);
    }

 例：多重嵌套

    public static void main(String[] args) {
        HashMap<String, HashMap<String, Integer>> hmap = new HashMap<String, HashMap<String, Integer>>();
        HashMap<String, Integer> smap = new HashMap<String, Integer>();
        smap.put("wangjing", 20);
        smap.put("wangjun", 21);
        HashMap<String, Integer> amap = new HashMap<String, Integer>();
        amap.put("xiaojingzi", 19);
        amap.put("xiaojunzi", 18);
        hmap.put("daming", smap);
        hmap.put("xiaoming", amap);
        
        Set<String> set = hmap.keySet();
        for (String k : set) {
            HashMap<String, Integer> ap = hmap.get(k);
            Set<String> st = ap.keySet();
            System.out.println("--------" + k + "-----");
            for(String sc : st) {
                System.out.println(sc + "-----" + ap.get(sc));
            }
        }       
    }

Hashtable和HashMap的区别：

Hashtable:线程安全，效率低，不允许null键和null值

HashMap:线程不安全，效率高，允许null键和null值