1. Set系列集合
一、Set系列集合概述
Set系列集合特点
● 无序：存取顺序不一致
● 不重复：可以去除重复
● 无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取。
Set集合实现类特点
● HashSet：无序、不重复、无索引
● LinkedHashSet：有序、不重复、无索引
● TreeSet：排序、不重复、无索引
【代码实例1】使用HashSet
public class SetDemo01 {
public static void main(String[] args){
// 看看Set系列集合的特点： HashSet LinkedHashSet TreeSet
// 无序、不重复、无索引
Set<String> sets = new HashSet<>(); //一行经典代码
sets.add("Mysql");
sets.add("Mysql");
sets.add("Java");
sets.add("Java");
sets.add("HTML");
sets.add("HTML");
sets.add("SpringBoot");
sets.add("SpringBoot");
System.out.println(sets);
}
}运行结果：
[Java, Mysql, HTML, SpringBoot]
【代码示例2】使用LikedHashSet
public class SetDemo01 {
public static void main(String[] args){
// 看看Set系列集合的特点： HashSet LinkedHashSet TreeSet
Set<String> sets = new LinkedHashSet<>(); //有序 不重复 无索引
sets.add("Mysql");
sets.add("Mysql");
sets.add("Java");
sets.add("Java");
sets.add("HTML");
sets.add("HTML");
sets.add("SpringBoot");
sets.add("SpringBoot");
System.out.println(sets);
}
}运行结果：
[Mysql, Java, HTML, SpringBoot]
二、HashSet元素无序的底层原理：哈希表
HashSet底层原理
● HashSet集合底层采取哈希表存储的数据。
● 哈希表是一种对于增删改查数据性能都较好的结构。
哈希表的组成
● JDK 8之前的，底层使用数组+链表组成
● JDK 8开始后，底层使用数组+链表+红黑树组成
在了解哈希表之前需要理解哈希值的概念
哈希值
● 是JDK根据对象的地址，按照某种规则算出来的int类型的数值。
Object类的API
● public int hashCode( ) ：返回对象的哈希值
对象的哈希值特点
● 同一个对象多次调用hashCode( )方法返回的哈希值是相同的
● 默认情况下，不同对象的哈希值是不同的
【代码示例1】
public class SetDemo02 {
public static void main(String[] args) {
//目标：学会获取对象的哈希值，并确认一下
String name = "yezi";
System.out.println(name.hashCode());
String name2 = "yazi";
System.out.println(name2.hashCode());
}
}运行结果：
3705659
3701815两者的运行结果不一样
HashSet1.7版本
JDK1.8版本开始HashSet原理解析
● 底层结构：哈希表（数组、链表、红黑树的结合体）
● 当挂在元素下面的数据过多时，查询性能降低，从JDK开始后，当链表长度超过8的时候，自动转换为红黑树。
哈希表的详细流程
● 创建一个默认长度为16，默认加载因为0.75的数组，数组名table
● 根据与那苏的哈希值跟数组的长度计算出应存如的位置
● 判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素，则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。
● 当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍。
三、HashSet元素去重复的底层原理
HashSet去重复原理解析图：
结论：如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的HashCode( )和equals( )方法
【案例】Set集合去重复
需求：
创建一个存储学生对象的集合，存储多个学生对象，使用程序实现控制台遍历该集合，要求：学生对象的成员变量值相同，我们就认为是同一个对象
分析：
① 定义学生类，创建HashSet集合对象，创建学生对象
② 把学生添加到集合
③ 在学生类中重写两个方法，hashCode( )和equals( )，自动生成即可
④ 遍历集合（增强for）
【代码示例】
定义类：Student
点击查看代码
public class Student {
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
//只要2个对象内容一样，结果一定是true
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return getAge() == student.getAge() &&
getSex() == student.getSex() &&
Objects.equals(getName(), student.getName());
}
/**
* s1 = new Student("无恙",20,'男')
* s2 = new Student("无恙",20,'男')
* s3 = new Student("周雄",21,'男')
* @return
*/
@Override
public int hashCode() {
return Objects.hash(getName(), getAge(), getSex());
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}测试类：
/**
* 目标：让Set集合把重复内容的对象去掉一个（去重复）
*/
public class SetDemo03 {
public static void main(String[] args) {
// Set集合去重原因：先判断哈希值，在判断equals
Set<Student> sets = new HashSet<>();
Student s1 = new Student("无恙",20,'男');
Student s2 = new Student("无恙",20,'男');
Student s3 = new Student("周雄",21,'男');
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
sets.add(s1);
sets.add(s2);
sets.add(s3);
System.out.println(sets);
}
}运行结果：
800712763
800712763
680875133
[Student{name='无恙', age=20, sex=男}, Student{name='周雄', age=21, sex=男}]
四、实现类LinkedHashSet
LinkedHashSet集合概述和特点
● 有序、不重复、无索引
● 这里的有序指的是保证存储和取出的元素顺序一致
● 原理：底层数据结构依然是哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。
【示例代码】
public class Demo01 {
public static void main(String[] args) {
Set<String> sets = new LinkedHashSet<>();
sets.add("Java");
sets.add("Java");
sets.add("MySQL");
sets.add("C++");
sets.add("MySQL");
sets.add("HTML");
System.out.println(sets);
}
}运行结果：
[Java, MySQL, C++, HTML]
五、TreeSet集合概述和特点
TreeSet集合概述和特点
● 可排序、不重复、无索引
● 可排序：按照元素的大小默认升序（有小有大）排序。
● TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
● 注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。
TreeSet集合默认排序的规则
● 对于数值类型：Integer，Double，官方默认按照大小进行升序排序。
● 对于字符串类型：默认按照首字符的编号升序排序。
● 对于自定义类型如Student对象，TreeSet无法直接排序。
结论：想要使用TreeSet存储自定义类型，需要指定排序规则
【代码示例1】
public class SetDemo01 {
public static void main(String[] args) {
Set<Integer> sets = new TreeSet<>(); //不重复、无索引、可排序
sets.add(23);
sets.add(24);
sets.add(12);
sets.add(8);
System.out.println(sets);
Set<String> sets1 = new TreeSet<>();//不重复、无索引、可排序
sets1.add("Java");
sets1.add("Java");
sets1.add("angels");
sets1.add("叶子");
sets1.add("Java");
sets1.add("About");
sets1.add("Python");
sets1.add("UI");
sets1.add("UI");
System.out.println(sets1);
}
}运行结果：
[8, 12, 23, 24]
[About, Java, Python, UI, angels, 叶子]
自定义排序规则
● TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则
方式一
● 让自定义的类（如学生类）实现Comparable接口重写里面的compareTo方法来定制比较规则。
方式二
● TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。
两种方式中，关于返回值的规则：
● 如果认为第一个元素大于第二个元素返回正整数即可。
● 如果认为第一个元素小于第二个元素返回负整数即可。
● 如果认为第一个元素等于第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复
注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序
【代码示例1】方式一：类自定义比较规则 o1.compareTo(o2)
定义类：Apple
点击查看代码
public class Apple implements Comparable<Apple>{
private String name;
private String color;
private double price;
private int weight;
public Apple() {
}
public Apple(String name, String color, double price, int weight) {
this.name = name;
this.color = color;
this.price = price;
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Apple{" + "name=" + name + ", color=" + color+ ", price=" + price + ", weight=" + weight + '}' +"\n";
}
/**
* 方式一：类自定义比较规则
* o1.compareTo(o2)
* @param o
* @return
*/
@Override
public int compareTo(Apple o) {
//按照重量进行比较的
return this.weight - o.weight; // 去重weight重复的元素 升序
// return this.weight - o.weight >= 0 ? 1 : -1; // 保留weight重复的元素
}
}测试类：
public class SetDemo01 {
public static void main(String[] args) {
Set<Apple> apples = new TreeSet<>();
apples.add(new Apple("红苹果", "红色", 9.9, 500));
apples.add(new Apple("青苹果", "青色", 15.9, 300));
apples.add(new Apple("绿苹果", "绿色", 29.9, 400));
apples.add(new Apple("黄苹果", "黄色", 9.8, 500));
System.out.println(apples);
}
}运行结果：
[Apple{name=青苹果, color=青色, price=15.9, weight=300}
, Apple{name=绿苹果, color=绿色, price=29.9, weight=400}
, Apple{name=红苹果, color=红色, price=9.9, weight=500}
]
【代码示例2】方式二：集合自带比较器对象进行规则定制
定义类：Apple
点击查看代码
public class Apple implements Comparable<Apple>{
private String name;
private String color;
private double price;
private int weight;
public Apple() {
}
public Apple(String name, String color, double price, int weight) {
this.name = name;
this.color = color;
this.price = price;
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Apple{" + "name=" + name + ", color=" + color+ ", price=" + price + ", weight=" + weight + '}' +"\n";
}
/**
* 方式一：类自定义比较规则
* o1.compareTo(o2)
* @param o
* @return
*/
@Override
public int compareTo(Apple o) {
//按照重量进行比较的
return this.weight - o.weight; // 去重weight重复的元素 升序
// return this.weight - o.weight >= 0 ? 1 : -1; // 保留weight重复的元素
}
}测试类：
public class SetDemo01 {
public static void main(String[] args) {
//方式二：集合自带比较器对象进行规则定制
Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
@Override
public int compare(Apple o1, Apple o2) {
//return o1.getWeight() - o2.getWeight(); //升序
//return o2.getWeight() - o1.getWeight(); //降序
// 注意：浮点型建议直接使用Double.compare进行比较
return Double.compare(o2.getPrice(),o1.getPrice());
}
});
apples.add(new Apple("红苹果", "红色", 9.9, 500));
apples.add(new Apple("青苹果", "青色", 15.9, 300));
apples.add(new Apple("绿苹果", "绿色", 29.9, 400));
apples.add(new Apple("黄苹果", "黄色", 9.8, 500));
System.out.println(apples);
}
}运行结果：
[Apple{name=黄苹果, color=黄色, price=9.8, weight=500}
, Apple{name=红苹果, color=红色, price=9.9, weight=500}
, Apple{name=青苹果, color=青色, price=15.9, weight=300}
, Apple{name=绿苹果, color=绿色, price=29.9, weight=400}
]
