Java集合（超详细-含源码）

今天是上天赐予你的礼物

已于 2023-03-03 17:55:10 修改

阅读量736

点赞数 4

文章标签： java Powered by 金山文档

于 2023-03-03 17:34:59 首次发布

本文链接：https://blog.csdn.net/m0_63975764/article/details/129298792

版权

一集合体系结构

集合的体系结构分为单列集合和双列集合

二 Collection单列集合

Collection是单列集合的祖宗接口，他的功能是全部单列集合都可以继承使用的。

单列集合接口下又分为List和Set两个接口，为何有分为两个接口呢？因为这两个接口实现的集合有各自的特点，我们应该根据问题选择合适的接口去解决！

List系列集合：添加的元素是有序、可重复、有索引

Set系列集合：添加的元素是无序、不重复、无索引

是否有序：有序是指向集合添加元素的顺序，和取元素的顺序是确定的，无序是不确定的。

是否可重复：不可重复是指集合中的元素是唯一的，不可以重复，可重复是指元素不是唯一的。

有无索引：有索引是指集合中每一个元素都有对应的索引值，可以通过索引获取对应的元素，无索引就是不能通过索引获取元素。

2.1常见的方法

这是方法是Collection集合中共性的方法，List和Set集合都可以使用这些方法。

/*
        public boolean add(E e)             添加
        public void clear()                 清空
        public boolean remove(E e)          删除
        public boolean contains(Object obj) 判断是否包含
        public boolean isEmpty()            判断是否为空
        public int size()                   集合长度


       注意点：
        Collection是一个接口,我们不能直接创建他的对象。
        所以，现在我们学习他的方法时，只能创建他实现类的对象。
        实现类：ArrayList
*/
        //目的：为了学习Collection接口里面的方法
        //自己在做一些练习的时候，还是按照之前的方式去创建对象。
        Collection<String> coll = new ArrayList<>();


        //1.添加元素
        //细节1：如果我们要往List系列集合中添加数据，那么方法永远返回true，因为List系列的是允许元素重复的。
        //细节2：如果我们要往Set系列集合中添加数据，如果当前要添加元素不存在，方法返回true，表示添加成功。
        //                                       如果当前要添加的元素已经存在，方法返回false，表示添加失败。
        //                                       因为Set系列的集合不允许重复。
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);

        //2.清空
        //coll.clear();

        //3.删除
        //细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
        //细节2：方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false
        //如果要删除的元素不存在，就会删除失败。
        System.out.println(coll.remove("aaa"));
        System.out.println(coll);


        //4.判断元素是否包含
        //细节：底层是依赖equals方法进行判断是否存在的。
        //所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。
        boolean result1 = coll.contains("bbb");
        System.out.println(result1);



        //5.判断集合是否为空
        boolean result2 = coll.isEmpty();
        System.out.println(result2);//false


        //6.获取集合的长度
        coll.add("ddd");
        int size = coll.size();
        System.out.println(size);//3

    }

2.2 Collection的遍历方式

collection的遍历方式分为三种：

1.迭代器遍历

2.增强for遍历

3.Lambda表达式遍历

这里有个小疑问为何不可以是用普通for遍历呢？

因为Set系列集合是无索引的，所以不能通过索引获取对应的元素，也就不能使用for循环进行遍历。

2.2.1 迭代器遍历

迭代器在Java中的类是Iterator,迭代器是集合专用的遍历方式。

/*
            Collection系列集合三种通用的遍历方式：
                1.迭代器遍历
                2.增强for遍历
                3.lambda表达式遍历


             迭代器遍历相关的三个方法：
                    Iterator<E> iterator()  ：获取一个迭代器对象
                    boolean hasNext()       ：判断当前指向的位置是否有元素
                    E next()                ：获取当前指向的元素并移动指针
        */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头，默认指向集合的0索引处
        Iterator<String> it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情：获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }

细节注意点：

当指针指向没有元素的地方，如果调用next()方法获取元素，就会报错NoSuchElementException

迭代器遍历完毕，指针不会复位

循环中只能用一次next方法

迭代器遍历时，不能用集合的方法进行增加或者删除，会报并发修改异常。

如果我实在要删除：那么可以用迭代器提供的remove方法进行删除。

如果我要添加，暂时没有办法。

2.2.2 增强for遍历

增强for的底层就是迭代器，为了简化迭代器的代码书写的。

它是JDK5之后出现的，其内部原理就是一个Iterator迭代器。

所有的单例集合和数组才能用增强for进行遍历。

