集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中非常常用

为了满足不同的业务场景需求，Java除了ArrayList还提供了很多不同特点的集合给我们选择

一. 集合的体系结构

集合可以分为两类：Collection（单列集合）和Map（双列集合）

        · Collection代表单列集合，每个元素（数据）只包含一个值

        · Map代表双列集合，每个元素包含两个值（键值对）

二. Collection（单列集合）

2.1 Collection集合体系

2.2 Collection集合特点

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

        · ArrayList、LinkList：有序、可重复、有索引

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

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

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

        · TreeSet：按照大小默认升序排序、不重复、无索引

//demo
public class demo {
    public static void main(String[] args) {
        //ArrayList：有序、可重复、有索引
        ArrayList<String> list = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java1");  //可重复
        list.add("java2");  //可重复
        System.out.println(list);  //[java1, java2, java1, java2]
        System.out.println(list.get(0));  //用索引值取内容  java1

        //HashSet：无序、不重复、无索引
        HashSet<String> set = new HashSet<>();
        set.add("java1");
        set.add("java2");
        set.add("java1");
        set.add("java2");
        System.out.println(set);  //[java2, java1]  不支持索引
    }
}

2.3 Collection的常用方法

        Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的

Collection的常用方法如下：

方法名	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数
public Object[] toArray()	把集合中的元素，存储到数组中

//demo
public class demo {
    public static void main(String[] args) {
        //Collection是接口，不能直接new（创建对象）
        Collection<String> c = new ArrayList<>();   //多态写法
        //public boolean add(E e)：添加元素，添加成功返回true
        c.add("java1");
        c.add("java2");
        c.add("java1");
        c.add("java2");
        c.add("java3");
        System.out.println(c); //[java1, java2, java1, java2, java3]

        System.out.println(c.isEmpty()); //false
        System.out.println(c.size()); //5
        System.out.println(c.contains("java1")); //true（包含java1）
        System.out.println(c.remove("java1")); //true（删除成功）
        System.out.println(c); //[java2, java1, java2, java3]
        Object[] arr1 = c.toArray();
        System.out.println(Arrays.toString(arr1)); //[java2, java1, java2, java3]

        //public void clear()：清空集合的元素
        c.clear();
        System.out.println(c); //[]

        //public boolean isEmpty()：判断集合是否为空 为空返回true，不为空返回false
        System.out.println(c.isEmpty()); //true

        //public int size()：获取集合的大小
        System.out.println(c.size()); //0

        //public boolean contains(Object obj)：判断集合中是否包含某个元素
        System.out.println(c.contains("java1")); //false

        //public boolean remove(E e)：删除某个元素，如果有多个重复元素，默认删除第一个重复元素
        System.out.println(c.remove("java1")); //false（没有java1元素）

        System.out.println("=====================");

        //public Object[] toArray()：把集合转换成数组（因为不确定集合中的数据类型，所以转换成Object数组比较合理）
        Object[] arr2 = c.toArray();
        System.out.println(Arrays.toString(arr2));  //[]

        //如果非要把集合转换成字符串数组（要保证集合中的数据都是字符串，否则不能转）
        String[] arr3 = c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(arr3));

        System.out.println("=====================");

        //把一个集合的全部数据倒入另一个集合中去
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);  //就是把c2集合的全部数据倒入到c1集合中去(相当于copy了一份c2的数据给c1)
        System.out.println(c1); //[java1, java2, java3, java4]
        System.out.println(c2); //[java3, java4]
    /*
        Collection<Integer> c3 = new ArrayList<>();
        c3.add(1);
        c1.addAll(c3);  //如果两个集合中存储的数据类型不一样，则不能倒入
    */
    }
}

2.4 Collection的遍历方式

· 为什么Collection的遍历不支持用普通的for循环？

        因为Collection中有些集合是无序的（如Set等），没有索引

2.4.1 迭代器

        迭代器是用来遍历集合的专用方式（数组没有迭代器），仔Java中迭代器的代表是Iterator

Collection集合获取迭代器的方法

方法名称	说明
Iterator<E> iterator()	返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素

 Iterator迭代器中的常用方法

方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在返回true，不存在返回false
E next()	获取当前位置的元素，并同时将迭代器对象指向下一个元素处

