Day18_Map集合概述和特点

set集合：
HashSet保证唯一性：equals(),hashCode():
if (e.hash == hash && ((k = e.key) == key || key.equals(k))

TreeSet红黑树保证唯一性：
无参构造：实现泛型接口Comparable<T>中的compareTo方法（返回负数左孩子，正数右孩子），中序遍历
可以具体实现 Comparable<Students>

有参构造函数：实现Comparator接口，重写compare方法
建立MyComparaor类
public class MyComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.getAge() - o2.getAge();
        if (o1.getAge() == o2.getAge())
            num = o1.getName().compareTo(o2.getName());
        //String重写了compareTo方法
        return num;
    }
}

TreeSet<Student> hs = new TreeSet<Student>(new MyComparator());

一.Map集合：HashMap、LinkedHashMap、TreeMap

1.Map集合概述和特点

引入：作为学生来说，是根据学号来区分不同的学生的，那么假设我现在已经知道了学生的学号，我要根据学号获取学生的姓名；此时前面的集合结构，只能把学号和姓名等作为一个对象的成员，而后存储这个对象，将来遍历对象的时候判断获取名称。
针对这种需求，已知学号就知道姓名，java提供了Map集合
java.util 接口 Map<K,V>,K为键，V为映射值，将键映射到值得对象。。
特点：
一个映射不能包含重复的键，每个键最多只能映射到一个键——————键唯一，但值可重复（键类似Set，值类似List）
Map和Collection集合得区别：
Map存储元素是成对出现，键唯一，值可重复，Map数据结构针对键有效，更值无关；
Collection是单独出现的，Collection得儿子Set是唯一得，List是可重复的，数据结构针对元素有效；

2.Map集合得功能概述

a. 添加

V put(K key, V value)//添加键值对，
如果key已经存在，返回原来的value，并用新value取代旧的，
否则返回null
put方法源码类似HashSet由key得hash和equals方法判断
void putAll(Map<? extends K, ? extends V> n)//

b.删除

void clear()//移除所有映射关系，不建议使用
V remove(Object key)//根据key删除值，并返回

c.判断

boolean containsKey(Object key)//是否包含键
boolean containsValue(Object value)//是否包含值
boolean isEmpty()//

d.获取

Set<Map.Entry<K,V>> entrySet()
返回键值对对象得集合
然后调用Map.Entry接口得getKey和getValue方法


V get(Object key)//根据键获取值
Set<K> keySet()//获取Map中所有键得集合
Collection<V> values()//获取所有值得集合

e.长度

int size()//返回键值对得对数

3.Map集合得遍历

A：key找value

Map<String, String> map = new HashMap<String, String>();

        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");

        Set<String> keyMap = map.keySet();
        for (String s : keyMap)
        {
            System.out.println(map.get(s));
        }

B.对象找键值

Map<String, String> map = new HashMap<String, String>();

        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");
        
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> s : set)
        {
            //Map.Entry是一个接口,里面由getKey和getValue方法
            System.out.println(s.getKey());
            System.out.println(s.getValue());
        }

两种方法得比较

两种遍历比较.png

二.HashMap类

key为哈希表结构，可保证键唯一

1.key和value为不同类型得案例

A：key为String，value为String


        HashMap<String, String> hm = new HashMap<String, String>();
        hm.put("it001", "马云");
        hm.put("it003", "马化腾");
        hm.put("it004", "乔布斯");
        hm.put("it005", "张朝阳");
        hm.put("it002", "求伯君");
        hm.put("it002", "盖茨");

        System.out.println(hm);//重写了toString
        //{it004=乔布斯, it003=马化腾, it005=张朝阳, it002=盖茨, it001=马云}
//String重写了hashCode和equals方法可以保证唯一性

B：key为Integer，value为String

        hm.put(27, "马云");
        hm.put(30, "马化腾");
        hm.put(28, "乔布斯");
        hm.put(29, "张朝阳");
//        hm.put(008, "求伯君");//8进制，会报错
        hm.put(29, "盖茨");
        System.out.println(hm);//重写了toString

C：key为String，value为Student