格式

 /* Collection系列集合三种通用的遍历方式：
        1.迭代器遍历
        2.增强for遍历
        3.lambda表达式遍历

        增强for格式：
            for(数据类型 变量名: 集合/数组){

            }

        快速生成方式：
            集合的名字 + for 回车

        */


        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");

        //2.利用增强for进行遍历
        //注意点：
        //s其实就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据
        for(String s : coll){
            s = "qqq";
        }

        System.out.println(coll);//zhangsan lisi wangwu

增强for细节:

修改增强for中的变量，不会改变集合中原本的数据。

2.2.3 Lambda表达式遍历

得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

/* Collection系列集合三种通用的遍历方式：
        1.迭代器遍历
        2.增强for遍历
        3.lambda表达式遍历

        lambda表达式遍历：
                default void forEach(Consumer<? super T> action):
        */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");
        //2.利用匿名内部类的形式
        //底层原理：
        //其实也会自己遍历集合，依次得到每一个元素
        //把得到的每一个元素，传递给下面的accept方法
        //s依次表示集合中的每一个数据
       /* coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式简写
        coll.forEach(s -> System.out.println(s));

三 List集合

3.1 List集合的特点：

有序：存和取的元素顺序一致

有索引：可以通过索引操作元素

可重复：存取的元素可以重复

3.2 List集合特有方法

Collection的方法List都继承了

List集合因为有索引，所以多了很多索引操作的方法。

/*

        List系列集合独有的方法：
            void add(int index,E element)       在此集合中的指定位置插入指定的元素
            E remove(int index)                 删除指定索引处的元素，返回被删除的元素
            E set(int index,E element)          修改指定索引处的元素，返回被修改的元素
            E get(int index)                    返回指定索引处的元素
        */


        //1.创建一个集合
        List<String> list = new ArrayList<>();

        //2.添加元素
        list.add("aaa");
        list.add("bbb");//1
        list.add("ccc");


        void add(int index,E element)       在此集合中的指定位置插入指定的元素
        //细节：原来索引上的元素会依次往后移
        list.add(1,"QQQ");

        //E remove(int index)                 删除指定索引处的元素，返回被删除的元素
        String remove = list.remove(0);
        System.out.println(remove);//aaa


        //E set(int index,E element)          修改指定索引处的元素，返回被修改的元素
        String result = list.set(0, "QQQ");
        System.out.println(result);

        // E get(int index)                    返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);


        //3.打印集合
        System.out.println(list);

List系列集合中的两个删除方法

直接删除元素

通过索引删除

//List系列集合中的两个删除的方法
        //1.直接删除元素
        //2.通过索引进行删除

        //1.创建集合并添加元素
        List<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);


        //2.删除元素
        //请问：此时删除的是1这个元素，还是1索引上的元素？
        //为什么？
        //因为在调用方法的时候，如果方法出现了重载现象
        //优先调用，实参跟形参类型一致的那个方法。

        //list.remove(1);


        //手动装箱，手动把基本数据类型的1，变成Integer类型
        Integer i = Integer.valueOf(1);

        list.remove(i);

        System.out.println(list);

3.3 List集合的遍历方式

迭代器遍历

列表迭代器遍历

增强for遍历

Lamdba表达式遍历

普通for循环（因为List集合存在索引）

/*
            List系列集合的五种遍历方式：
                1.迭代器
                2.列表迭代器
                3.增强for
                4.Lambda表达式
                5.普通for循环
         */


        //创建集合并添加元素
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //1.迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }


        //2.增强for
        //下面的变量s，其实就是一个第三方的变量而已。
        //在循环的过程中，依次表示集合中的每一个元素
        for (String s : list) {
            System.out.println(s);
        }

        //3.Lambda表达式
        //forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
        //并把每一个元素传递给下面的accept方法
        //accept方法的形参s，依次表示集合中的每一个元素
        list.forEach(s->System.out.println(s) );


        //4.普通for循环
        //size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素
        for (int i = 0; i < list.size(); i++) {
            //i:依次表示集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }

        // 5.列表迭代器
        //获取一个列表迭代器的对象，里面的指针默认也是指向0索引的

        //额外添加了一个方法：在遍历的过程中，可以添加元素
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()){
            String str = it.next();
            if("bbb".equals(str)){
                //qqq
                it.add("qqq");
            }
        }
        System.out.println(list);

四 ArrayList集合

ArrayList底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素

因为ArrayList是List的实现类，AarryList和List集合中的方法相同

4.1 ArrayList集合的底层原理

4.2 底层源码

add()方法源码解析