//demo
public class demo {
    public static void main(String[] args) {
        //Collection是接口，不能直接new（创建对象）
        Collection<String> c = new ArrayList<>();   //多态写法
        c.add("张三");
        c.add("李四");
        c.add("王五");
        c.add("赵二");
        c.add("郝六");
        System.out.println(c); //[张三, 李四, 王五, 赵二, 郝六]

        //使用迭代器遍历集合
        //1.从集合对象中获取迭代器对象
        Iterator<String> it = c.iterator();  //Iterator<E> iterator()返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素
        //E next()	获取当前位置的元素，并同时将迭代器对象指向下一个元素处
//        System.out.println(it.next());  //张三
//        System.out.println(it.next());  //李四
//        System.out.println(it.next());  //王五
//        System.out.println(it.next());  //赵二
//        System.out.println(it.next());  //郝六
        //System.out.println(it.next());  //超出集合的长度，会保错（出现NoSuchElementException异常）

        //应该使用循环结合迭代器遍历集合
        while(it.hasNext()){  //boolean hasNext()：询问当前位置是否有元素存在，存在返回true，不存在返回false
            //System.out.println(it.next());  //不建议这样写（如果循环中写两行，集合元素是单数，则会存在报错现象）
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

2.4.2 增强for循环

        增强for循环可以用来遍历集合或数组

        增强for循环遍历集合，本质就是迭代器遍历集合的简化写法

//demo
public class demo {
    public static void main(String[] args) {
        //Collection是接口，不能直接new（创建对象）
        Collection<String> c = new ArrayList<>();   //多态写法
        c.add("张三");
        c.add("李四");
        c.add("王五");
        c.add("赵二");
        c.add("郝六");
        System.out.println(c); //[张三, 李四, 王五, 赵二, 郝六]

        //使用增强for循环遍历集合
        for(String ele : c){
            System.out.println(ele);
        }
        //快捷写法(集合对象.for) c.for

        //使用增强for循环遍历数组
        String[] name = {"123","java","哈哈哈哈"};
        for(String ele : name){
            System.out.println(ele);
        }
        //快捷写法 name.for
    }
}

2.4.3 Lambda表达式

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

需要使用Collection的如下方法来完成

方法名称	说明
default void forEach(Consumer<? super T> action)	集合Lambda遍历集合

//demo
public class demo {
    public static void main(String[] args) {
        //Collection是接口，不能直接new（创建对象）
        Collection<String> c = new ArrayList<>();   //多态写法
        c.add("张三");
        c.add("李四");
        c.add("王五");
        c.add("赵二");
        c.add("郝六");
        System.out.println(c); //[张三, 李四, 王五, 赵二, 郝六]

        //结合Lambda表达式遍历集合
        //default void forEach(Consumer<? super T> action)  //Consumer是接口，不能直接创建对象，这里使用匿名内部类
        c.forEach(new Consumer<String>() {  //forEach方法的底层源码思想是 增强for循环
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //层层简化
        c.forEach((String s) -> {
                System.out.println(s);
        });

        //层层简化
        c.forEach( s -> {
            System.out.println(s);
        });

        //层层简化
        c.forEach( s -> System.out.println(s));

        //层层简化
        c.forEach(System.out::println);
    }
}

2.4.4 案例：遍历集合中的自定义对象

//demo
public class demo {
    public static void main(String[] args) {
        Collection<Movie> movies = new ArrayList<>();  //每部电影都是一个对象，多部电影用集合封装
        Movie m1 = new Movie("肖申克的救赎","The Shawshank Redemption","弗兰克","蒂姆","1994");
        Movie m2 = new Movie("霸王别姬","Farewell My Concubine","陈凯歌","张国荣","1993");
        Movie m3 = new Movie("阿甘正传","Forrest Gump","罗伯特","汤姆","1994");
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);

        //遍历集合中的三个对象，输出每部电影的详情信息
        //方法1：迭代器
        Iterator<Movie> it = movies.iterator(); //创建迭代器的对象（从集合对象中获取迭代器对象）
        while(it.hasNext()){
            Movie m = it.next();
            System.out.println(m.toString());
        }

        System.out.println("=============================");

        //方法2：增强for循环  快捷键 movies.for
        //for(元素数据类型 变量名 : 集合或数组)
        for (Movie movie : movies) {
            System.out.println(movie.toString());
        }

        System.out.println("=============================");

        //方法3：结合Lambda表达式遍历集合
        //集合.forEach(Consumer<? super T> action)
        movies.forEach(new Consumer<Movie>() {
            @Override
            public void accept(Movie movie) {
                System.out.println(movie.toString());
            }
        });

        //简化代码
        movies.forEach((Movie movie) -> {
            System.out.println(movie.toString());
        });
    }
}

//Movie
public class Movie {
    private String name; //电影名称
    private String engName; //电影英文名
    private String director; //电影导演
    private String actor; //电影主演
    private String time; //电影上映时间

    public Movie(){

    }

    public Movie(String name, String engName, String director, String actor, String time) {
        this.name = name;
        this.engName = engName;
        this.director = director;
        this.actor = actor;
        this.time = time;
    }

    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", engName='" + engName + '\'' +
                ", director='" + director + '\'' +
                ", actor='" + actor + '\'' +
                ", time='" + time + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getEngName() {
        return engName;
    }

    public void setEngName(String engName) {
        this.engName = engName;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }
}

 注意：集合中存储的是元素的地址信息！！！

三. List集合

3.1 List集合特点、特有方法

· List系列集合特点：有序、可重复、有索引

        · ArrayList：有序、可重复、有索引

        · LinkedList：有序、可重复、有索引

· List集合的特有方法

        List集合因为支持索引，所以多了很多和索引相关的方法，当然，Collection的功能List也都继承了

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个ArrayList集合对象(List是一个接口不能直接创建对象，要用实现类创建)
        List<String> list = new ArrayList<>(); //多态
        list.add("java1");
        list.add("java2");
        list.add("java2");
        list.add("java3");
        System.out.println(list); //[java1, java2, java2, java3] 有序，可重复，有索引

        //void add(int index,E element)	在此集合中的指定位置插入指定的元素
        list.add(2,"java4");
        System.out.println(list); //[java1, java2, java4, java2, java3]

        //E remove(int index) 删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(2)); //java4
        System.out.println(list); //[java1, java2, java2, java3]

        //E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(2,"list5")); //java2
        System.out.println(list); //[java1, java2, list5, java3]

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

3.2 List集合遍历方式

· List集合支持的遍历方式

        · for循环（因为List集合有索引）

        · 迭代器

        · 增强for循环

        · Lambda表达式

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个ArrayList集合对象(List是一个接口不能直接创建对象，要用实现类创建)
        List<String> list = new ArrayList<>(); //多态
        list.add("java1");
        list.add("java2");
        list.add("java3");
        System.out.println(list); //[java1, java2, java3]

        //1.for循环 快捷方式输入 list.fori
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("===================");

        //2.迭代器
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println("===================");

        //3.增强for循环（forEach遍历）
        for (String s : list) {
            System.out.println(s);
        }

        System.out.println("===================");

        //4.结合Lambda表达式
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //简化
        list.forEach( s -> System.out.println(s));
    }
}

3.3 ArrayList集合的底层原理

        ArrayList和LinkedList两者底层采用的数据结构（存储、组织数据的方式）不同，应用场景也不同

        · ArrayList集合底层采用的是数组，LinkedList集合底层采用的是双链表

3.3.1 数组的特点（查询快、增删慢）

· 查询速度快（注意：是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同

· 删除效率低：可能需要把后面很多的数据进行前移

· 添加效率极低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容

3.3.2 ArrayList集合的底层原理

         ArrayList集合是基于数组实现的，因此ArrayList集合的特点也是查询快，增删慢

1. 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组

2. 添加第一个元素时，底层会创建一个新的长度为10的数组

3. 存满时，会扩容1.5倍

4. 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准（如扩容1.5倍是多了5个位置，但是有11个位置的数据要放，则会直接添加11个位置）    

3.3.3 ArrayList集合适合的应用场景

· ArrayList集合适合根据索引查询数据，比如根据随机索引取数据（高效）或者数据量不是很大时

· ArrayList集合不适合数据量大的同时又要频繁的进行增删操作

3.4 LinkedList集合的底层原理

        LinkedList集合是基于双链表实现的

3.4.1 链表

链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址

链表的特点

        · 查询慢，无论查询哪个数据都要从头开始找

        · 链表增删相对快

双向链表的特点：

        查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

3.4.2 ArrayList集合的底层原理

        LinkedList集合是基于双链表实现的，因此LinkedList的特点也是查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

LinkedList新增了很多首尾操作的特有方法

方法名称	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

3.4.3 LinkedList集合适合的应用场景

LinkedList的应用场景1：可以用来设计队列（队列的特点：先进先出，后进后出）

队列的两端都开口                             

数据进去是入队，数据出来是出队

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个队列
        LinkedList<String> queue = new LinkedList<>();  //这里不要用多态，因为List没有首尾操作的方法
        //入队操作
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        queue.addLast("4号");
        System.out.println(queue); //[1号, 2号, 3号, 4号]

        //2.出队操作
        System.out.println(queue.removeFirst()); //移除第一个位置（1号）
        System.out.println(queue); //[2号, 3号, 4号]
    }
}