HashMap<String, Student> hm = new HashMap<String, Student>();
        Student s1 = new Student("周星驰", 58);
        Student s2 = new Student("刘德华", 55);
        Student s3 = new Student("梁朝伟", 54);
        Student s4 = new Student("刘嘉玲", 50);

        // 添加元素
        hm.put("9527", s1);
        hm.put("9522", s2);
        hm.put("9524", s3);
        hm.put("9529", s4);

        // 遍历
        Set<String> set = hm.keySet();
        for (String key : set) {
            // 注意了：这次值不是字符串了
            // String value = hm.get(key);
            Student value = hm.get(key);
            System.out.println(key + "---" + value.getName() + "---"
                    + value.getAge());
        }

D：key为Student，value为String
因为自定义引用作为键，所以要重写equals和hashcode方法保证唯一性

import java.util.Objects;

/**
 * @author : liulinzhi
 * @date: 2020/06/10/15:37
 * @description:
 */
public class Student {
    private String name;
    private int age;
    public Student()
    {}
    public Student(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

三.LinkedHashMap类

哈希表和链表实现，key有序（先进去先打印谁）
哈希表保证key唯一，链表保证有序（存储和取出得顺序一致）

四.TreeMap类

key为红黑树结构，保证键得排序和唯一性
A：key为String，value为String

B：key为Student，value为String
内部匿名类实现Comparator<Student>接口

TreeMap<Student, String> tm = new TreeMap<Student, String>(
                new Comparator<Student>() {//内部类实现
                    @Override
                    public int compare(Student s1, Student s2) {
                        // 主要条件
                        int num = s1.getAge() - s2.getAge();
                        // 次要条件
                        int num2 = num == 0 ? s1.getName().compareTo(
                                s2.getName()) : num;
                        return num2;
                    }
                });

        // 创建学生对象
        Student s1 = new Student("潘安", 30);
        Student s2 = new Student("柳下惠", 35);
        Student s3 = new Student("唐伯虎", 33);
        Student s4 = new Student("燕青", 32);
        Student s5 = new Student("唐伯虎", 33);

        // 存储元素
        tm.put(s1, "宋朝");
        tm.put(s2, "元朝");
        tm.put(s3, "明朝");
        tm.put(s4, "清朝");
        tm.put(s5, "汉朝");

        // 遍历
        Set<Student> set = tm.keySet();
        for (Student key : set) {
            String value = tm.get(key);
            System.out.println(key.getName() + "---" + key.getAge() + "---"
                    + value);
        }

五.Map集合案例

统计字符串中每个字符出现得次数
利用Map得key唯一性，累加value即可

String demo = "aaaffffkkkkiiii0000999";
        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        char[] demo_char_list = demo.toCharArray();
        int value_tempt = 1;
        for (int i = 0; i < demo_char_list.length; i++)
        {
            char c = demo_char_list[i];
            value_tempt = 1;
            if (hm.containsKey(c))
            {
                value_tempt = hm.get(c) + 1;
            }
            hm.put(c, value_tempt);
        }
        System.out.println(hm);

六.集合嵌套

HashMap集合嵌套HashMap集合

HashMap<String, HashMap<String, Integer>> czbkMap = new HashMap<String, HashMap<String, Integer>>();

        // 创建基础班集合对象
        HashMap<String, Integer> jcMap = new HashMap<String, Integer>();
        // 添加元素
        jcMap.put("陈玉楼", 20);
        jcMap.put("高跃", 22);
        // 把基础班添加到大集合
        czbkMap.put("jc", jcMap);

        // 创建就业班集合对象
        HashMap<String, Integer> jyMap = new HashMap<String, Integer>();
        // 添加元素
        jyMap.put("李杰", 21);
        jyMap.put("曹石磊", 23);
        // 把基础班添加到大集合
        czbkMap.put("jy", jyMap);
        
        //遍历集合
        Set<String> czbkMapSet = czbkMap.keySet();
        for(String czbkMapKey : czbkMapSet){
            System.out.println(czbkMapKey);
            HashMap<String, Integer> czbkMapValue = czbkMap.get(czbkMapKey);
            Set<String> czbkMapValueSet = czbkMapValue.keySet();
            for(String czbkMapValueKey : czbkMapValueSset){
                Integer czbkMapValueValue = czbkMapValue.get(czbkMapValueKey);
                System.out.println("\t"+czbkMapValueKey+"---"+czbkMapValueValue);
            }
        }

HashMap嵌套ArrayList集合

package cn.itcast_05;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 *需求：
 *假设HashMap集合的元素是ArrayList。有3个。
 *每一个ArrayList集合的值是字符串。
 *元素我已经完成，请遍历。
 *结果：
 *       三国演义
 *          吕布
 *          周瑜
 *       笑傲江湖
 *          令狐冲
 *          林平之
 *       神雕侠侣
 *          郭靖
 *          杨过  
 */
public class HashMapIncludeArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();

        // 创建元素集合1
        ArrayList<String> array1 = new ArrayList<String>();
        array1.add("吕布");
        array1.add("周瑜");
        hm.put("三国演义", array1);

        // 创建元素集合2
        ArrayList<String> array2 = new ArrayList<String>();
        array2.add("令狐冲");
        array2.add("林平之");
        hm.put("笑傲江湖", array2);

        // 创建元素集合3
        ArrayList<String> array3 = new ArrayList<String>();
        array3.add("郭靖");
        array3.add("杨过");
        hm.put("神雕侠侣", array3);
        
        //遍历集合
        Set<String> set = hm.keySet();
        for(String key : set){
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for(String s : value){
                System.out.println("\t"+s);
            }
        }
    }
}