当向ArrayList添加元素时，底层先判断集合的长度和存储数据的数组长度是否相等，如果不相等，还有存储空间，直接将元素添加到数组的末尾。如果相等，说明集合的容量已经满了，这时候就会调用grow(）方法进行扩容，grow()方法会传入装满所有元素所需的最小容量.

如果是第一次添加元素，底层会取在装满所有元素所需的最小容量和默认创建容量大小为10中的最大值作为集合的容量并创建新数组，最后将添加的数据赋值到索引为0的数组位置中，size+1。

如果不是第一次添加，底层会取装满所有元素所需的最小容量和默认需要扩容大小中最大的作为新数组的长度创建数组，并将原来的数据赋值到新数组当中，并将添加的元素赋值到索引为size的数组地址中，size+1;

第一次添加数组

第十一次添加数组

五 LinkedList集合

LinkedList集合底层是双链表，查询慢，增删快，但是如果操作的首尾元素，速度也是极快的

LinkedList本身多了很多直接操作首尾元素特有API。

5.1 LinkedList独有方法

5.2 LinkedList底层源码

LinkedList在使用无参构造函数创建实例时，会在堆中创建一个对象，对象里的first和last节点都初始化为空，此时再调用linkLast方法添加元素，底层会新建一个node对象，将这个node对象的前置节点赋值成last,此时因为没有元素，所有last为空，l为空代表没有元素，此节点作为头结点。再次添加元素时，此时的last节点代表上一个节点的后置节点，创建新的节点，此节点的前置节点赋值为上一个节点的后置节点，而因为l不为空，上一个节点的后置节点指向当前的新节点。因此构成了双向链表。

5.3 Iterator迭代器底层源码

六 Set集合

6.1 Set集合特点

无序：存取顺序不一致

不重复：可以去除重复

无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素

6.2 Set集合的实现类

HashSet：无序、不重复、无索引

LinkedHashSet：有序、不重复、无索引

TreeSet：可排序、不重复、无索引

6.3 Set接口方法

Set接口中的方法上基本上与Colllection的API一致

/*
           利用Set系列的集合，添加字符串，并使用多种方式遍历。
            迭代器
            增强for
            Lambda表达式

        */


        //1.创建一个Set集合的对象
        Set<String> s = new HashSet<>();

        //2,添加元素
        //如果当前元素是第一次添加，那么可以添加成功，返回true
        //如果当前元素是第二次添加，那么添加失败，返回false
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        //无序
        //System.out.println(s);//[李四, 张三, 王五]

        //迭代器遍历
       Iterator<String> it = s.iterator();
        while (it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }


        //增强for
       for (String str : s) {
            System.out.println(str);
       }

        // Lambda表达式
        s.forEach( str->System.out.println(str));

七 HashSet集合

无序、不重复、无索引

7.1 HashSet底层数据结构

HashSet集合底层采用哈希表存储数据

哈希表是一种对于增删改查数据性能都较好的结构

哈希表组成

JDK8之前：数组+链表

JDK8开始：数组+链表+红黑树

哈希值

根据hashcoD方法算出来的int类型的整数

该方法定义在Object类中，所有对象都可以调用，默认使用地址值进行计算

一般情况下，会重写hashCode放法，利用对象内部的属性值计算哈希值

对象的哈希值特点

如果没有重写hashCode()方法，不同对象计算出的哈希值是不同的

如果重写了hashCode()方法，不同的对象只要属性相同，计算出的哈希值是一样的

在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。（哈希碰撞）

/*
            哈希值：
                对象的整数表现形式
                1. 如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
                2. 如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
                3. 但是在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。（哈希碰撞）

         */

        //1.创建对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("zhangsan",23);

        //2.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
        //  如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
        System.out.println(s1.hashCode());//-1461067292
        System.out.println(s2.hashCode());//-1461067292


        //在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。
        //哈希碰撞
        System.out.println("abc".hashCode());//96354
        System.out.println("acD".hashCode());//96354

7.2 HashSet底层原理

八 LinkedHashSet集合

有序、不重复、无索引

这里的有序指的是保证存储和取出的元素顺序一致

原理：底层数据结构依然是哈希表、只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

//1.创建4个学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);
        Student s4 = new Student("zhangsan",23);


        //2.创建集合的对象
        LinkedHashSet<Student> lhs = new LinkedHashSet<>();


        //3.添加元素
        System.out.println(lhs.add(s3));
        System.out.println(lhs.add(s2));
        System.out.println(lhs.add(s1));
        System.out.println(lhs.add(s4));

        //4.打印集合
        System.out.println(lhs);//s1,s2,s3,s4

对于HashSe和LinkedHashSet的使用，要根据不同的需求选择何时的数据结构

如果要数据去重，默认使用HashSet,如果要求去重且存取有序，才使用LinkedHashSet

九 TreeSet集合

9.1 TreeSet的特点

不重复、无索引、可排序

可排序：按照元素的默认规则（从小到大）排序。

TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都比较好。

/*
        *
        *       需求：利用TreeSet存储整数并进行排序
        *
        * */


        //1.创建TreeSet集合对象
        TreeSet<Integer> ts = new TreeSet<>();

        //2.添加元素
        ts.add(4);
        ts.add(5);
        ts.add(1);
        ts.add(3);
        ts.add(2);

        //3.打印集合
        //System.out.println(ts);

        //4.遍历集合（三种遍历）
        //迭代器
        Iterator<Integer> it = ts.iterator();
        while(it.hasNext()){
            int i = it.next();
            System.out.println(i);
        }

        System.out.println("--------------------------");
        //增强for
        for (int t : ts) {
            System.out.println(t);
        }
        System.out.println("--------------------------");
        //lambda
        ts.forEach( i-> System.out.println(i));

9.2 TreeSet集合默认的规则

对于数值类型：Integer、Double,默认按照从小到大的顺序进行排序。

对于字符、字符串类型：按照字符在ASCLL码表中的数字升序进行排列


/*
            需求：创建TreeSet集合，并添加3个学生对象
            学生对象属性：
                姓名，年龄。
                要求按照学生的年龄进行排序
                同年龄按照姓名字母排列（暂不考虑中文）
                同姓名，同年龄认为是同一个人

            方式一：
                默认的排序规则/自然排序
                Student实现Comparable接口，重写里面的抽象方法，再指定比较规则
        */


        //1.创建三个学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);
        Student s4 = new Student("zhaoliu",26);


        //2.创建集合对象
        TreeSet<Student> ts = new TreeSet<>();

        //3.添加元素
        ts.add(s3);
        ts.add(s2);
        ts.add(s1);
        ts.add(s4);

        //4.打印集合
        System.out.println(ts);


        //TreeSet 底层是红黑树





public class Student implements Comparable<Student>{
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    @Override
    //this：表示当前要添加的元素
    //o：表示已经在红黑树存在的元素

    //返回值：
    //负数：表示当前要添加的元素是小的，存左边
    //正数：表示当前要添加的元素是大的，存右边
    //0 :表示当前要添加的元素已经存在，舍弃
    public int compareTo(Student o) {
        System.out.println("--------------");
        System.out.println("this:" + this);
        System.out.println("o:" + o);
        //指定排序的规则
        //只看年龄，我想要按照年龄的升序进行排列
        return this.getAge() - o.getAge();
    }
}

9.3 TreeSet添加元素的底层原理

9.4 TreeSet的两种比较方式

如果方式一和方式二同时存在，我们以方式二为准

/*
            需求：请自行选择比较器排序和自然排序两种方式；
            要求：存入四个字符串， “c”, “ab”, “df”, “qwer”
            按照长度排序，如果一样长则按照首字母排序

            采取第二种排序方式：比较器排序
        */

        //1.创建集合
        //o1:表示当前要添加的元素
        //o2：表示已经在红黑树存在的元素
        //返回值规则跟之前是一样的
        TreeSet<String> ts = new TreeSet<>((o1, o2)->{
                // 按照长度排序
                int i = o1.length() - o2.length();
                //如果一样长则按照首字母排序
                i = i == 0 ? o1.compareTo(o2) : i;
                return i;
        });

        //2.添加元素
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");


        //3.打印集合
        System.out.println(ts);

/*  需求：创建5个学生对象
        属性：(姓名,年龄，语文成绩,数学成绩,英语成绩),
        按照总分从高到低输出到控制台
        如果总分一样，按照语文成绩排
        如果语文一样，按照数学成绩排
        如果数学成绩一样，按照英语成绩排
        如果英文成绩一样，按照年龄排
        如果年龄一样，按照姓名的字母顺序排
        如果都一样，认为是同一个学生，不存。

        第一种：默认排序/自然排序
        第二种：比较器排序

        默认情况下，用第一种排序方式，如果第一种不能满足当前的需求，采取第二种方式。


        课堂练习：
            要求：在遍历集合的时候，我想看到总分。

      */


        //1.创建学生对象
        Student2 s1 = new Student2("zhangsan",23,90,99,50);
        Student2 s2 = new Student2("lisi",24,90,98,50);
        Student2 s3 = new Student2("wangwu",25,95,100,30);
        Student2 s4 = new Student2("zhaoliu",26,60,99,70);
        Student2 s5 = new Student2("qianqi",26,70,80,70);


        //2.创建集合
        TreeSet<Student2> ts = new TreeSet<>();

        //3.添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        //4.打印集合
        //System.out.println(ts);
        for (Student2 t : ts) {
            System.out.println(t);
        }



public class Student2 implements Comparable<Student2> {
    //姓名
    private String name;
    //年龄
    private int age;
    //语文成绩
    private int chinese;
    //数学成绩
    private int math;
    //英语成绩
    private int english;


    public Student2() {
    }

    public Student2(String name, int age, int chinese, int math, int english) {
        this.name = name;
        this.age = age;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return chinese
     */
    public int getChinese() {
        return chinese;
    }

    /**
     * 设置
     * @param chinese
     */
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    /**
     * 获取
     * @return math
     */
    public int getMath() {
        return math;
    }

    /**
     * 设置
     * @param math
     */
    public void setMath(int math) {
        this.math = math;
    }

    /**
     * 获取
     * @return english
     */
    public int getEnglish() {
        return english;
    }

    /**
     * 设置
     * @param english
     */
    public void setEnglish(int english) {
        this.english = english;
    }

    public String toString() {
        return "Student2{name = " + name + ", age = " + age + ", chinese = " + chinese + ", math = " + math + ", english = " + english + "}";
    }

   /* 按照总分从高到低输出到控制台
    如果总分一样，按照语文成绩排
    如果语文一样，按照数学成绩排
    如果数学成绩一样，按照英语成绩排
    如果英文成绩一样，按照年龄排
    如果年龄一样，按照姓名的字母顺序排
    如果都一样，认为是同一个学生，不存。*/
    @Override
    public int compareTo(Student2 o) {
        int sum1 = this.getChinese() + this.getMath() + this.getEnglish();
        int sum2 = o.getChinese() + o.getMath() + o.getEnglish();

        //比较两者的总分
        int i = sum1 - sum2;
        //如果总分一样，就按照语文成绩排序
        i = i == 0 ? this.getChinese() - o.getChinese() : i;
        //如果语文成绩一样，就按照数学成绩排序
        i = i == 0 ? this.getMath() - o.getMath() : i;
        //如果数学成绩一样，按照英语成绩排序（可以省略不写）
        i = i == 0 ? this.getEnglish() - o.getEnglish() : i;
        //如果英文成绩一样，按照年龄排序
        i = i == 0 ? this.getAge() - o.getAge() : i;
        //如果年龄一样，按照姓名的字母顺序排序
        i = i == 0 ? this.getName().compareTo(o.getName()) : i;
        return i;
    }
}

十单列集合总结

十一 Map双列集合

双列集合一次存一对元素，分别为键和值。

键不能重复，值可以重复

键和值是一一对应的，每一个键只能找到自己对应值

键+值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”

10.1 Ma的常见API

Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

put方法的细节：
    在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中，方法返回null
    在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回

Map<String, String> m = new HashMap();//创建HashMap需要指定键和值的数据类型。
    m.put("郭靖", "黄蓉");
    m.put("韦小宝", "沐剑屏");
    m.put("尹志平", "小龙女");
    int size = m.size();
    System.out.println(size);//3
    System.out.println(m);
    //删除
    String result = m.remove("郭靖")

    //判断是否包含
    boolean keyResult = m.containsKey("郭靖");
    //判断是否包含
    boolean valueResult = m.containsValue("小龙女");

    //判断是否为空
    boolean valueResult = m.isEmpty();

    //获取键值对个数
    int size = m.size();

10.2 Map的遍历方式

键找值

键值对

Lambda表达式

键找值

根据键去找对应的值，因为键和值的一一对应的，找到了键就能找到对应的值

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

        map.put("尹志平", "小龙女");
        map.put("郭靖", "穆念慈");
        map.put("欧阳克", "黄蓉");
        //获取所有的键，把这些键放在set集合中
        Set<String> keys = map.keySet();
        Iterator var3 = keys.iterator();
        //根据键获取对应的值
        while(var3.hasNext()) {
            String key = (String)var3.next();
            String value = (String)map.get(key);
            System.out.println(key + " = " + value);
        }

键值对

可以获取集合中的键值对，再使用getKey(),getValue()获取里面的key

 Map<String, String> map = new HashMap();
        map.put("标枪选手", "马超");
        map.put("人物挂件", "明世隐");
        map.put("御龙骑士", "尹志平");
        //获取所有的键值对对象，会返回一个Set集合
        Iterator var2 = map.entrySet().iterator();

        while(var2.hasNext()) {
            Map.Entry<String, String> entry = (Map.Entry)var2.next();
            //利用entry调用get方法获取键和值
            String key = (String)entry.getKey();
            String value = (String)entry.getValue();
            System.out.println(key + "=" + value);
        }

Lambda表达式

Map<String, String> map = new HashMap();
        map.put("鲁迅", "这句话是我说的");
        map.put("曹操", "不可能绝对不可能");
        map.put("刘备", "接着奏乐接着舞");
        map.put("柯镇恶", "看我眼色行事");
        map.forEach(new BiConsumer<String, String>() {
            public void accept(String key, String value) {
                System.out.println(key + "=" + value);
            }
        });
        System.out.println("-----------------------------------");
        //forEach其实就是利用第二种方式遍历，依次得到每一个键和值
        map.forEach((key, value) -> {
            System.out.println(key + "=" + value);
        });

十二 HashMap

12.1 HashMap的特点

HashMap是Map里面的一个实现类。

不用额外需要学习特有的方法，直接使用Map里面的方法就可以了

特点都是跟键决定的：无序，不重复，无索引

HashMap跟HashSet底层原理是一模一样的，都是哈希表结构

12.2 底层原理

 HashMap<Student, String> hm = new HashMap();
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        Student s4 = new Student("wangwu", 25);
        hm.put(s1, "江苏");
        hm.put(s2, "浙江");
        hm.put(s3, "福建");
        hm.put(s4, "山东");
        Set<Student> keys = hm.keySet();
        Iterator var7 = keys.iterator();

        while(var7.hasNext()) {
            Student key = (Student)var7.next();
            String value = (String)hm.get(key);
            System.out.println("" + key + "=" + value);
        }

        System.out.println("--------------------------");
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        Iterator var13 = entries.iterator();

        while(var13.hasNext()) {
            Map.Entry<Student, String> entry = (Map.Entry)var13.next();
            Student key = (Student)entry.getKey();
            String value = (String)entry.getValue();
            System.out.println("" + key + "=" + value);
        }

        System.out.println("--------------------------");
        hm.forEach((student, s) -> {
            System.out.println("" + student + "=" + s);
        });

12.2 底层源码

1.源码详解


Node<K,V>[] table   //哈希表结构中数组的名字

DEFAULT_INITIAL_CAPACITY   //数组默认长度16

DEFAULT_LOAD_FACTOR        //默认加载因子0.75



HashMap里面每一个对象包含一下内容
1.1 链表中的键值对对象
      
         int hash;         //键的哈希值
            final K key;      //键
            V value;          //值
            Node<K,V> next;   //下一个几点的地址值
         
         
1.2 红黑树中的简直对对象
   
         int hash;             //键的哈希值
            final K key;          //键
            V value;              //值
            TreeNode<K,V> parent;      //父节点的地址值
         TreeNode<K,V> left;       //左节点的地址值
         TreeNode<K,V> right;   //右节点的地址值
         boolean red;         //节点的颜色
               


2.添加元素
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);


2.1 数组的位置为null
2.2 数组的位置不为null,键重复，元素覆盖
2.3 数组位置不为null,键不重复，挂在下面形成链表或者红黑树



// 参数一；键
// 参数二：值

//返回值：被覆盖元素的值，如果没有覆盖返回空
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}


