JavaSE学习进阶day06_02 Set集合和Set接口
第二章 Set系列集合和Set接口
Set集合概述：前面学习了Collection集合下的List集合，现在继续学习它的另一个分支，Set集合。
set系列集合的特点：
Set接口：
java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口都会以某种规则保证存入的元素不出现重复。
Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet、java.util.TreeSet这两个集合。
tips:Set集合取出元素的方式可以采用：迭代器、增强for。
2.1 HashSet集合介绍
java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:
public class HashSetDemo {public static void main(String[] args) {//创建 Set集合HashSet<String> set = new HashSet<String>();
//添加元素set.add(new String("cba"));set.add("abc");set.add("bac"); set.add("cba"); //遍历for (String name : set) {System.out.println(name);}}
}
输出结果如下，说明集合中不能存储重复元素：
cba abc bac
tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。
为了方便理解，我们再给出一个例子：
我们发现重复的的第二个“111”字符串没有被添加进去，说明HashSet的特点就是像上面所说的，有去重复的功能，或者说不能添加重复的数据。因此打印只打印了一个字符串：“111”
再看：
添加的顺序是"111"、"333"、"222"，但是打印的顺序是"111"、"222"、"333"，说明打印顺序和添加顺序没有关系，也就是存的顺序和取的顺序不一致。也就是说HashSet是无序的。其实在底层是用HashMap实现的，后面会细说。
至于无索引怎么体现呢，可以到JDK参考文档里查看，HashSet集合里没有获取索引的方法。因此这也是它的一个特点：无索引。
HashSet在开发中的使用场景：
可以利用HashSet的特性给数据去重
代码示例：
//练习需求：给ArrayList进行去重
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("bbb");
list.add("ccc");
list.add("ccc");
System.out.println(list);
//可以利用HashSet的特性给数据去重
HashSet<String> hs = new HashSet<>();
//把list集合中所有的元素全部添加到hs当中
hs.addAll(list);
//无序
System.out.println(hs);
运行结果：
2.2 HashSet集合存储数据的结构（哈希表）
什么是哈希表呢？在了解哈希表之前先得知道哈希值：
JDK1.7的哈希值：
关于更多哈希值的知识点请查看课件PPT的内容。
在JDK1.8之前，哈希表底层采用数组+链表实现，即使用数组处理冲突，同一hash值的链表都存储在一个数组里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，且数组长度大于等于64时，将链表转换为红黑树，这样大大减少了查找时间。
简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。
看到这张图就有人要问了，这个是怎么存储的呢？
为了方便大家的理解我们结合一个存储流程图来说明一下：
总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须重写hashCode和equals方法建立属于当前对象的比较方式。
哈希表详细流程：
2.3 HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时，比如学生类型，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一.
创建自定义Student类:
public class Student {private String name;private int age;
public Student() {}
public Student(String name, int age) {this.name = name;this.age = age;}
/* 获取* @return name*/public String getName() {return name;}
/* 设置* @param name*/public void setName(String name) {this.name = name;}
/* 获取* @return age*/public int getAge() {return age;}
/* 设置* @param age*/public void setAge(int age) {this.age = age;}
@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && Objects.equals(name, student.name);}
@Overridepublic int hashCode() {return Objects.hash(name, age);}
public String toString() {return "Student{name = " + name + ", age = " + age + "}";}
}
创建测试类:
public class HashSetDemo1 {public static void main(String[] args) {//创建集合HashSet<Student> hs = new HashSet<>();
//如果在Student类中，没有重写hashCode和equals方法//都是操作的都是地址值。//如果我们认为，属性相同，就是同一个对象，那么就需要重写hashCode和equals方法//添加元素hs.add(new Student("zhangsan",23));hs.add(new Student("zhangsan",23));hs.add(new Student("zhangsan",23));
System.out.println(hs);}
}
这段代码可能理解不透彻，我细说一下，现在就是创建一个学生类Student类，学生属性有姓名跟年龄，我们用快捷键生成标准javabean类后，如下：
注意啊，现在没有重写equals方法和hashCode方法，我们在测试类写入如下代码并运行：
发现重复的元素也添加进去了，这是为什么？？不是说HashSet不是有不重复的特点吗？为啥上面那个String就不能添加重复的元素，而自定义的Student类不能。这就是我们要讨论的问题。当添加的元素是自己自定义的类型后，就需要重写equals方法和hashCode方法。快捷键：alt+insert：
原来这个快捷键每一项都是有用的，现在学了很多了。重写后我们再运行上面那个代码：
发现现在不能添加重复的元素了。总结：再用HashSet集合添加自定义元素（除了java提供的都叫自定义元素）时，都要重写equals和hashCode方法才能保证它的不重复性。前面那个String之所以不能添加重复元素，是因为在String类已经重写equals和hashCode方法了。其他包装类也是如此。
2.4 LinkedHashSet
我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。它能使得元素存放时是有序的。但是在以后的开发中，LinkedHashSet用的不多，因为它的底层多了一个双向链表，效率有点低。以后用hashSet的比较多。
先看一个代码：
发现添加元素的顺序和打印的顺序是一致的。相比hashSet，LinkHashSet就多了一个有序性。
演示代码如下:
public class LinkedHashSetDemo {public static void main(String[] args) {Set<String> set = new LinkedHashSet<String>();set.add("bbb");set.add("aaa");set.add("abc");set.add("bbc");Iterator<String> it = set.iterator();while (it.hasNext()) {System.out.println(it.next());}}
}
结果：bbbaaaabcbbc
2.5 TreeSet集合
1. 特点
TreeSet集合是Set接口的一个实现类,底层依赖于TreeMap,是一种基于红黑树的实现,其特点为：
元素唯一（不能添加重复的元素）
元素没有索引
使用元素的自然顺序对元素进行排序，或者根据创建 TreeSet 时提供的 Comparator比较器 进行排序，具体取决于使用的构造方法：
先看一个案例：
发现Integer打印的是默认升序排序，且不能添加重复的元素。
2.排序方式一：默认方式
默认的排序方式，也叫做自然排序。
是让Javabean类实现Comparable接口，重写里面的compareTo方法来实现的。
注意点：
1.Java已经写好的String，Integer已经定义好了默认规则。
String：按照首字母的字典顺序排序，如果首字母一样，则比较第二个字母。
Integer：升序
2.我们自己定义了Javabean类需要指定默认排序规则，否则会报错。
代码示例1（存自定义对象）：
package com.itheima.a04treesetdemo;
public class Student implements Comparable<Student> {private String name;private int age;
//...空参...//...有参...//...get和set方法...//...toString方法...
@Overridepublic int compareTo(Student o) {//按照年龄进行排序//this表示当前要添加的元素//o：已经在树里面存在的元素//如果结果是负数，那么就存左边（降序）//如果结果是正数，那么就存右边（升序）//如果结果是0，认为现在要添加的元素跟当前元素一直，就不存
//System.out.println("this:" + this);//System.out.println("o:" + o);return this.age - o.age;}
}
代码示例2（存Integer）：
案例演示自然排序(20,18,23,22,17,24,19):
public static void main(String[] args) {//无参构造,默认使用元素的自然顺序进行排序TreeSet<Integer> set = new TreeSet<Integer>();set.add(20);set.add(18);set.add(23);set.add(22);set.add(17);set.add(24);set.add(19);System.out.println(set);
}
控制台的输出结果为:
[17, 18, 19, 20, 22, 23, 24]
3.排序方式二：比较器排序
创建集合对象时，传递Comparator实现类的对象，并重写compare方法。
并在使用的时候，默认用第一种，当第一种不能满足要求的时候，可以用第二种排序方式。
比如，Integer默认升序，如果我想降序排列，就需要用第二种了。
比如，String默认按照字典的顺序排列，如果我想按照字符串的长度排列，就需要用第二种了。
案例：
演示比较器排序(20,18,23,22,17,24,19):
public static void main(String[] args) {//有参构造,传入比较器,使用比较器对元素进行排序TreeSet<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//元素前 - 元素后 : 升序//元素后 - 元素前 : 降序（C语言库的快速排序算法就是这个原理）return o2 - o1;}});set.add(20);set.add(18);set.add(23);set.add(22);set.add(17);set.add(24);set.add(19);System.out.println(set);
}
控制台的输出结果为:
[24, 23, 22, 20, 19, 18, 17]
2.6练习-存储学生信息按照总分排序
需求：
需求：键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
隐藏的排序规则：总分一致还得按照语文，数学，英语，姓名这样的顺序排序。
分析
①定义学生类
②创建TreeSet集合对象，通过进行排序
③创建学生对象
④把学生对象添加到集合
⑤遍历集合
注意：
在指定顺序的时候默认按照自然排序方式，当自然排序不能满足我们的要求时，就用比较器排序。
代码示例：
public class Student implements Comparable<Student>{private String name;private double chinese;private double math;private double english;...空参构造......带参构造......get和set方法......toString方法...
@Overridepublic int compareTo(Student o) {//this odouble sum1 = this.chinese + this.math + this.english;double sum2 = o.chinese + o.math + o.english;double sum = sum1 - sum2;
//总分一样，看语文double result = sum == 0 ? this.chinese - o.chinese : sum;//语文一样，看数学
result = result == 0 ? this.math - o.math : result;//学生一样，看英语result = result == 0 ? this.english - o.english : result;//英语一样，看姓名result = result == 0 ? this.name.compareTo(o.name) : result;return (int)result;}
}
public class TreeSetTest1 {public static void main(String[] args) {//1.创建集合TreeSet<Student> ts = new TreeSet<>();
//2.//只要使用TreeSet就一定要指定排序规则。//首先默认按照自然排序Scanner sc = new Scanner(System.in);for (int i = 0; i < 3; i++) {System.out.println("请输入学生的姓名");String name = sc.next();System.out.println("请输入语文成绩");double chinese = sc.nextDouble();System.out.println("请输入数学成绩");double math = sc.nextDouble();System.out.println("请输入英语成绩");double english = sc.nextDouble();
Student s = new Student(name,chinese,math,english);ts.add(s);}//打印System.out.println(ts);}
}
这个代码含金量很高，一定要掌握，自己手动写出来！！TreeSet的内容差不多就这些了，掌握到这里就已经不错了！
单列集合总结：
以后单列集合用的最多的是，ArrayList、HashSet、TreeSet。前面两种用的最为频繁。默认用ArrayList，要去重的话用HashSet，如果需要排序用TreeSet（这是今后开发用的实战用到的哦）。
LinkedHashSet和LinkedList基本用不到。
可变参数：什么是可变参数？为什么要引入可变参数？如下：
如果我们按照之前的做法就是重写多个方法，这样会非常麻烦，因为你也不知道数据有几个，或者有的人直接创建数组，然后传入数组长度，这样也可以，但是还是有点小丢丢麻烦。可变参数就是可以传入任意个数的参数。
如：
测试类：可以传任意个数的数据，这就是可变参数，它的本质就是用数组实现的。
注意：当形参有多个时，可变参数只能写在最后面的位置!!放在前面的话后面的形参会传递不到值。