ArrayList嵌套HashMap

package cn.itcast_05;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 ArrayList集合嵌套HashMap集合并遍历。
 需求：
 假设ArrayList集合的元素是HashMap。有3个。
 每一个HashMap集合的键和值都是字符串。
 元素我已经完成，请遍历。
 结果：
 周瑜---小乔
 吕布---貂蝉

 郭靖---黄蓉
 杨过---小龙女

 令狐冲---任盈盈
 林平之---岳灵珊
 */
public class ArrayListIncludeHashMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();

        // 创建元素1
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("周瑜", "小乔");
        hm1.put("吕布", "貂蝉");
        // 把元素添加到array里面
        array.add(hm1);

        // 创建元素1
        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");
        // 把元素添加到array里面
        array.add(hm2);

        // 创建元素1
        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("林平之", "岳灵珊");
        // 把元素添加到array里面
        array.add(hm3);

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

七.HashMap和Hashtable得区别

Hashtable：线程安全，效率低，不允许null键和null值；
HashMap：线程不安全，效率高，允许null键和null值

List，Set，Map等接口是否都继承自Map接口
List，Set继承自Collection接口

八.Collections工具类

A：概述：Collection是接口，而加s之后就变成了工具类，此类完全再Collection上操作或返回collection得静态方法组成

 * Collections:是针对集合进行操作的工具类，都是静态方法。
 * 
 * 面试题：
 * Collection和Collections的区别?
 * Collection:是单列(Map是双列)集合的顶层接口，有子接口List和Set。
 * Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
 * 
 * 要知道的方法
 * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
 * public static <T> int binarySearch(List<?> list,T key):二分查找
 * public static <T> T max(Collection<?> coll):最大值
 * public static void reverse(List<?> list):反转
 * public static void shuffle(List<?> list):随机置换

ArrayList存储自定义对象并排序

@Override
    public int compareTo(Student s) {
        int num = this.age - s.age;
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }

package cn.itcast_02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * Collections可以针对ArrayList存储基本包装类的元素排序，存储自定义对象可不可以排序呢?
 */
public class CollectionsDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List<Student> list = new ArrayList<Student>();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("刘晓曲", 28);
        Student s4 = new Student("武鑫", 29);
        Student s5 = new Student("林青霞", 27);

        // 添加元素对象
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);

        // 排序
        // 自然排序
        // Collections.sort(list);
        // 比较器排序
        // 如果同时有自然排序和比较器排序，以比较器排序为主
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getAge() - s1.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
                        : num;
                return num2;
            }
        });

        // 遍历集合
        for (Student s : list) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}