//利用键值计算出对应的哈希值，再把哈希值进行一些额外的额处理
//简单理解：返回值就是返回键的哈希值
static final int hash(Object key) {
    int h;
    return (key == null)  0 : (h = key.hashCode()) ^ (h >>> 16);
}

//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果元素重复了是否保留
//       true，表示元素的值保留，不会覆盖
//       false，表示老元素的值不保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
       //定义一个局部变量，用来记录哈希表中数组的地址值
        Node<K,V>[] tab;
      
      //临时的第三方变量，用来记录键值对对象的地址值
        Node<K,V> p;
        
      //表示当前数组的长度
      int n;
      
      //表示索引
        int i;
      
      //把哈希表中的数组的地址值，赋值给局部变量tab
      tab = table;

        if (tab == null || (n = tab.length) == 0){
         //1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
         //2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容条件
         //如果没有达到扩容条件，底层不会做任何操作
         //如果达到了扩容条件，底层会把数字扩容为原先的两倍，并把数据全部转移到新的哈希表中
         tab = resize();
         //表示把当前数组的长度赋值给n
            n = tab.length;
        }

      //拿着数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置
      i = (n - 1) & hash;//index
      //获取数组中对应的数据
      p = tab[i];
      
      
        if (p == null){
         //底层会创建一个键值对对象，直接放到数组当中
            tab[i] = newNode(hash, key, value, null);
        }else {
            Node<K,V> e;
            K k;
         
         //等号的左边：数组中键值对的哈希值
         //等号的右边：当前要添加键值对的哈希值
         //如果键不一样，此时返回false
         //如果键一样，此时返回true
         boolean b1 = p.hash == hash;
         
            if (b1 && ((k = p.key) == key || (key != null && key.equals(k)))){
                e = p;
            } else if (p instanceof TreeNode){
            //判断数组中获取出来的键值对是不是红黑树中的节点
            //如果是，则调用方法putTreeVal,把当前的节点按照红黑树的规则添加到节点当中。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            } else {
            //判断数组中获取出来的键值对是不是红黑树中的节点
            //表示此时下面挂的是链表
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                  //此时就会创建一个新的节点，挂在下面形成链表
                        p.next = newNode(hash, key, value, null);
                  //判断当前链表的长度是否超过8，如果超过8，就会调用方法treeifyBin
                  //treeifyBin方法的底层还会回继续判断
                  //判断数组的长度是否大于等于64
                  //如果同时满足这两个条件，就会把这个链表转成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            treeifyBin(tab, hash);
                        break;
                    }

               //e：        0x0044  ddd  444
               //要添加的元素： 0x0055   ddd   555
               //如果哈希值一样：就会调用equals方法比较内部的属性值是否相同
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
                   break;
               }

                    p = e;
                }
            }

         //如果e为null，表示当前不需要覆盖任何元素
         //如果e不为null，表示当前的键是一样的，值就会被覆盖
         //e:0x0044  ddd  555
         //要添加的元素： 0x0055   ddd   555
            if (e != null) {
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null){
               
               //等号的右边：当前要添加的值
               //等号的左边：0X0044的值
               e.value = value;
            }
                afterNodeAccess(e);
                return oldValue;
            }
        }
      
        //threshold 记录的就是数组长度* 0.75  16 * 0.75 = 12 哈希表的扩容时机
        if (++size > threshold){
          resize();
      }
        
      //表示当前没有覆盖任何元素，返回null
        return null;
    }

