Java中Collection集合体系list--＞{（Arraylist），（LinkedList）} set--＞{（HashSet），（treeSet），（linkedHashSet）}

落日映苍穹つ 2024-03-24 18:37 3阅读 0赞

#### Collection集合体系 ####

![7b46f93858d649c99a18b5a93d300359.png][]

**List系列集合：存取有序、可重复、有索引**

**ArrayList**

**LinekdList**

**Set系列集合：存取无序、不重复、无索引**

**HashSet**

**LinkedHashSet: 存取有序**

**TreeSet：排序**

//简单确认一下Collection集合的特点
 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] 
 
 HashSet<String> list = new HashSet<>(); //存取顺序不一致，不重复，无索引
 list.add("java1");
 list.add("java2");
 list.add("java1");
 list.add("java2");
 list.add("java3");
 System.out.println(list); //[java3, java2, java1]

**1**、单列集合的顶层接口是？双列集合的顶层接口是？存储元素的特点是？

**Collection，每个元素只包含一个值**

**Map，每个元素包含两个值，元素也称为键值对**

2、Collection有哪两大体系，各自的特点是？

**List系列集合：存取有序、可重复、有索引**

**Set系列集合：存取无序、不重复、无索引**

##### **Collection的常用方法** #####

<table> 
 <tbody> 
 <tr> 
 <td style="width:296px;"> 方法名 </td> 
 <td style="width:472px;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;boolean&nbsp;add(E&nbsp;e) </td> 
 <td style="width:472px;"> 把给定的对象添加到当前集合中&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;void&nbsp;clear()&nbsp; </td> 
 <td style="width:472px;"> 清空集合中所有的元素 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;boolean&nbsp;remove(E&nbsp;e) </td> 
 <td style="width:472px;"> 把给定的对象在当前集合中删除 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;boolean&nbsp;contains(Object&nbsp;obj) </td> 
 <td style="width:472px;"> 判断当前集合中是否包含给定的对象 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;boolean&nbsp;isEmpty() </td> 
 <td style="width:472px;"> 判断当前集合是否为空 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;int&nbsp;size() </td> 
 <td style="width:472px;"> 返回集合中元素的个数。 </td> 
 </tr> 
 <tr> 
 <td style="width:296px;"> public&nbsp;Object[]&nbsp;toArray() </td> 
 <td style="width:472px;"> 把集合中的元素，存储到数组中 </td> 
 </tr> 
 </tbody> 
</table>

import java.util.ArrayList;
 import java.util.Collection;
 
 public class Test04 {
 public static void main(String[] args) {
 Collection<String> collection = new ArrayList<>();
 collection.add("张三");
 collection.add("王五");
 collection.add("赵六");
 collection.add("钱七");
 collection.remove("张三");//删除
 collection.contains("张三");//判断集合中是否包含某个元素
 collection.clear();//清除所有元素
 System.out.println(collection.size());//判断集合中有多少个元素；
 Object[] array = collection.toArray();//将集合转换成一个数组；
 
 }
 }

将一个集合添加到另一个集合中；

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集合中去
 System.out.println(c1); //[java1, java2, java3, java4]

##### Collection遍历方式 #####

为什么Collection集合不能用普通for循环遍历

因为Collection中没有get方法，多态创建对象，编译报错；

###### 迭代器遍历 ######

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

<table> 
 <tbody> 
 <tr> 
 <td> 方法名称 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> Iterator&lt;E&gt;&nbsp;iterator() </td> 
 <td> 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素 </td> 
 </tr> 
 </tbody> 
</table>

迭代器Iterator常用方法

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

import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 public class Test05 {
 public static void main(String[] args) {
 Collection<Object> list = new ArrayList<>();
 list.add("aa");
 list.add("bb");
 list.add("cc");
 list.add("dd");
 list.add("ee");
 Iterator<Object> iterator = list.iterator();
 while (iterator.hasNext()){//判断是否有元素
 System.out.println(iterator.next());//取出元素并将索引指向下一个
 }
 }
 }

迭代器代码的原理如下：

*  当调用iterator()方法获取迭代器时，当前指向第一个元素
 *  hasNext()方法则判断这个位置是否有元素，如果有则返回true，进入循环
 *  调用next()方法获取元素，并将索引指向下一个位置，
 *  等下次循环时，则获取下一个元素，依此内推

1、如何获取集合的迭代器? 迭代器遍历集合的代码具体怎么写？

通过集合对象名，调用iterator()方法获取迭代器对象 循环判断语句中调用hasNext()方法，该方法判断当前位置是否有元素可以取出，如果有则调用next()方法取出，并让迭代器后移一位；如果没有循环结束

2、hasNext()方法结果为false，如果继续使用next()方法会出现什么异常?

**NoSuchElementException异常**

###### 增强for遍历集合 ######

增强for循环不仅可以遍历集合还可以遍历数组

