1.Map集合

Map<K,V>，K：建的类型，V：值的类型，键是唯一的，使用HashMap实现类创建对象

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

        //使用put添加元素
        map.put(1,"张嘉圣杰");
        map.put(2,"张飘飘");
        map.put(3,"郭少");

        System.out.println(map); // {1=张嘉圣杰, 2=张飘飘, 3=郭少}
    }

2.Map集合方法

方法名	说明
V put(K key, V value)	添加元素，将指定的值与该映射中的指定键相关联
V remove(Object key)	删除此键的键值元素
void clear()	删除所有的键值元素
boolean containsKey(Object key)	判断是否包含指定的键
boolean containsValue(Object value)	判断是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	键值对的个数

Map集合的获取功能

方法名	说明
V get(Object key)	根据指定键获取值
Set<K> keySet()	获取所有键的集合
Collection<V> values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值的集合

3.Map集合的遍历

3.1方式一

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1,"张嘉圣杰");
        map.put(2,"张飘飘");
        map.put(3,"郭少");

        //获取所有建的集合，用keySet()方法实现
        Set<Integer> set = map.keySet();

        //遍历键的集合，获取到每一个键
        for (Integer integer:set){
            //根据键找出对应的值，用get(Object key)方法实现
            String s = map.get(integer);
            System.out.println(integer+","+s);
        }
        /**1,张嘉圣杰
         2,张飘飘
         3,郭少
         */
    }

3.2方式二

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "张嘉圣杰");
        map.put(2, "张飘飘");
        map.put(3, "郭少");

        //获取所有键值对的集合,用Set<Map.Entry<K,V>> entrySet
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

        //遍历键值集合，得到每一个键值
        for (Map.Entry<Integer, String> entry : entrySet) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "," + value);
        }
        /**1,张嘉圣杰
         2,张飘飘
         3,郭少
         */
    }

4.Map学生案例

4.1创建学生类（如果学生对象是键，需要重写hashCode和equals方法）

public class Student {
    private String name;
    private int age;
    /*
    -----------------------
    */
    }

4.2 测试类，创建Map集合，学生对象，添加学生对象，遍历学生对象（键找值，键值对找键值）

    public static void main(String[] args) {
        //创建HashMap集合对象
        Map<String,Student> map=new HashMap<String,Student>();

        //创建学生对象
        Student s1 =new Student("张嘉圣杰",22);
        Student s2=new Student("张飘飘",21);
        Student s3=new Student("郭少",20);

        //把学生添加到集合中
        map.put("001",s1);
        map.put("002",s2);
        map.put("003",s3);

        //遍历集合
        //方式一,键找值
        Set<String> keySet = map.keySet();

        for (String key:keySet){
            Student student = map.get(key);
            System.out.println(key+","+student.getName()+","+student.getAge());
        }
        /**001,张嘉圣杰,22
         002,张飘飘,21
         003,郭少,20
         */

        //方式二，键值对找键值
        Set<Map.Entry<String, Student>> entrySet = map.entrySet();

        for (Map.Entry<String, Student> entry:entrySet){
            String key = entry.getKey();
            Student student = entry.getValue();
            System.out.println(key+","+student.getName()+","+student.getAge());
        }
        /**001,张嘉圣杰,22
         002,张飘飘,21
         003,郭少,20
         */

    }

5.ArrayList嵌套HashMap

        //创建集合
        ArrayList<HashMap<Integer, String>> array = new ArrayList<HashMap<Integer, String>>();

        //添加元素
        HashMap<Integer, String> hashMap1 = new HashMap<Integer, String>();
        hashMap1.put(1, "张嘉圣杰");
        hashMap1.put(2, "张飘飘");
        array.add(hashMap1);

        HashMap<Integer, String> hashMap2 = new HashMap<Integer, String>();
        hashMap2.put(3, "郭少");
        hashMap2.put(4, "佳洁");
        array.add(hashMap2);

        //遍历
        for (HashMap<Integer, String> hashMap : array) {
            Set<Integer> keySet = hashMap.keySet();
            for (Integer key : keySet) {
                String s = hashMap.get(key);
                System.out.println(key + "," + s);
            }
        }
        /**1,张嘉圣杰
         2,张飘飘
         3,郭少
         4,佳洁
         */

6.HashMap嵌套ArrayList

        //创建集合
        HashMap<Integer, ArrayList<String>> hashMap = new HashMap<Integer, ArrayList<String>>();

        ArrayList<String> array1 = new ArrayList<String>();
        array1.add("张嘉圣杰");
        array1.add("郭少");

        ArrayList<String> array2 = new ArrayList<String>();
        array2.add("张飘飘");
        array2.add("佳洁");

        hashMap.put(1, array1);
        hashMap.put(2, array2);

        //遍历
        Set<Integer> keySet = hashMap.keySet();
        for (Integer key : keySet) {
            ArrayList<String> values = hashMap.get(key);
            for (String s : values) {
                System.out.println(key + "," + s);
            }
        }
        /**1,张嘉圣杰
         1,郭少
         2,张飘飘
         2,佳洁
         */

7.统计字符串中每个字符出现的次数

        Scanner sc = new Scanner(System.in);
        String string = sc.next();
        System.out.println("请输入字符串：");

        //键是Character，值是Integer,可以使用TreeMap
        HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();

        //遍历字符串得到每一个字符
        for (int i = 0; i < string.length(); i++) {
            char key = string.charAt(i);

            //字符作为键，找对应的值
            Integer value = hashMap.get(key);

            if (value == null) {
                hashMap.put(key, 1);
            } else {
                value++;
                hashMap.put(key, value);
            }

        }

        StringBuilder sb = new StringBuilder();

        //遍历集合
        Set<Character> keySet = hashMap.keySet();

        for (Character key : keySet) {
            Integer value = hashMap.get(key);
            sb.append(key).append("（").append(value).append("）");
        }
        String s = sb.toString();
        System.out.println(s);
        /**
         * aaabbbcccbbbnm
         * 请输入字符串：
         * a（3）b（6）c（3）m（1）n（1）
         * */