十三 LinkedHashMap

有键决定：有序、不重复、无索引

这里的有序指的是保证存储和取出元素顺序一致

原理：底层数据结构依然是哈希表，只是每个键值对元素额外的多了一和双链表的机制记录存储的顺序。

 LinkedHashMap<String, Integer> lhm = new LinkedHashMap();
        lhm.put("c", 789);
        lhm.put("b", 456);
        lhm.put("a", 123);
        lhm.put("a", 111);
        System.out.println(lhm);

十四 Hashtable

底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化

Hashtable同样是基于哈希表实现的，同样每个元素是一个key-value对，其内部也是通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。

十五 TreeMap

TreeMap跟TreeSet底层原理一样，都是红黑树结构的。

由键决定特性：不重复、无索引、可排序

可排序：对键进行排序

    /*需求：
      字符串“aabacabcdabcde”
      青铜级字符串中每一个字符出现的次数，并按照一下格式输出     

    */


        String s = "aababcabcdabcde";
        TreeMap<Character, Integer> tm = new TreeMap();

        for(int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            if (tm.containsKey(c)) {
                int count = (Integer)tm.get(c);
                ++count;
                tm.put(c, count);
            } else {
                tm.put(c, 1);
            }
        }

        StringJoiner sj = new StringJoiner("", "", "");
        tm.forEach((key, value) -> {
            sj.add("" + key).add("(").add("" + value).add(")");
        });
        System.out.println(sj);