for（Object o:s）{
    
        System.out.println(o)
    }
    //Object表示集合的类型，o代表集合中的每一个元素，s代表集合；

Collection<String> c = new ArrayList<>();
 c.add("赵敏");
 c.add("小昭");
 c.add("素素");
 c.add("灭绝");
 
 //1.使用增强for遍历集合
 for(String s: c){
 System.out.println(s); 
 }
 
 //2.再尝试使用增强for遍历数组
 String[] arr = {"迪丽热巴", "古力娜扎", "稀奇哈哈"};
 for(String name: arr){
 System.out.println(name);
 }

反编译可以看出增强for底层调用迭代器

![a2987226d04947888b51a992599a3053.png][]

###### forEach遍历集合 ######

在JDK8版本以后还提供了一个forEach方法也可以遍历集合，如果下图所示：

<table> 
 <tbody> 
 <tr> 
 <td style="width:339px;"> 方法名称 </td> 
 <td style="width:509px;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="width:339px;"> default&nbsp;void&nbsp;forEach(Consumer&lt;?&nbsp;super&nbsp;T&gt;&nbsp;action)&nbsp; </td> 
 <td style="width:509px;"> 结合lambda遍历集合 </td> 
 </tr> 
 </tbody> 
</table>

public class Demo06 {
 public static void main(String[] args) {
 Collection<String> collection = new ArrayList<>();
 collection.add("张无忌");
 collection.add("谢逊");
 collection.add("周芷若");
 collection.add("小昭");
 collection.add("张三丰");
 collection.forEach(new Consumer<String>() {//匿名内部类
 @Override
 public void accept(String s) {
 System.out.println(s);
 }
 });
 collection.forEach(System.out::println);//Lambda表达式进行简化
 }
 }

public class Movie{
        private String name; //电影名称
        private double score; //评分
        private String actor; //演员
        //无参数构造方法
        public Movie(){}
        //全参数构造方法
        public Movie(String name, double score, String actor){
            this.name=name;
            this.score=score;
            this.actor=actor;
        }
        //...get、set、toString()方法自己补上..
    }

public class Test{
 public static void main(String[] args){
 Collection<Movie> movies = new ArrayList<>();
 movies.add(new MOvie("《肖申克的救赎》", 9.7, "罗宾斯"));
 movies.add(new MOvie("《霸王别姬》", 9.6, "张国荣、张丰毅"));
 movies.add(new MOvie("《阿甘正传》", 9.5, "汤姆汉克斯"));
 
 for(Movie movie : movies){
 System.out.println("电影名：" + movie.getName());
 System.out.println("评分：" + movie.getScore());
 System.out.println("主演：" + movie.getActor());
 }
 }
 }

![83104f6801024c6b8bacfb7c3bd272b4.png][]

**集合中存储的是元素对象的地址**

#### List系列集合 ####

![f05cd28cafca47c9b23048558c8a8081.png][]

##### List集合的常用方法 #####

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

<table> 
 <tbody> 
 <tr> 
 <td style="width:275px;"> 方法名称 </td> 
 <td style="width:493px;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="width:275px;"> void&nbsp;add(int&nbsp;index,E&nbsp;element) </td> 
 <td style="width:493px;"> 在此集合中的指定位置插入指定的元素 </td> 
 </tr> 
 <tr> 
 <td style="width:275px;"> E&nbsp;remove(int&nbsp;index) </td> 
 <td style="width:493px;"> 删除指定索引处的元素，返回被删除的元素 </td> 
 </tr> 
 <tr> 
 <td style="width:275px;"> E&nbsp;set(int&nbsp;index,E&nbsp;element) </td> 
 <td style="width:493px;"> 修改指定索引处的元素，返回被修改的元素 </td> 
 </tr> 
 <tr> 
 <td style="width:275px;"> E&nbsp;get(int&nbsp;index) </td> 
 <td style="width:493px;"> 返回指定索引处的元素 </td> 
 </tr> 
 </tbody> 
</table>

//1.创建一个ArrayList集合对象（有序、有索引、可以重复）
 List<String> list = new ArrayList<>();
 list.add("蜘蛛精");
 list.add("至尊宝");
 list.add("至尊宝");
 list.add("牛夫人"); 
 System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
 
 //2.public void add(int index, E element): 在某个索引位置插入元素
 list.add(2, "紫霞仙子");
 System.out.println(list); //[蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]
 
 //3.public E remove(int index): 根据索引删除元素, 返回被删除的元素
 System.out.println(list.remove(2)); //紫霞仙子
 System.out.println(list);//[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
 
 //4.public E get(int index): 返回集合中指定位置的元素
 System.out.println(list.get(3));
 
 //5.public E set(int index, E e): 修改索引位置处的元素，修改后，会返回原数据
 System.out.println(list.set(3,"牛魔王")); //牛夫人
 System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛魔王]

