前言：
上一篇我们说到了集合中list集合的特性以及其中的一些底层思想，没有看过的小伙伴快通过传送门过去
这期我们就来探讨以下list集合吧！看完觉得还不错的小伙伴记得一键三连哦~
目录
4.3、实现 java.util.comparator接口：比较器排序接口
1、Set集合的特点
1.1、无序
这里有小伙伴就会问了：哥哥酱~，为什么List集合同样是集合，他为什么就是有序的呢？
这是因为：Set集合的底层数据结构是哈希表，哈希表的实现方式是通过键（key）和值（value）之间的一一映射（即哈希函数），将每个键映射为一个唯一的取值范围较小的整数，然后将这个整数作为索引，将对应的值存储在对应的数组元素中。因为Set集合的元素是按照哈希值来存储的，而哈希值的顺序是无序的，所以Set集合本身是无序的。
1.2、不可重复
刚才说到了：Set集合内部使用了哈希表来存储元素，每个元素都对应一个唯一的哈希值，相同的元素在哈希表中只会存在一次。当我们想要向一个Set集合中添加元素时，Set会先计算该元素的哈希值，然后查看哈希表中是否已经存在相同哈希值的元素。如果存在相同哈希值的元素，则表明该元素已经存在于Set集合中，不会再次被添加。
2、Set集合的遍历方式
我可爱的小伙伴们又会问了：哥哥，哥哥，List集合遍历的方式有三种，那Set集合遍历的方式应该也是三种吧
答案是：两种
2.1、foreach遍历
HashSet hs = new HashSet<>();
hs.add("a");
hs.add("b");
hs.add("c");
// set 集合的遍历方式 只有两种
// for循环遍历
for (Object object : hs) {
System.out.println(object);
// 这里是有序的
}2.2、迭代器遍历
// 迭代器遍历
Iterator it = hs.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}为什么Set集合的遍历方式就只有两种呢？：由于Set集合是无序的，因此在遍历Set集合时，不能像数组一样使用简单的 for 循环进行遍历。如果使用 for 循环遍历Set集合，会导致元素的顺序不可预测，并且可能漏遍或重复遍历某些元素。
3、Set集合的去重原理
首先我们知道Set集合他是不可重复的，因为其底层是基于哈希表实现的，而哈希值是唯一的，所以，Set集合是不允许重复的，接下来，我们就来看一下操作上的原理吧
HashSet hs = new HashSet<>();
hs.add("a");
hs.add("b");
hs.add("c");
hs.add(new person(1, "w1", 13, 1800));
hs.add(new person(2, "w2", 14, 18000));
hs.add(new person(3, "w3", 15, 1900));
//此时我们添加两条数据
hs.add("a");
hs.add(new person(3, "w3", 15, 1900));
看看我们打印得到的结果是什么？
// person [id=1, name=w1, age=13, money=1800]
// a
// person [id=3, name=w3, age=15, money=1900]
// b
// c
// person [id=3, name=w3, age=15, money=1900]
// person [id=2, name=w2, age=14, money=18000]
细心的小伙伴们一定发现了，我们的字符串没有加进去，但是我们的对象居然加进去了，这是为什么呢？
这是因为，我只重写了equals方法（哥哥好坏~），但是其实，不管我的equals方法写没写，在添加对象的时候，都不会起到作用，那么这是为什么呢？
Set集合是Java中的一个接口，它是一个没有重复元素的集合，并且没有顺序。Set集合的去重原理是基于哈希码（hashCode）和相等性（equals）的。
在Java中，每个对象都有一个哈希码，用来标识该对象在哈希表中的位置。当我们把一个对象插入到Set集合中时，首先会通过该对象的哈希码来计算它在集合中的位置。如果该位置上没有元素，则直接将这个对象插入到该位置上；如果该位置上已经有元素，则会通过调用该元素的equals方法来判断该元素与插入的对象是否相等。如果相等，则认为插入的对象已存在于集合中，不再需要插入，否则就插入到集合中。
注 : 而我们如果没有重写hashcode方法的时候，它会默认返回false值 ，所以加不进，而在添加对象的时候，而只有hashcode方法返回true的时候，equals方法才会执行，所以这就验证了刚刚的问题
4、Set集合的排序方法
4.1、实现Java.lang.Comparable接口
要知道set集合的特点就是无序，不可重复
那我们什么情况下才会运用到这样的一个集合呢？
在企业中，我们用到的数据可不是本地的，所以此时我们拿到的数据就不是按照我们想要的 顺序来的，那么此时，我们应该怎么办呢？
package com.wenhao;
/**
* set的集合的排序
* 要知道set集合的特点就是无序，不可重复
* 那我们什么情况下才会运用到这样的一个集合呢？
* 在企业中，我们用到的数据可不是本地的，所以此时我们拿到的数据就不是按照我们想要的顺序来的，那么此时，我们应该怎么办呢？
* 这里就涉及到了我们的排序
* 1、实现 java.lang.Comparable，自然排序接口
* @author liwen
*
*/
import java.util.HashSet;
import java.util.TreeSet;
public class Demo2 {
public static void main(String[] args) {
//首先我们创建一个set集合
HashSet hs= new HashSet<>();
hs.add(new person1(1, "w1", 13, 1800));
hs.add(new person1(2, "w2", 14, 18000));
hs.add(new person1(3, "w3", 15, 1900));
hs.add(new person1(3, "w3", 16, 1900));
//此时就是一个默认排序，相当于别人给你的接口数据
for (Object object : hs) {
System.out.println(object);
}
System.out.println("================================");
//我们接下来对数据进行加工
//创建一个TreeSet集合
TreeSet set= new TreeSet<>();
//将老数据放进新集合中
for (Object object : hs) {
set.add(object);
}
//再次遍历集合，此时会报出一个错误，com.wenhao.person1 cannot be cast to java.lang.Comparable
//这段错误就是告诉我们我们没有实现Comparable接口，也就是说我们的person1不是Comparable的一个子类
//所以说我么要实现这个接口
//
for (Object object : set) {
System.out.println(object);
}
}
}
class person1 implements Comparable<person1> {
private int id;
private String name;
private int age;
private int money;
public person1() {
// TODO Auto-generated constructor stub
}
public person1(int id, String name, int age, int money) {
super();
this.id = id;
this.name = name;
this.age = age;
this.money = money;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public String toString() {
return "person1 [id=" + id + ", name=" + name + ", age=" + age + ", money=" + money + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + money;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
person1 other = (person1) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (money != other.money)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//那么现在我实现了这个接口，重写其中的方法
// 在实现Comparable接口的compareTo()方法时，
// 需要将当前对象与传入的对象进行比较，根据比较结果返回一个整数值，
// 该整数值表示当前对象与传入对象的大小关系。
@Override
public int compareTo(person1 o) {
return this.id-o.id;
//o.id-this.id 降序
//在compareTo()方法中，减法操作的目的是将结果转换为整数类型，
//计算的是当前对象与传入对象的属性之间的差值。如果结果为负数，则表示当前对象小于传入对象；
//如果结果为正数，则表示当前对象大于传入对象；如果结果为0，则表示两个对象相等。
}
}在实现
Comparable接口的compareTo()方法时，需要将当前对象与传入的对象进行比较，根据比较结果返回一个整数值，该整数值表示当前对象与传入对象的大小关系。在比较两个对象大小时，通常是根据对象的某些属性进行比较，若两个对象的属性相等则认为它们相等，若不相等则按照属性的大小关系返回比较结果。
而在
compareTo()方法中，减法操作的目的是将结果转换为整数类型，计算的是当前对象与传入对象的属性之间的差值。如果结果为负数，则表示当前对象小于传入对象；如果结果为正数，则表示当前对象大于传入对象；如果结果为0，则表示两个对象相等。
注意：如果出现这种错误 cannot be cast to java.lang.Comparable，那么就是没有实现comparable接口导致的
4.2、问题：
但是此时我们还可以发现一个问题就是，当我们重写comparato方法的的时候，如果相比较的字段是相同的，那么这条数据就会被判定成同一条数据，就无法拿到其他与这个字段相同的对象或者数据，那么此时我们应该怎么办呢？：比较两种字段，用到下面的比较器排序接口
4.3、实现 java.util.comparator接口：比较器排序接口
package com.wenhao;
import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;
/**
* set去重第二个方法：
* java.util.comparator接口：比较器排序接口
* @author liwen
*
*/
public class Demo3 {
public static void main(String[] args) {
//首先我们创建一个set集合
HashSet hs= new HashSet<>();
hs.add(new person2(1, "w1", 13, 1800));
hs.add(new person2(2, "w2", 14, 18000));
hs.add(new person2(3, "w3", 15, 1900));
hs.add(new person2(4, "w5", 13, 1900));
System.out.println("默认看到的数据===================================");
//此时就是一个默认排序，相当于别人给你的接口数据
for (Object object : hs) {
System.out.println(object);
}
System.out.println("我充钱了========================");
//创建已经定义好排序规则的set集合
TreeSet set1= new TreeSet<>(new Comparator<person2>() {
@Override
public int compare(person2 o1, person2 o2) {
// 比较o1和o2的大小
// 如果o1比o2小，则返回负数；
// 如果o1比o2大，则返回正数；
// 如果o1和o2相等，则返回0。
//根据金钱降序
return o2.getMoney()-o1.getMoney();
}
});
//循环添加定义好排序规则的新集合之中
for (Object object : hs) {
set1.add(object);
}
//打印
for (Object object : set1) {
System.out.println(object);
}
System.out.println("我充的钱是最多的======================");
//此时如果老板再次提出要求，在年龄相同的情况下，我要钱多的
//创建已经定义好排序规则的set集合
TreeSet set2= new TreeSet<>(new Comparator<person2>() {
@Override
public int compare(person2 o1, person2 o2) {
// 比较o1和o2的大小
// 如果o1比o2小，则返回负数；
// 如果o1比o2大，则返回正数；
// 如果o1和o2相等，则返回0。
//我先按照金钱排序
int n=o2.getMoney()-o1.getMoney();
//如果n=0了，那么就代表两人的年龄相同
if(n==0) {
return o2.getAge()-o1.getAge();
}
//根据金钱降序
return o2.getMoney()-o1.getMoney();
}
});
//循环添加定义好排序规则的新集合之中
for (Object object : hs) {
set2.add(object);
}
//打印
for (Object object : set2) {
System.out.println(object);
}
}
}
class person2 {
private int id;
private String name;
private int age;
private int money;
public person2() {
// TODO Auto-generated constructor stub
}
public person2(int id, String name, int age, int money) {
super();
this.id = id;
this.name = name;
this.age = age;
this.money = money;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public String toString() {
return "person1 [id=" + id + ", name=" + name + ", age=" + age + ", money=" + money + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + money;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
person2 other = (person2) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (money != other.money)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}在这里我们可以看到，我们我们是在创建集合的时候就实现了Comparator接口，那么这是为什么呢？
Comparable接口是一个类实现的接口，即如果一个类要自定义比较规则，则需要实现Comparable接口，并重写compareTo方法定义类对象的比较规则。由于一个类只能有一个比较规则，因此它只需要实现一次Comparable接口即可。
Comparator接口是一个独立的接口，用于定义两个对象的比较规则。在使用Comparator接口时，可以创建一个实现了该接口的对象，并把它作为集合构造函数的参数进行传递，在创建集合时就指定了比较规则。因此，Comparator接口并不局限于某一个类，一个实现了Comparator接口的类可以用于比较多个类的对象，即可以重用该比较逻辑。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