LinkedList的应用场景2：可以用来设计栈（栈的特点：后进先出，先进后出） 

栈的一端开口（栈顶），一端封闭（栈底）        

数据进入栈模型的过程称为：压/进栈（push），数据离开栈模型的过程称为：弹/出栈（pop）

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个栈对象
        LinkedList<String> stack = new LinkedList<>();  //这里不要用多态，因为List没有首尾操作的方法
        //压栈（进栈）操作
//        stack.addFirst("子弹1");
//        stack.addFirst("子弹2");
//        stack.addFirst("子弹3");
//        stack.addFirst("子弹4");
        stack.push("子弹1");
        stack.push("子弹2");
        stack.push("子弹3");
        stack.push("子弹4");
        System.out.println(stack); //[子弹4, 子弹3, 子弹2, 子弹1]
        //弹栈（出栈）操作
//        System.out.println(stack.removeFirst()); //子弹4
        System.out.println(stack.pop()); //子弹4
        System.out.println(stack); //[子弹3, 子弹2, 子弹1]
    }
}

四. Set集合

4.1 Set系列集合特点

Set系列集合：无序（添加数据的顺序和获取出的数据顺序不一致）、不重复、无索引

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

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

        · TreeSet：按照大小默认升序排序、不重复、无索引

注意：Set要用到的常用方法基本上就是Collection提供的！自己几乎没有额外新增一些常用功能