##### List集合支持的遍历方式 #####

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

**iterator迭代器**

**增强for循环**

**Lambda表达式（foreach）**

List<String> list = new ArrayList<>();
 list.add("蜘蛛精");
 list.add("至尊宝");
 list.add("糖宝宝");
 
 //1.普通for循环
 for(int i = 0; i< list.size(); i++){
 //i = 0, 1, 2
 String e = list.get(i);
 System.out.println(e);
 }
 
 //2.增强for遍历
 for(String s : list){
 System.out.println(s);
 }
 
 //3.迭代器遍历
 Iterator<String> it = list.iterator();
 while(it.hasNext()){
 String s = it.next();
 System.out.println(s);
 }
 
 //4.lambda表达式遍历
 list.forEach(s->System.out.println(s));

#### ArrayList底层的原理 ####

**基于数组实现的**

*  **查询速度快（注意：根据索引查询数据快）：查询数据通过索引直接定位，查询任意数据耗时相同**
 *  **删除效率低：需要把后面很多的数据进行前移**
 *  **添加效率极低：需要把后面很多的数据后移，再添加元素。也可能需要进行数组扩容**

我们知道数组的长度是固定的，但是集合的长度是可变的，这是怎么做到的呢？原理如下：

![0a6ff4c1172c40f5a7baf834336a02cc.png][]

**elementData是底层代码中arraylist创建对象时创建的空数组；**

#### LinkedList底层原理 ####

LinkedList底层是链表结构，链表结构是由一个一个的节点组成，一个节点由数据值、下一个元素的地址组成。如下图所示

![60c19526442948de941b0c4bf80d3915.png][]

*  **查询慢，无论查询那个都需要从头开始；**
 *  **增删相对于arraylist比较快；**

假如，现在要在B节点和D节点中间插入一个元素，只需要把B节点指向D节点的地址断掉，重新指向新的节点地址就可以了。如下图所示：

![a63ff340290d4ca99689897b70d3f084.png][]

假如，现在想要把D节点删除，只需要让C节点指向E节点的地址，然后把D节点指向E节点的地址断掉。此时D节点就会变成垃圾，会把垃圾回收器清理掉。

![363549c949d04b5cac94cc12e34c339d.png][]

上面的链表是单向链表，它的方向是从头节点指向尾节点的，只能从左往右查找元素，这样查询效率比较慢；还有一种链表叫做双向链表，不光可以从做往右找，还可以从右往左找。如下图所示： ![f6f689c8f802445f83dc724ab421470e.png][]

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

<table style="width:594px;"> 
 <tbody> 
 <tr> 
 <td style="width:239px;"> 方法名称 </td> 
 <td style="width:353px;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;void&nbsp;addFirst(E&nbsp;e) </td> 
 <td style="width:353px;"> 在该列表开头插入指定的元素 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;void&nbsp;addLast(E&nbsp;e) </td> 
 <td style="width:353px;"> 将指定的元素追加到此列表的末尾 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;E&nbsp;getFirst() </td> 
 <td style="width:353px;"> 返回此列表中的第一个元素 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;E&nbsp;getLast() </td> 
 <td style="width:353px;"> 返回此列表中的最后一个元素 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;E&nbsp;removeFirst() </td> 
 <td style="width:353px;"> 从此列表中删除并返回第一个元素 </td> 
 </tr> 
 <tr> 
 <td style="width:239px;"> public&nbsp;E&nbsp;removeLast() </td> 
 <td style="width:353px;"> 从此列表中删除并返回最后一个元素 </td> 
 </tr> 
 </tbody> 
</table>

####  ####

#### LinkedList集合的应用场景 ####

LInkedList集合有什么用呢？可以用它来**设计栈结构、队列结构。**

队列结构，队列结构你可以认为是一个上端开口，下端也开口的管子的形状。元素从上端入队列，从下端出队列。

![d638186cc1634eb1be171fb868d18417.png][]

package com.itcast.test;
 
 import java.util.LinkedList;
 
 public class Demo06 {
 public static void main(String[] args) {
 LinkedList<String> linkedList = new LinkedList<>();
 //进队列
 linkedList.add("000");
 linkedList.add("111");
 linkedList.add("222");
 linkedList.addLast("aaa");
 linkedList.addLast("bbb");
 linkedList.addLast("ccc");
 linkedList.addLast("ddd");
 
 System.out.println(linkedList);
 //出队列
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 System.out.println(linkedList.removeFirst());
 
 System.out.println(linkedList);
 
 }
 }

![1c047bab38154c338b2095e1220b0734.png][]

**队结构先进先出**

用LinkedList集合来模拟一下栈结构的效果。还是先来认识一下栈结构长什么样。栈结构可以看做是一个上端开头，下端闭口的水杯的形状。