15.1 底层源码

1.TreeMap中每一个节点的内部属性
K key;                    //键
V value;                //值
Entry<K,V> left;        //左子节点
Entry<K,V> right;        //右子节点
Entry<K,V> parent;        //父节点
boolean color;            //节点的颜色




2.TreeMap类中中要知道的一些成员变量
public class TreeMap<K,V>{
   
    //比较器对象
    private final Comparator<? super K> comparator;

    //根节点
    private transient Entry<K,V> root;

    //集合的长度
    private transient int size = 0;

   

3.空参构造
    //空参构造就是没有传递比较器对象
     public TreeMap() {
        comparator = null;
    }
    
    
    
4.带参构造
    //带参构造就是传递了比较器对象。
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }
    
    
5.添加元素
    public V put(K key, V value) {
        return put(key, value, true);
    }

参数一：键
参数二：值
参数三：当键重复的时候，是否需要覆盖值
        true：覆盖
        false：不覆盖
        
    private V put(K key, V value, boolean replaceOld) {
        //获取根节点的地址值，赋值给局部变量t
        Entry<K,V> t = root;
        //判断根节点是否为null
        //如果为null，表示当前是第一次添加，会把当前要添加的元素，当做根节点
        //如果不为null，表示当前不是第一次添加，跳过这个判断继续执行下面的代码
        if (t == null) {
            //方法的底层，会创建一个Entry对象，把他当做根节点
            addEntryToEmptyMap(key, value);
            //表示此时没有覆盖任何的元素
            return null;
        }
        //表示两个元素的键比较之后的结果
        int cmp;
        //表示当前要添加节点的父节点
        Entry<K,V> parent;
        
        //表示当前的比较规则
        //如果我们是采取默认的自然排序，那么此时comparator记录的是null，cpr记录的也是null
        //如果我们是采取比较去排序方式，那么此时comparator记录的是就是比较器
        Comparator<? super K> cpr = comparator;
        //表示判断当前是否有比较器对象
        //如果传递了比较器对象，就执行if里面的代码，此时以比较器的规则为准
        //如果没有传递比较器对象，就执行else里面的代码，此时以自然排序的规则为准
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else {
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        } else {
            //把键进行强转，强转成Comparable类型的
            //要求：键必须要实现Comparable接口，如果没有实现这个接口
            //此时在强转的时候，就会报错。
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                //把根节点当做当前节点的父节点
                parent = t;
                //调用compareTo方法，比较根节点和当前要添加节点的大小关系
                cmp = k.compareTo(t.key);
                
                if (cmp < 0)
                    //如果比较的结果为负数
                    //那么继续到根节点的左边去找
                    t = t.left;
                else if (cmp > 0)
                    //如果比较的结果为正数
                    //那么继续到根节点的右边去找
                    t = t.right;
                else {
                    //如果比较的结果为0，会覆盖
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        }
        //就会把当前节点按照指定的规则进行添加
        addEntry(key, value, parent, cmp < 0);
        return null;
    }    
    
    
    
     private void addEntry(K key, V value, Entry<K, V> parent, boolean addToLeft) {
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (addToLeft)
            parent.left = e;
        else
            parent.right = e;
        //添加完毕之后，需要按照红黑树的规则进行调整
        fixAfterInsertion(e);
        size++;
        modCount++;
    }
    
    
    
    private void fixAfterInsertion(Entry<K,V> x) {
        //因为红黑树的节点默认就是红色的
        x.color = RED;

        //按照红黑规则进行调整
        
        //parentOf:获取x的父节点
        //parentOf(parentOf(x)):获取x的爷爷节点
        //leftOf:获取左子节点
        while (x != null && x != root && x.parent.color == RED) {
            
            
            //判断当前节点的父节点是爷爷节点的左子节点还是右子节点
            //目的：为了获取当前节点的叔叔节点
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                //表示当前节点的父节点是爷爷节点的左子节点
                //那么下面就可以用rightOf获取到当前节点的叔叔节点
                Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    //叔叔节点为红色的处理方案
                    
                    //把父节点设置为黑色
                    setColor(parentOf(x), BLACK);
                    //把叔叔节点设置为黑色
                    setColor(y, BLACK);
                    //把爷爷节点设置为红色
                    setColor(parentOf(parentOf(x)), RED);
                    
                    //把爷爷节点设置为当前节点
                    x = parentOf(parentOf(x));
                } else {
                    
                    //叔叔节点为黑色的处理方案
                    
                    
                    //表示判断当前节点是否为父节点的右子节点
                    if (x == rightOf(parentOf(x))) {
                        
                        //表示当前节点是父节点的右子节点
                        x = parentOf(x);
                        //左旋
                        rotateLeft(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
                //表示当前节点的父节点是爷爷节点的右子节点
                //那么下面就可以用leftOf获取到当前节点的叔叔节点
                Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
        
        //把根节点设置为黑色
        root.color = BLACK;
    }
    
    
    
    
    
    
    
6.课堂思考问题：
6.1TreeMap添加元素的时候，键是否需要重写hashCode和equals方法？
此时是不需要重写的。
没用用到hashcode,equals;
6.2HashMap是哈希表结构的，JDK8开始由数组，链表，红黑树组成的。
既然有红黑树，HashMap的键是否需要实现Compareable接口或者传递比较器对象呢？
不需要的。
因为在HashMap的底层，默认是利用哈希值的大小关系来创建红黑树的




6.3TreeMap和HashMap谁的效率更高？
如果是最坏情况，添加了8个元素，这8个元素形成了链表，此时TreeMap的效率要更高
但是这种情况出现的几率非常的少。
一般而言，还是HashMap的效率要更高。



6.4你觉得在Map集合中，java会提供一个如果键重复了，不会覆盖的put方法呢？
此时putIfAbsent本身不重要。
传递一个思想：
    代码中的逻辑都有两面性，如果我们只知道了其中的A面，而且代码中还发现了有变量可以控制两面性的发生。
    那么该逻辑一定会有B面。
    
    习惯：
        boolean类型的变量控制，一般只有AB两面，因为boolean只有两个值
        int类型的变量控制，一般至少有三面，因为int可以取多个值。
        



6.5三种双列集合，以后如何选择？
    HashMap LinkedHashMap TreeMap
    
    默认：HashMap（效率最高）
    如果要保证存取有序：LinkedHashMap
    如果要进行排序：TreeMap