//demo
public class demo {
    public static void main(String[] args) {
        //创建一个Set集合的对象
        //Set是接口，不能直接创建对象，要通过实现类的方式创建
        //Set<Integer> set = new HashSet<>(); //多态，创建了一个HashSet的集合对象
        //Set<Integer> set = new LinkedHashSet<>();
        Set<Integer> set = new TreeSet<>();
        set.add(7);
        set.add(-4);
        set.add(2);
        set.add(2);
        set.add(5);
        set.add(4);
        set.add(3);
        set.add(1);
        System.out.println(set);
        //HashSet:[1, 2, -4, 3, 4, 5, 7]  //无序，无索引，不重复
        //LinkedHashSet:[7, -4, 2, 5, 4, 3, 1]  //有序（和我的添加顺序一致），无索引，不重复
        //TreeSet:[-4, 1, 2, 3, 4, 5, 7]  //按照大小默认升序排序、不重复、无索引
    }
}

4.2 HashSet集合的底层原理

4.2.1 哈希值

        · 哈希值就是一个int类型的数值，Java中每个对象都有一个哈希值

        · Java中的所有对象，都可以调用Object类提供的hashCode方法，返回该对象自己的哈希值

public int hashCode()：返回对象的哈希码值

对象哈希值的特点：

        · 同一个对象多次调用hashCode()方法返回的哈希值是相同的

        · 不同的对象，它们的哈希值一般不相同，但也有可能会相同（哈希碰撞）（创建对象的个数超过int所能容纳的范围，就会导致哈希碰撞）

//demo
public class demo{
    public static void main(String[] args){
        Car c1 = new Car("奔驰",23.9);
        Car c2 = new Car("宝马",23.8);
        System.out.println(c1.hashCode()); //2133927002
        System.out.println(c1.hashCode()); //2133927002
        System.out.println(c2.hashCode()); //1836019240

        String str1 = new String("abc");
        String str2 = new String("acD");
        System.out.println(str1.hashCode()); //96354(哈希碰撞)
        System.out.println(str2.hashCode()); //96354(哈希碰撞)
    }
}

//Car
public class Car {
    private String name;
    private double price;

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

 4.2.2 数据结构——树

4.2.3 HashSet集合的底层原理

        基于哈希表实现

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

哈希表

        JDK8之前，哈希表=数组+链表

        JDK8开始，哈希表=数组+链表+红黑树

JDK8之前HashSet集合的底层原理，基于哈希表：数组+链表

如果数据占满了数组，继续增加数据，越来越多的数据会导致链表过长，致使查询性能降低

因此会采用扩容的方法

        默认加载因子0.75 × 16 = 12，当数组中占满了12个位置的时候，就开始扩容（新数组是原来数组的两倍），再把原来的数组重新转移到新的数组中

JDK8开始HashSet集合的底层原理，基于哈希表：数组+链表+红黑树

        JDK8开始，当链表长度超过8，切数据长度≥64时，自动将链表转成红黑树

4.2.4 深入理解HashSet集合去重复的机制