元素永远是上端进，也从上端出，先进入的元素会压在最底下，所以**栈结构的特点是先进后出，后进先出**

![bcfdcab22ba8442f9d1674e5a9ae303e.png][]

package com.itcast.test;
 
 import java.util.LinkedList;
 
 public class Demo07 {
 public static void main(String[] args) {
 LinkedList<String> linkedList = new LinkedList<>();
 linkedList.push("第一颗子弹");//相当于addFirst
 linkedList.push("第二颗子弹");//相当于addFirst
 linkedList.push("第三颗子弹");//相当于addFirst
 linkedList.push("第四颗子弹");//相当于addFirst
 linkedList.push("第五颗子弹");//相当于addFirst
 linkedList.push("第六颗子弹");//相当于addFirst
 linkedList.push("第七颗子弹");//相当于addFirst
 
 System.out.println(linkedList);
 
 System.out.println(linkedList.pop());//相当于removeFirst
 System.out.println(linkedList.pop());
 System.out.println(linkedList.pop());
 System.out.println(linkedList.pop());
 System.out.println(linkedList.pop());
 System.out.println(linkedList.pop());
 System.out.println(linkedList.pop());
 
 System.out.println(linkedList);
 
 }
 }

![8460d1e78ccb44b2be820358df088d6a.png][]

1、LinkedList集合的底层是基于什么实现的？有什么特点？

**基于双链表实现的 查询慢，增删相对较快，但对首、尾元素进行增删改查的速度是极快的**

2、LinkedList集合适合什么业务场景？

**设计队列、设计栈。有专门对首、尾元素进行操作的方法**

#### set集合 ####

##### set集合的特点 #####

Set集合是属于Collection体系下的另一个分支，它的特点如下图所示

![eab7b49eb600486891d39b68472d4841.png][]

Set集合特点：

*  **无序**
 *  **不重复**
 *  **无索引**

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

package com.itcast.prepare;
 
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.TreeSet;
 
 public class Demo01 {
 public static void main(String[] args) {
 Set<String> set1 = new HashSet<>();//无序 无索引 无重复
 set1.add("aaa");
 set1.add("bbb");
 set1.add("ccc");
 set1.add("aaa");
 set1.add("aaa");
 set1.add("ddd");
 set1.add("ddd");
 System.out.println(set1);
 System.out.println("--------------------------");
 
 Set<String> set2 = new LinkedHashSet<>();//有序 无索引 无重复
 set2.add("aaa");
 set2.add("bbb");
 set2.add("aaa");
 set2.add("aaa");
 set2.add("ccc");
 set2.add("ddd");
 System.out.println(set2);
 System.out.println("--------------------------------");
 
 Set<String> set3 = new TreeSet<>();//可排序（升序） 无索引 无重复
 set3.add("aaaaaa");
 set3.add("bbb");
 set3.add("ccc");
 set3.add("bbb");
 set3.add("bbbbbbb");
 set3.add("ddd");
 System.out.println(set3);
 }
 }

![a4c80f4018e14323accbc50f4c6032c2.png][]

1.  **HashSet：无序 无索引 无重复；**
2.  **LinkedHashSet：有序 无索引 无重复；**
3.  **TreeSet ：排序（升序）无索引 无重复**

#### HashSet集合底层原理 ####

HashSet集合底层是基于哈希表实现的，哈希表根据JDK版本的不同，也是有点区别的

*  JDK8以前：哈希表 = 数组+链表
 *  **JDK8以后：哈希表 = 数组+链表+红黑树**

##### 哈希值 #####

*  就是一个int类型的数值，Java中每个对象都有一个哈希值。
 *  Java中的所有对象，都可以调用Obejct类提供的hashCode方法，返回该对象自己的哈希值。

Public int hashCode（）{//返回对象的哈希值码
    
    }

##### 对象哈希值的特点 #####

*  同一个对象多次调用hashCode()方法返回的哈希值是相同的。
 *  不同的对象，它们的哈希值一般不相同，但也有可能会相同(哈希碰撞)。

哈希表

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

![2b46c5c02db047c1b573d09528460a02.png][]

我们发现往HashSet集合中存储元素时，底层调用了元素的两个方法：一个是hashCode方法获取元素的hashCode值（哈希值）；另一个是调用了元素的equals方法，用来比较新添加的元素和集合中已有的元素是否相同。

*  只有新添加元素的hashCode值和集合中以后元素的hashCode值相同、新添加的元素调用equals方法和集合中已有元素比较结果为true, 才认为元素重复。
 *  如果hashCode值相同，equals比较不同，则以链表的形式连接在数组的同一个索引为位置（如上图所示）

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

在JDK8开始后，为了提高性能，当链表的长度超过8时，就会把链表转换为红黑树，如下图所示

![7bed560f00ce4a8897935e6fbc23c5b1.png][]

#### HashSet去重原理 ####

