Set系列集合特点：
- 无序:存取顺序不一致
- 不重复:可以去除重复
- 无索引:没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。
Set集合实现类特点：
- Hashset :无序、不重复、无索引。
- LinkedHashSet:有序、不重复、无索引。
- TreeSet:排序、不重复、无索引。
Set集合的功能基本上与Collection的API一致。
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo1 {
public static void main(String[] args) {
//Hashset :无序、不重复、无索引。
// Set<String> sets = new HashSet<>();
//LinkedHashSet:有序、不重复、无索引。
// Set<String> sets = new LinkedHashSet<>();
//TreeSet:排序、不重复、无索引。
Set<String> sets = new TreeSet<>();
sets.add("java");
sets.add("java");
sets.add("Mybatis");
sets.add("HTML");
sets.add("Spring");
sets.add("Java");
// System.out.println(sets);//HashSet:[Java, java, HTML, Spring, Mybatis]无序不重复无索引
// System.out.println(sets);//LinkedHashSet:[java, Mybatis, HTML, Spring, Java]有序不重复无索引
System.out.println(sets);//TreeSet:[HTML, Java, Mybatis, Spring, java]无序不重复无索引
}
}HashSet元素无序的底层原理：哈希表
- HashSet集合底层采取哈希表存储的数据。
- 哈希表是一种对于增删改查数据性能都较好的结构。
哈希表的组成：
- JDK8之前的，底层使用数组+链表组成
- JDK8开始后，底层采用数组+链表+红黑树组成。
哈希值：
- 是JDK根据对象的地址，按照某种规则算出来的int类型的数值。
- Object类的API：public int hashcode():返回对象的哈希值
- 对象的哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的。
- 默认情况下，不同对象的哈希值是不同的。
public class HashDemo {
public static void main(String[] args) {
String name = "oreo";
//同一对象的哈希值一样
System.out.println(name.hashCode());//3419597
System.out.println(name.hashCode());//3419597
//不同对象间的哈希值不一样
String name1 = "oreo1";
System.out.println(name1.hashCode());//106007556
System.out.println(name1.hashCode());//106007556
}
}HashSet1.7版本原理解析：数组＋链表＋(结合哈希算法)：
- 创建一个默认长度16的数组，数组名table
- 根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法)
- 判断当前位置是否为null，如果是null直接存入
- 如果位置不为null，表示有元素，则调用equals方法比较
- 如果一样，则不存，如果不一样，则存入数组
- JDK7新元素占老元素位置，指向老元素（链表）
- JDK8中新元素挂在老元素下面
结论:哈希表是一种对于增删改查数据性能都较好的结构。
JDK1.8版本开始HashSet原理解析：哈希表（数组、链表、红黑树的结合体)，当挂在元素下面的数据过多时，查询性能降低，从JDK8开始后，当链表长度超过8的时候，自动转换为红黑树。
哈希表的详细流程：
- 创建一个默认长度16，默认加载因为0.75的数组，数组名table
- 根据元素的哈希值跟数组的长度计算出应存入的位置
- ③判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素，则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。
- ④当数组存满到16*0.75=12时，就自动扩容，每次扩容为原先的两倍。
HashSet去重复原理解析：
- 创建一个默认长度16的数组，数组名table
- 根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法)
- 判断当前位置是否为null，如果是null直接存入
- 如果位置不为null，表示有元素，则调用equals方法比较
- 如果一样，则不存，如果不一样，则存入数组，
结论:如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法
LinkedHashSet集合
- 概述和特点：有序、不重复、无索引。
- 这里的有序指的是保证存储和取出的元素顺序一致。
- 原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。
Treeset集合
- 概述和特点：不重复、无索引、可排序。
- 可排序:按照元素的大小默认升序（有小到大)排序。
- TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
- 注意:TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。
Treeset集合默认的规则
- 对于数值类型: Integer , Double，官方默认按照大小进行升序排序。
- 对于字符串类型：默认按照首字符的编号升序排序。
- 对于自定义类型如Student对象，TreeSet无法直接排序。
结论：想要使用TreeSet存储自定义类型，需要制定排序规则。
自定义排序规则
- TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则
方式一
- 让自定义的类（如学生类)实现Comparable接口重写里面的compareTo方法来定制比较规则。
方式二
- TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。
两种方式中，关于返回值的规则:
- 如果认为第一个元素大于第二个元素返回正整数即可。
- 如果认为第一个元素小于第二个元素返回负整数即可。
- 如果认为第一个元素等于第二个元素返回0即可，此时TreeSet集合只会保留一个元素，认为两者重复。
import java.applet.AppletContext;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) {
Set<Integer> sets = new TreeSet<>();
sets.add(1);
sets.add(33);
sets.add(8);
sets.add(12);
sets.add(5);
System.out.println(sets);//[1, 5, 8, 12, 33]
Set<String> sets1 = new TreeSet<>();
sets1.add("java");
sets1.add("about");
sets1.add("python");
sets1.add("About");
sets1.add("樊东");
sets1.add("ui");
System.out.println(sets1);//[About, about, java, python, ui, 樊东]
System.out.println("-----------------------");
//方式二：集合自带的比较器对象进行规则定制
//如果方式一和方式二都有，默认使用方式二
// 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());//按照价格降序
// }
// });
//简化版
Set<Apple> apples = new TreeSet<>((o1, o2)-> Double.compare(o2.getPrice(),o1.getPrice()));
apples.add(new Apple("红苹果","红色",9.9,500));
apples.add(new Apple("绿苹果","绿色",19.9,300));
apples.add(new Apple("青苹果","青色",14.9,700));
apples.add(new Apple("黄苹果","黄色",9.8,500));
System.out.println(apples);
/*
只用方式一的结果
[Apple{name='绿苹果', color='绿色', price=19.9, weight=300},
Apple{name='黄苹果', color='黄色', price=9.8, weight=500},
Apple{name='红苹果', color='红色', price=9.9, weight=500},
Apple{name='青苹果', color='青色', price=14.9, weight=700}]
*/
/*
方式二：按照价格降序
[Apple{name='绿苹果', color='绿色', price=19.9, weight=300},
Apple{name='青苹果', color='青色', price=14.9, weight=700},
Apple{name='红苹果', color='红色', price=9.9, weight=500},
Apple{name='黄苹果', color='黄色', price=9.8, weight=500}]
*/
}
}public class Apple implements Comparable<Apple>{
private String name;
private String color;
private double price;
private int weight;
public Apple(String name, String color, double price, int weight) {
this.name = name;
this.color = color;
this.price = price;
this.weight = weight;
}
public Apple() {
}
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 +
'}';
}
/**
* 方式一：类自定义比较规则
* @param o
* @return
*/
@Override
public int compareTo(Apple o) {
//按照重量比较
// return this.weight - o.weight; //会去掉重量重复的元素
return this.weight - o.weight >= 1 ? 1:-1;//保留重量重复的元素
}
}如果希望元素可以重复，又有索引，索引查询要快?
- 用ArrayList集合，基于数组的。(用的最多)
如果希望元素可以重复，又有索引，增删首尾操作快?
- 用LinkedList集合，基于链表的。（栈、队列、排队叫号系统）
如果希望增删改查都快，但是元素不重复、无序、无索引。
- 用HashSet集合，基于哈希表的。
如果希望增删改查都快，但是元素不重复、有序、无索引。
- 用LinkedHashSet集合，基于哈希表和双链表。
如果要对对象进行排序。
- 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。
版权声明：本文为m0_47320958原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。