        HashSet集合默认不能对内容一样的两个不同对象去重复

如何让HashSet集合能够实现对内容一样的两个不同对象去重复？

//demo
public class demo{
    public static void main(String[] args){
        Set<Car> set = new HashSet<>();
        Car c1 = new Car("奔驰",23.9);
        Car c2 = new Car("奔驰",23.9);
        Car c3 = new Car("宝马",23.8);
        set.add(c1);
        set.add(c2);
        set.add(c3);
        System.out.println(set);
        //没有重写equals和hashCode之前：
            //内容一样的两个不同对象（c1，c2）添加到HashSet中，认为它们是不重复的
            //结果是：[Car{name='奔驰', price=23.9}, Car{name='奔驰', price=23.9}, Car{name='宝马', price=23.8}]
        //重写之后
            //内容一样的两个不同对象（c1，c2）添加到HashSet中，认为它们是重复的
            //结果是：[Car{name='奔驰', price=23.9}, Car{name='宝马', price=23.8}]
    }
}

//Car
public class Car {
    private String name;
    private double price;

    //右键->生成->equals()和hashCode()
    //只要两个对象内容一样就返回true
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 &&
                Objects.equals(name, car.name);
    }

    //只要两个对象内容一样,返回的哈希值就是一样的
    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

4.3 LinkedHashSet集合的底层原理

         LinkedHashSet集合也是基于哈希表（数组、链表、红黑树）实现的

        但是它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置

4.4 TreeSet集合

特点：不重复，五索引，可排序（默认升序排序，按照元素的大小，由小到大排序）

TreeSet集合底层是基于红黑树实现的排序

注意：

        · 对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序

        · 对于字符串类型：默认按照首字符的编号升序排序

        · 对于自定义类型如Student对象，TreeSet默认是无法直接排序的

自定义排序规则

· TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两个方式来指定比较规则

方式一

· 让自定义的类（如Student类）实现Comparable接口，重写里面的compareTo方法来指定比较规则

方式二

· 通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象），用于指定比较规则

        public TreeSet(Comparator<? super E> comparator)

//demo
public class demo{
    public static void main(String[] args){
        Set<Integer> set = new TreeSet<>();
        set.add(6);
        set.add(5);
        set.add(5);
        set.add(7);
        System.out.println(set);  //[5, 6, 7]

        //如果同时存在两种比较规则，会就近选择自己自带的比较器对象进行排序
//        Set<Car> set1 = new TreeSet<>(new Comparator<Car>() {
//            @Override
//            public int compare(Car o1, Car o2) {
//                //需求：按照价格降序排序
//                return Double.compare(o2.getPrice(),o1.getPrice());
//            }
//        });
        //简化
        Set<Car> set1 = new TreeSet<>((o1, o2)-> Double.compare(o2.getPrice(),o1.getPrice()));

        Car c1 = new Car("奔驰",12.8);
        Car c2 = new Car("宝马",14.1);
        Car c3 = new Car("大众",9.9);
        Car c4 = new Car("未来",14.1);
        set1.add(c1);
        set1.add(c2);
        set1.add(c3);
        set1.add(c4);
        System.out.println(set1);
        //没有自定义排序规则前报ClassCastException异常
        //自定义排序规则后，[Car{name='大众', price=9.9}, Car{name='奔驰', price=12.8}, Car{name='宝马', price=14.1}]
        //会发现c4没有存进去，是因为需求是按照price升序排列，如果两个对象price一样，则后面一个就被判定为重复
    }
}

//Car
public class Car implements Comparable<Car> {
    private String name;
    private double price;

    //this代表主调   o是被调
    @Override
    public int compareTo(Car o) {
        //如果认为左边对象大于右边对象返回正整数
        //如果认为左边对象小于右边对象返回负整数
        //如果认为左边对象等于右边对象返回0
        //需求：按照价格升序排序
        if(this.price>o.price){
            return 1;
        }else if(this.price<o.price){
            return -1;
        }else{
            return 0;
        }
        //return (int)(this.price-o.price); //不能这样写，返回值是int类型，两个double类型相减之后强转可能会出bug
    }

    //右键->生成->equals()和hashCode()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 &&
                Objects.equals(name, car.name);
    }

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

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

五. 总结

六. 注意事项：集合的并发修改异常问题

集合的并发修改异常

· 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误

· 由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误

怎么保证遍历集合的同时删除数据时不出bug？

· 使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可

· 如果能用for循环遍历时：可以倒着遍历并删除；或者从前往后遍历，单输出元素后做i--操作