HashSet存储元素的原理，依赖于两个方法：一个是hashCode方法用来确定在底层数组中存储的位置，另一个是用equals方法判断新添加的元素是否和集合中已有的元素相同。

package com.itcast.prepare;
 
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 
 public class Demo02 {
 public static void main(String[] args) {
 Set<Student> hashSet = new HashSet<>();//创建hashSet对象
 //添加学生对象
 hashSet.add(new Student("张三",18,180.0));
 hashSet.add(new Student("王五",28,190.0));
 hashSet.add(new Student("王五",28,190.0));
 hashSet.add(new Student("李四",38,180.0));
 //增强for遍历
 for (Student student : hashSet) {
 System.out.println(student);
 }
 }
 
 }
 //编写学生的Javabean
 class Student{
 private String name;
 private int age;
 private double height;
 
 public Student() {
 }
 
 public Student(String name, int age, double height) {
 this.name = name;
 this.age = age;
 this.height = height;
 }
 
 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;
 }
 
 public double getHeight() {
 return height;
 }
 
 public void setHeight(double height) {
 this.height = height;
 }
 
 @Override
 public String toString() {
 return "Student{" +
 "name='" + name + '\'' +
 ", age=" + age +
 ", height=" + height +
 '}';
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
 
 Student student = (Student) o;
 
 if (age != student.age) return false;
 if (Double.compare(student.height, height) != 0) return false;
 return Objects.equals(name, student.name);
 }
 
 @Override
 public int hashCode() {
 int result;
 long temp;
 result = name != null ? name.hashCode() : 0;
 result = 31 * result + age;
 temp = Double.doubleToLongBits(height);
 result = 31 * result + (int) (temp ^ (temp >>> 32));
 return result;
 }
 }

![ea9a8d9c57c44aad809584d3e712eee1.png][]

只打印了一个王五，并且是无序的；

当我们使用Set集合时，都是去用它去除里面的重复元素，假如我们在存储的时候对于那些对象一一进行equals()方法进行比较的话，这效率可就太低了（耗时间又耗内存），而使用hash算法的HashCode()方法，则提高了去重的效率，也使equals()方法的执行次数大大降低！

1.当我们的HashSet调用add()方法去存储对象的时候，是先调用对象的HashCode（）得到一个哈希值，然后在集找是否有哈希值相同的对象。

（1）、如果没有哈希值相同的对象就直接加入到集合当中不用再经过equals(）方法进行比对

（2）、如果哈希值相同的对象的话，就进一步用equals()方法比对去重。

2. 将我们自定义的对象存入set集合当中时：

（1）、**类中必须重写equals()和HashSet()这两个方法**

（2）、HashCode()：属性相同的对象返回值必须是相同的，属性不相同的对象返回值一定不同

（3）、equals()：属性相同就返回true,属性不同就返回false;(此方法是判断是否为同一个对象终极审判)

#### LinkedHashSet底层原理 ####

HashSet的子类LinkedHashSet类。LinkedHashSet它底层采用的是也是哈希表结构，只不过额外新增了一个双向链表来维护元素的存取顺序。如下下图所示：

*  依然是基于哈希表（数组、链表、红黑树）实现的；
 *  每个元素额外多一个双链表的机制记录前后元素位置；

![d96f2744660e40878582c943633a1545.png][]

每次添加元素，就和上一个元素用双向链表连接一下。第一个添加的元素是双向链表的头节点，最后一个添加的元素是双向链表的尾节点。

import java.util.LinkedHashSet;
 import java.util.Objects;
 import java.util.Set;
 
 public class Dome03 {
 public static void main(String[] args) {
 Set<Students> linkedHashSet = new LinkedHashSet<>();
 
 linkedHashSet.add(new Students("张三",19,190.0));
 linkedHashSet.add(new Students("张三",19,190.0));
 linkedHashSet.add(new Students("李四",19,190.0));
 linkedHashSet.add(new Students("王五",19,190.0));
 
 linkedHashSet.forEach(System.out::println);
 
 }
 }
 //编写学生的Javabean
 class Students{
 private String name;
 private int age;
 private double height;
 
 public Students() {
 }
 
 public Students(String name, int age, double height) {
 this.name = name;
 this.age = age;
 this.height = height;
 }
 
 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;
 }
 
 public double getHeight() {
 return height;
 }
 
 public void setHeight(double height) {
 this.height = height;
 }
 
 @Override
 public String toString() {
 return "students{" +
 "name='" + name + '\'' +
 ", age=" + age +
 ", height=" + height +
 '}';
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
 
 Students students = (Students) o;
 
 if (age != students.age) return false;
 if (Double.compare(students.height, height) != 0) return false;
 return Objects.equals(name, students.name);
 }
 
 @Override
 public int hashCode() {
 int result;
 long temp;
 result = name != null ? name.hashCode() : 0;
 result = 31 * result + age;
 temp = Double.doubleToLongBits(height);
 result = 31 * result + (int) (temp ^ (temp >>> 32));
 return result;
 }
 }

