Java集合（四）、继承自Collection接口的Set接口
一、Set接口的特点
一个不包含重复元素的collection。更确切地讲，Set不包含满足e1.equals(e2)的元素对 e1和e2，并且最多包含一个null元素。
Set集合由Set接口和Set接口的实现类组成，Set接口继承了Collection接口，因此包含了Collection接口的所有方法。其主要实现类有HashSet和TreeSet，在HashSet的基础上又延伸出了LinkedHashSet。
HashSet和TreeSet的不同就在于如何判断两个数是否相同的方法上。
1.HashSet判断两个对象是否相同的方法时继承自Object类的equals方法
（public boolean equals(Object o)方法只可以比较是否相等，相等返回true，反之返回false）。
2.TreeSet判断两个对象是否相同的方法则是Comparable接口中的compareTo()方法
（public void int compareTo(Object o)方法不仅可以比较是否相等，还可以比较大小，如果相等返回0，调用者大于参数则返回正数，否则返回负数）
所以可以得到添加到TreeSet中的对象必须实现Comparable接口。同时如果使用HashSet则最好重写equals()方法。
二、HashSet
HashSet实现了Set接口，基于HashMap进行存储。遍历时不保证顺序，并不保证下次遍历的顺序和之前一样。HashSet中允许null值。
进入到HashSet源码中我们发现，所有数据存储在
private transient HashMap<E, Object> map; private static final Object PRESENT = new Object();
意思就是HashSet的集合其实就是HashMap的key的集合，然后HashMap的val默认都是PRESENT。HashMap的定义即是key不重复的集合。使用HashMap实现，这样HashSet就不需要再实现一遍。
所以所有的add，remove等操作其实都是HashMap的add、remove操作。遍历操作其实就是HashMap的keySet的遍历,举例如下
...
public Iterator<E> iterator(){
return map.keySet().iterator();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public void clear() {
map.clear();
}
...
1.HashSet底层实际上是一个HashMap，HashMap底层采用了哈希表数据结构。
2.哈希表又叫散列表，哈希表底层是一个数组，这个数组中每一个元素是一个单向链表，每个单向链表都有一个独一无二的hash值，代表数组的下表。在某个单向链表中的每个节点上的hash值是相同的。hash值实际上是key调用hashCode方法，再通过“hash function”转换成的值。
3.如何向哈希表中添加元素？
先调用存储的key的hashCode方法，经过 某个算法得到hash值，如果这个哈希表中不存在这个hash值，则直接加入元素。如果该hash值已经存在，继续调用key之间的equals方法，如果equals方法返回false，则将该元素添加。如果equals方法返回true，则放弃添加该元素 ，即元素重复。
HashMap和HashSet的初始化容量是16，默认加载因子是0.75。
代码举例
public class Student{
private Integer id;
private String name;
public Student(Integer id, String name){
this.id = id;
this.name = name;
}
@Override
public String toString(){
return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
}
}
测试类
import java.util.*;
public class test{
public static void main(String[] args) {
Set<Student> set = new HashSet<>();
Student stu1 = new Student(1001, "leslie");
Student stu2 = new Student(1001, "leslie");
set.add(stu1);
set.add(stu2);
set.forEach(stu -> System.out.println(stu));
}
}
运行程序，得到如下结果
看到这个结果应该很惊讶，我们期望的是Set中存放的数据不可重复，而代码里的两个Student对象，学号与姓名都相同，插入到HashSet中后应该只保留一个对象。
这是因为Set集合中所说的不允许重复，这个重复是指对象的重复。何为同一个对象？即在内存中的编号是一致的。内存中的编号是什么？就是哈希码（哈希码一般是 类名 和 对象所在内存地址的十六进制数字表示 的组合）。
改造我们定义的Student类，为Student类增加hashCode()与equals()方法，即重写这两个方法。
public class Student{
private Integer id;
private String name;
public Student(Integer id, String name){
this.id = id;
this.name = name;
}
@Override
public String toString(){
return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
}
@Override
public boolean equals(Object o){
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student stu = (Student) o;
return id.equals(stu.id);
}
@Override
public int hashCode(){
return id.hashCode();
}
}
再次运行测试程序，结果如下：
此时，HashSet中只有一个对象。
另外，HashSet完全继承了Set或者Collection里的方法实现add、addAll、clear、isEmpty、size、contains、iterator、remove等
简单示例：
import java.util.*;
public class test{
public static void main(String[] args) {
HashSet<Integer> hashSet = new HashSet<>();
for (int i = 0; i < 10; i++){
hashSet.add((int)(Math.random()*100));
}
System.out.println(hashSet.size());
//打印
Iterator<Integer> it = hashSet.iterator();
while(it.hasNext()){
System.out.println(it.next() + " ");
}
//判断是否包含重复元素
System.out.println(hashSet.contains(8));
}
}
输出
三、TreeSet
TreeSet类型是J2SE中唯一可实现自动排序的类型
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向 TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
TreeSet集合：可以对Set集合中的元素进行排序。是不同步的。
但是TreeSet集合的存储是有序的，即：存储到集合中的元素是按自然顺序存储的。
判断元素唯一性的方式：
根据比较方法的返回值来判断。是0（零）就存入集合，不是0就不存。因为Set集合是不能有重复的元素，无序。
TreeSet要注意的事项：
1.往TreeSet里面添加元素时候，如果元素本具备自然顺序特性，那么就按照元素的自然顺序排序存储.
2.往TreSet里面添加元素时候，如果元素不具备自然顺序特性，那么该元素就必须要实现Comparable接口，把元素的比较规则定义在compareTo(T o)方法中
3.如果比较元素的时候，compareTo返回的是0，那么该元素被视为重复元素，不允许添加 (注意：TreeSet与HashCode，equals没有任何关系)
4.往TreeSet里面添加元素时候，如果元素本身不具备自然自然顺序特性，而且元素所属类也没有实现Comparable接口，那么我们必须要在创建TreeSet的时候传入一个比较器.
自定义比较器
自定一个比较器只需要实现接口 Comparator<T>即可，把元素与元素之间的比较规则定义在compare方法内即可
自定义比较器的格式：
class 类名 implements Comparator<T>{
}
Java中的TreeSet是Set的一个子类，TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一。TreeSet如何保证元素唯一呢，他是怎么样进行排序的呢？
首先来看一段代码
public class Person{
private Integer age;
private String name;
public Person(Integer age, String name){
this.age = age;
this.name = name;
}
}
import java.util.*;
public class test{
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person(23, "张三"));
ts.add(new Person(13, "李四"));
ts.add(new Person(13, "周七"));
ts.add(new Person(43, "王五"));
ts.add(new Person(33, "赵六"));
System.out.println(ts);
}
}
出错，会抛出一个异常：java.lang.ClassCastException显然是出现了类型转换异常。原因在于我们需要告诉TreeSet如何来进行比较元素，如果不指定，就会抛出这个异常
如何解决：
如何指定比较的规则，需要在自定义类(Person)中实现```Comparable```接口，并重写接口中的compareTo方法
public class Person implements Comparable<Person>{
private Integer age;
private String name;
public Person(Integer age, String name){
this.age = age;
this.name = name;
}
public int CompareTo(Person o){
return 0; //当compareTo方法返回0的时候集合中只有一个元素
return 1; //当compareTo方法返回正数的时候集合会怎么存就怎么取
return -1; //当compareTo方法返回负数的时候集合会倒序存储
}
为什么返回0，只会存一个元素，返回-1会倒序存储，返回1会怎么存就怎么取呢？
原因在于TreeSet底层其实是一个二叉树机构，且每插入一个新元素(第一个除外)都会调用```compareTo()```方法去和上一个插入的元素作比较，并按二叉树的结构进行排列。
1. 如果将```compareTo()```返回值写死为0，元素值每次比较，都认为是相同的元素，这时就不再向TreeSet中插入除第一个外的新元素。所以TreeSet中就只存在插入的第一个元素。
2. 如果将```compareTo()```返回值写死为1，元素值每次比较，都认为新插入的元素比上一个元素大，于是二叉树存储时，会存在根的右侧，读取时就是正序排列的。
3. 如果将```compareTo()```返回值写死为-1，元素值每次比较，都认为新插入的元素比上一个元素小，于是二叉树存储时，会存在根的左侧，读取时就是倒序序排列的。
（一）、自然排序
实现Comparable接口比较元素
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
利用上诉规则，我们就可以按照年龄来排序了。主要代码：
public int CompareTo(Person o){
int num = this.age - o.age; //年龄是比较的主要天骄
return num == 0 ? this.name.compareTo(o.name) : num; //姓名是比较的次要条件
}
完整代码：
import java.util.*;
class Person implements Comparable<Person>{
Integer age;
String name;
public Person (Integer age, String name){
this.age = age;
this.name = name;
}
//重写接口中的方法
//要重写比较规则
@Override
public int compareTo(Person o){
int num = this.age - o.age;
return num == 0 ? this.name.compareTo(o.name) : num;
}
@Override
public String toString(){
return "Person{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}
public class test{
//需求：将字符创安装长度排序
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person(23, "张三"));
ts.add(new Person(13, "李四"));
ts.add(new Person(13, "周七"));
ts.add(new Person(43, "王五"));
ts.add(new Person(33, "赵六"));
System.out.println(ts);
}
}
按照姓名排序（依据Unicode编码大小），主要代码如下：
public int CompareTo(Person o){
int num = this.name.compareTo(o.name); //姓名是比较的主要条件
retrun num == 0 ? this.age - o.age : num; //年龄是比较的次要条件
}
完整代码：
import java.util.*;
class Person implements Comparable<Person>{
Integer age;
String name;
public Person (Integer age, String name){
this.age = age;
this.name = name;
}
//重写接口中的方法
//要重写比较规则
@Override
public int compareTo(Person o){
int num = this.name.compareTo(o.name);
return num == 0 ? this.age - o.age : num;
}
@Override
public String toString(){
return "Person{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}
public class test{
//需求：将字符创安装长度排序
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person(23, "张三"));
ts.add(new Person(13, "李四"));
ts.add(new Person(13, "周七"));
ts.add(new Person(43, "王五"));
ts.add(new Person(33, "赵六"));
System.out.println(ts);
}
}
按照姓名长度排序,代码如下：
public int CompareTo(Person o){
int length = this.name.length() - o.name.length(); //比较长度为主要条件
int num = length == 0? this.name.compareTo(o.name) : length; //比较内容为此要条件
return num == 0 ? this.age - o.age : num; //比较年龄为次要条件
}
完整代码：
import java.util.*;
class Person implements Comparable<Person>{
Integer age;
String name;
public Person (Integer age, String name){
this.age = age;
this.name = name;
}
//重写接口中的方法
//要重写比较规则
@Override
public int compareTo(Person o){
int length = this.name.length() - o.name.length();
int num = length == 0 ? this.name.compareTo(o.name) : length;
return num == 0 ? this.age - o.age : num;
}
@Override
public String toString(){
return "Person{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}
public class test{
//需求：将字符创安装长度排序
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person(23, "张三呀"));
ts.add(new Person(13, "李"));
ts.add(new Person(13, "周七"));
ts.add(new Person(43, "王颜王五"));
ts.add(new Person(33, "赵leslie六"));
System.out.println(ts);
}
}
以上是TreeSet如何比较自定义对象，接下来我们再来看一下TreeSet如何利用比较器比较元素。
（二）定制排序
自定义比较器比较元素
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(To1,To2)方法
需求:现在要制定TreeSet中按照String长度比较String。
import java.util.*;
//定义一个类，实现Comparator接口，并重写compare()方法
class CompareByLen implements Comparator<String>{
@Override
public int compare(String s1, String s2){ //按照字符串的长度比较
int num = s1.length() - s2.length(); //长度为主要条件
return num == 0 ? s1.compareTo(s2) : num; //内容为次要条件
}
}
public class test{
//需求：将字符创安装长度排序
public static void main(String[] args) {
TreeSet<String> ts = new TreeSet<>(new CompareByLen());
//CompareByLen c = new CompareByLen();
ts.add("aaaaaaaa");
ts.add("z");
ts.add("wc");
ts.add("nba");
ts.add("cba");
System.out.println(ts);
}
}
（三）TreeSet总结：
1.特点
TreeSet是用来排序的，可以指定一个顺序，对象存入之后会按照指定的顺序排列
2.使用方式
（1）自然顺序（Comparable）
TreeSet类的add()方法会把存入的对象提升为Comparable类型
调用对象的comparaTo()方法和集合中的对象比较
根据comparaTo()方法返回的结果进行存储
（2）比较器顺序
创建TreeSet的时候可以指定一个Comparator
如果传入了Comparator的子类对象，那么TreeSet就会按照比较器的顺序排序。
add()方法内部会自动调用Comparator接口中的compare()方法排序
调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
（3）两种方式的区别
TreeSet构造函数什么都不传，默认按照类中Comparable的顺序（没有就报错ClassCastException）
TreeSet如果传入Comparator，就有先按照Comparator
四、LinkedList
（一）、LinkedList概述
LinkedHashSet集合也是根据元素hashCode值来决定元素存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里元素时，HashSet将会按元素的添加顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。
（代码示例）
import java.util.*;
public class test{
public static void main(String[] args) {
LinkedHashSet<String> books = new LinkedHashSet<>();
books.add("java");
books.add("Linux");
books.add("C++");
books.add("算法");
System.out.println(books);
//删除 Java
books.remove("java");
//重新添加Java
books.add("java");
System.out.println(books);
}
}
运行结果为：
我们可以看到，“java”所在的位置发生了变化，也证明了插入顺序就是遍历顺序。
（二）LinkedHashSet结论
输出LinkedHashSet集合中的元素时，元素的顺序总是和添加顺序一致。