![db2013fb47f54e989db0e582aefe7d50.png][]

####  ####

#### TreeSet集合 ####

TreeSet集合的特点是可以对元素进行排序，但是必须指定元素的排序规则。

如果往集合中存储String类型的元素，或者Integer类型的元素，它们本身就具备排序规则，所以直接就可以排序。

import java.util.Set;
 import java.util.TreeSet;
 
 public class Demo04 {
 public static void main(String[] args) {
 Set<String> treeSet = new TreeSet<>();
 
 treeSet.add("aaa");
 treeSet.add("aaa");
 treeSet.add("aaa");
 treeSet.add("bbb");
 treeSet.add("bbbbbbbbbbb");
 treeSet.add("ccc");
 treeSet.add("ddd");
 System.out.println(treeSet);
 
 Set<Integer> treeSet1 = new TreeSet<>();
 treeSet1.add(1);
 treeSet1.add(8);
 treeSet1.add(9);
 treeSet1.add(2);
 treeSet1.add(3);
 treeSet1.add(4);
 treeSet1.add(6);
 treeSet1.add(5);
 System.out.println(treeSet1);
 }
 }

如果往TreeSet集合中存储自定义类型的元素，比如说Student类型，则需要我们自己指定排序规则，否则会出现异常。

public class Demo05 {
 public static void main(String[] args) {
 Set<Student> ts = new TreeSet<>();
 ts.add(new Student("张三",19,180.0));
 ts.add(new Student("李四",28,198.0));
 ts.add(new Student("王五",29,164.0));
 System.out.println(ts);
 }
 }

此时运行代码，会直接报错。原因是TreeSet不知道按照什么条件对Student对象来排序。

![4ee53ff36ccf4415b6c534b7ccbf31b4.png][]

reeSet集合按照指定的规则排序，有两种办法：

*  第一种：让元素的类实现Comparable接口，重写compareTo方法

//编写学生的Javabean
 class Student implements Comparable<Student>{//实现compareable的接口并设置泛型
 private String name;
 private int age;
 private double height;
 
 public Student() {
 }
 
 public Student(String name, int age, double height) {
 this.name = name;
 this.age = age;
 this.height = height;
 }
 
 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;
 }
 
 public double getHeight() {
 return height;
 }
 
 public void setHeight(double height) {
 this.height = height;
 }
 
 @Override
 public String toString() {
 return "Student{" +
 "name='" + name + '\'' +
 ", age=" + age +
 ", height=" + height +
 '}';
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
 
 Student student = (Student) o;
 
 if (age != student.age) return false;
 if (Double.compare(student.height, height) != 0) return false;
 return Objects.equals(name, student.name);
 }
 
 @Override
 public int hashCode() {
 int result;
 long temp;
 result = name != null ? name.hashCode() : 0;
 result = 31 * result + age;
 temp = Double.doubleToLongBits(height);
 result = 31 * result + (int) (temp ^ (temp >>> 32));
 return result;
 }
 
 //重写compareTo方法
 @Override
 public int compareTo(Student s) {
 return this.age - s.age;//升序
 // return s.age - this.age;//降序
 }
 }

![ad3d2d12a82f45bd9b89c9963abda89f.png][]

*  第二种：在创建TreeSet集合时，通过构造方法传递Compartor比较器对象

注意：如果类本身有实现Comparable接口，TreeSet集合同时也自带比较器，默认使用集合自带的比较器排序。

public class Demo06 {
 public static void main(String[] args) {
 Set<Students> ts = new TreeSet<>(new Comparator<Students>() {
 @Override
 public int compare(Students s1, Students s2) {
 return s2.getAge() - s1.getAge();
 }
 });
 ts.add(new Students("张三", 19, 180.0));
 ts.add(new Students("李四", 28, 198.0));
 ts.add(new Students("王五", 29, 164.0));
 //System.out.println(ts);
 for (Students student : ts) {
 System.out.println(student);
 }
 }
 }

![e7bbdfc8344447cdae91e79a9a29fba5.png][]

TreeSet集合的特点是怎么样的？

**可排序、不重复、无索引 底层基于红黑树实现排序，增删改查性能较好**

TreeSet集合对自定义类型的对象排序，有几种方式指定比较规则？

**2种。 类实现Comparable接口，重写比较规则。 集合自定义Comparator比较器对象，重写比较规则。**

#### 并发修改异常 ####

public class Demo07 {
 public static void main(String[] args) {
 List<String> list = new ArrayList<>();
 list.add("王麻子");
 list.add("小李子");
 list.add("李爱花");
 list.add("张全蛋");
 list.add("晓李");
 list.add("李玉刚");
 
 Iterator<String> it = list.iterator();
 
 //需求：找到集合中带‘李’字的元素，并删除；
 while (it.hasNext()){
 String st = it.next();
 if (list.contains("李")){
 list.remove(st);
 }
 }
 System.out.println(list);
 }
 }

![1d5409bf48304817ab36457fee9d6f49.png][]

为什么会出现这个异常呢？那是因为迭代器遍历机制，**规定迭代器遍历集合的同时，不允许集合自己去增删元素**，否则就会出现这个异常。

怎么解决这个问题呢？不使用集合的删除方法，而是使用迭代器的删除方法，代码如下：

public class Demo07 {
 public static void main(String[] args) {
 List<String> list = new ArrayList<>();
 list.add("王麻子");
 list.add("小李子");
 list.add("李爱花");
 list.add("张全蛋");
 list.add("晓李");
 list.add("李玉刚");
 
 Iterator<String> it = list.iterator();
 
 //需求：找到集合中带‘李’字的元素，并删除；
 while (it.hasNext()){
 String st = it.next();
 if (st.contains("李")){//字符串的contains方法
 //list.remove(st);//集合的方法；
 it.remove();//迭代器的方法；
 }
 }
 System.out.println(list);
 }
 }

可变参数

*  **可变参数是一种特殊的形式参数，定义在方法、构造器的形参列表处，它可以让方法接收多个同类型的实际参数。**
 *  **可变参数在方法内部，本质上是一个数组**

import java.util.Arrays;
    
    public class Demo08 {
        public static void main(String[] args) {
            //空参
            test();
            //带参
            test(1,2,3,4,4,5);
            //传递一个数组
            int[] arr = {1,2,3,3,4,4,5,5};
            test(arr);
    
        }
        public static void test(int...nums){
            //可变参数本质上是一个数组
            System.out.println(nums.length);
            System.out.println(Arrays.toString(nums));
            System.out.println("---------------------");
        }
    }

![cfda048e6ecd49bb9a914eab72d082fc.png][]

最后还有一些错误写法，需要让大家写代码时注意一下，不要这么写哦！！！

>  *  **一个形参列表中，只能有一个可变参数；否则会报错**
>  *  **一个形参列表中如果多个参数，可变参数需要写在最后；否则会报错**

![c6897e4441c2418794c0b4095391f91e.png][]

#### Collections工具类 ####

注意Collections并不是集合，它比Collection多了一个s，一般后缀为s的类很多都是工具类。这里的Collections是用来操作Collection的工具类。它提供了一些好用的静态方法，如下

![275ce80c26a44a35aa3f2fd0048478d5.png][]

public class Demo09 {
 public static void main(String[] args) {
 List<String> list = new ArrayList<>();
 //批量添加
 Collections.addAll(list,"李四","王五","张三三");
 System.out.println(list);
 System.out.println("----------------------------------");
 //打乱集合中元素的顺序
 Collections.shuffle(list);
 System.out.println(list);
 System.out.println("----------------------------------");
 //对集合中的元素进行升序排列
 Collections.sort(list);
 System.out.println(list);
 System.out.println("----------------------------------");
 Collections.sort(list, new Comparator<String>() {
 @Override
 public int compare(String s1, String s2) {
 return s1.length() - s2.length();//升序
 }
 });
 System.out.println(list);
 System.out.println("----------------------------------");
 }
 }

![0d0a4428e3a643b2862691520f45b212.png][]

当集合中元素时对象时，我们需要自定义排序规则；

*  **让引用类实现Comparetor接口并指定泛型，并重新compareTo接口，在重写方法中制定排序规则，再调用Collections的sort方法；**

public class Demo10 {
 public static void main(String[] args) {
 List<Student> list = new ArrayList<>();
 list.add(new Student("蜘蛛精",23,169.7));
 list.add(new Student("紫霞",22,169.8));
 list.add(new Student("紫霞",22,169.8));
 list.add(new Student("至尊宝",26,169.5));
 Collections.sort(list);//调用Collections的sort方法，直接排序；
 for (Student student : list) {
 System.out.println(student);
 }
 }
 }
 //编写学生的Javabean
 class Student implements Comparable<Student>{//实现compareable的接口并设置泛型
 private String name;
 private int age;
 private double height;
 
 public Student() {
 }
 
 public Student(String name, int age, double height) {
 this.name = name;
 this.age = age;
 this.height = height;
 }
 
 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;
 }
 
 public double getHeight() {
 return height;
 }
 
 public void setHeight(double height) {
 this.height = height;
 }
 
 @Override
 public String toString() {
 return "Student{" +
 "name='" + name + '\'' +
 ", age=" + age +
 ", height=" + height +
 '}';
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
 
 Student student = (Student) o;
 
 if (age != student.age) return false;
 if (Double.compare(student.height, height) != 0) return false;
 return Objects.equals(name, student.name);
 }
 
 @Override
 public int hashCode() {
 int result;
 long temp;
 result = name != null ? name.hashCode() : 0;
 result = 31 * result + age;
 temp = Double.doubleToLongBits(height);
 result = 31 * result + (int) (temp ^ (temp >>> 32));
 return result;
 }
 
 //重写compareTo方法
 @Override
 public int compareTo(Student s) {
 return this.age - s.age;//升序
 // return s.age - this.age;//降序
 }
 }

![81feb465cb7d47379678d1eef609f8ca.png][]

*  直接调用Collections的sort方法并在方法的第二个参数传入比较器；

package com.itcast.prepare;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
 public class Demo10 {
 public static void main(String[] args) {
 
 List<Students> list = new ArrayList<>();
 
 list.add(new Students("蜘蛛精",23,169.7));
 list.add(new Students("紫霞",22,169.8));
 list.add(new Students("紫霞",22,169.8));
 list.add(new Students("至尊宝",26,169.5));
 
 Collections.sort(list, new Comparator<Students>() {
 @Override
 public int compare(Students s1, Students s2) {
 return s1.getAge() -s2.getAge();//升序
 }
 });//调用Collections的sort方法，直接排序；
 for (Students students : list) {
 System.out.println(students);
 }
 }
 }

![cad2cd78a5a24ce4abfa515bddcd2d1f.png][]

[7b46f93858d649c99a18b5a93d300359.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f3afe5a524d743af81d49a90a68e705c.png
[a2987226d04947888b51a992599a3053.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/78c082cd16c64f0582510d43bc3293d1.png
[83104f6801024c6b8bacfb7c3bd272b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/9ccdbe11152041a89f3907858a77cffb.png
[f05cd28cafca47c9b23048558c8a8081.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/a907dd7ef0104ed79f40b4bf6aa7c427.png
[0a6ff4c1172c40f5a7baf834336a02cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/7583529e561b432abcbafc04f76f8876.png
[60c19526442948de941b0c4bf80d3915.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/d4830713babd41a8ad83e6f52c366722.png
[a63ff340290d4ca99689897b70d3f084.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/060e891b834f4e13b6b304086b5403c0.png
[363549c949d04b5cac94cc12e34c339d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/151cf1ad8e034f3cbd1f3d1aabc0195d.png
[f6f689c8f802445f83dc724ab421470e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/314786c8327446ecab3949ee8bbe7171.png
[d638186cc1634eb1be171fb868d18417.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/cd7891d6a28b49db86d72d9cde4a9aaf.png
[1c047bab38154c338b2095e1220b0734.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/560784b4835e411ba7f00ee9da62ec27.png
[bcfdcab22ba8442f9d1674e5a9ae303e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/85cd15e01cf744eda3af0a7c59c49713.png
[8460d1e78ccb44b2be820358df088d6a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/d93c89f2ff074668b9b10b8ac42586f0.png
[eab7b49eb600486891d39b68472d4841.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/5f5437da8e4444029568afbac11a4319.png
[a4c80f4018e14323accbc50f4c6032c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/3f6765b125fe4fefae228194f7088e78.png
[2b46c5c02db047c1b573d09528460a02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/6d24e23a35f841ce9fcc99002b8c91e6.png
[7bed560f00ce4a8897935e6fbc23c5b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/d1459ac531344470ba711abb7cd2695d.png
[ea9a8d9c57c44aad809584d3e712eee1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/e005f93e52c7447eb3cb8bc0f1306f99.png
[d96f2744660e40878582c943633a1545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/0f972962c518452680c132c4c15be54c.png
[db2013fb47f54e989db0e582aefe7d50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f62ca54786e74f93828e83356f998baf.png
[4ee53ff36ccf4415b6c534b7ccbf31b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/cbe94af6149a42a99784dd7a65bb7e76.png
[ad3d2d12a82f45bd9b89c9963abda89f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/cbcb8cf8735e4b18bba9548df00139dd.png
[e7bbdfc8344447cdae91e79a9a29fba5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/cfe07826b3554136ad5e2f02f9a6f1b7.png
[1d5409bf48304817ab36457fee9d6f49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/7ae901143da94600afda7ae80a559151.png
[cfda048e6ecd49bb9a914eab72d082fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c94d60e0b6e144f09c8ddc9a829cbdb0.png
[c6897e4441c2418794c0b4095391f91e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/bf226e9960654701a95230cac37ddb4b.png
[275ce80c26a44a35aa3f2fd0048478d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/8f364182d11e49b1a4ff3e84fff6a877.png
[0d0a4428e3a643b2862691520f45b212.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/18f87cd634a844f5a802ca3bbe539150.png
[81feb465cb7d47379678d1eef609f8ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/1af894b2bd554f6b8fa621d6816ed962.png
[cad2cd78a5a24ce4abfa515bddcd2d1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/2556a5a6833e4e2db68292469e6e9ad9.png