目录
Set
1、Set集合概述及特点：
public interface Set<E> extends Collection<E> 不包含重复元素的集合。 更正式地，集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多一个空元素。
Set接口继承自Collection接口的所有构造函数（方法）。Set与Collection方法一模一样。
2、Set集合子类如何保证元素唯一？
HashSet
1、Set集合子类HashSet<E>概述：
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable ，此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。 它不保证set的迭代顺序; 特别是它不保证该顺序在一段时间内保持不变。此类允许使用null元素。翻译：存取顺序不一致，可以存储null。
2、案例演示：HashSet存储字符串并遍历。
import java.util.HashSet;
/**
* set集合中元素无索引，不可以重复，无序（存取顺序不一致）
*/
public class Demo1_HashSet {
public static void main(String[] args) {
HashSet<String> hs = new HashSet<>(); //创建HashSet对象。
boolean b1 = hs.add("a");
boolean b2 = hs.add("a"); //当向Set集合中存储重复元素的时候返回为false。
System.out.println(hs); //HashSet的继承体系中有重写toString方法
System.out.println(b1); //true
System.out.println(b2); //false
//HashSet的爷爷类AbstractCollection重写了toString()
/*public String toString() {
Iterator<E> it = iterator(); //获取迭代器
if (! it.hasNext()) //如果迭代器中没有元素
return "[]"; //返回[]
StringBuilder sb = new StringBuilder(); //如果有元素，创建StringBuilder
sb.append('['); //将元素不断进行添加
for (;;) {
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString(); //最后将元素转换成toString给返回
sb.append(',').append(' ');
}
}*/
System.out.println("----------------------------------");
hs.add("d");
hs.add("c");
hs.add("b");
System.out.println(hs);
for (String string : hs) { //只要能使用迭代器迭代的，就可以使用增强for循环遍历。
System.out.println(string);
}
}
}3、案例演示：HashSet存储自定义对象，并保证元素唯一性。
import java.util.HashSet;
import com.bean.Person;
public class Demo2_HashSet {
public static void main(String[] args) {
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("张三", 23));
hs.add(new Person("张三", 23));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
//即使重写了自定义类中的equals方法，依然所有元素都在。因为并没有执行。
//重写了hashCode方法后，保证元素唯一了，我们并没有调equals方法，equals方法也跟着执行了。
//集合的每个对象元素进入集合的内存空间时，对象元素会自动调对应自定义类的hashCode()给自己算一个具体的hashCode值（地址值），每个对象的hashCode值都不一样所以不会调equals()进行比较。因为地址值都不一样，所以重复的对象都保留了。
//重写hashCode()给定一个固定的值（任意），不让自己算了。地址值相同的对象元素，调用equals()进行比较，如果元素属性值相同，则返回值是true，就不存了。如果元素属性不同，HashSet有桶结构，新元素会像桶一样挂在被比较的元素上。再进来的元素会先与挂着的元素比较。
System.out.println(hs.size());
System.out.println(hs);
}
}
重写hashCode()和equals()方法
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
public int hashCode() {
return 10;
}
代码优化：
为了减少比较，优化hashCode()代码写法。最终版就是自动生成即可。
Alt + Shift + S + H 自动生成hashCode()和equals()。
//这么复杂是为了少调用equals()，提高程序的运行效率。
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj) //传入对象等于调用对象，说明两个引用指向同一个对象。
return true; //直接返回true
if (obj == null) //传入的对象为null
return false; //返回false
if (getClass() != obj.getClass()) //调用的字节码对象和传入的字节码对象不是同一个。内存中同名的字节码文件只能有一个。
return false; //直接返回false。 到这里，判断了传入对象一定是自定义对象，跟被调用对象不是同一个对象，肯定是有值的，和被调用对象属于同一个字节码文件生成的对象。
Person other = (Person) obj; //向下转型 因为上一步进行过判断，所以不会出现类型转换异常。
if (age != other.age) //调用对象的年龄不等于传入对象的年龄
return false; //返回false
if (name == null) { //调用对象的name属性为null，name是自定义对象的属性，是可以赋值为null的(不给赋值)，不存在空指针异常。
if (other.name != null) //传入对象的name属性不为null
return false; //返回false
} else if (!name.equals(other.name))//调用对象的姓名不等于传入对象的姓名
return false; //返回false
return true; //返回true
}prime等于31是因为：
31是一个质数，质数是仅能被1和自己整除的数，这样他的公约数就少了，就可以降低重复的可能性。
31这个数既不大也不小。大了，进行运算之后可能超过int的取值范围，小了，最后相乘的结果可能还是重复的。能不重复尽量不重复。
31这个数好算，2的5次方减1，2向左移动5位再减去一。
4、HashSet如何保证元素唯一性的原理：
1.HashSet原理：
我们使用Set集合都需要去掉重复元素，如果在存储的时候逐个元素调用equals()进行比较，效率较低。哈希算法提高了去重复的效率，降低了使用equals()的次数。
当HashSet调用add()方法存储对象的时候，先调用对象的hashCode()方法得到一个哈希值，然后在集合中查找是否有哈希值相同的对象。
如果没有哈希值相同的对象就直接存入集合。
如果有哈希值相同的对象，就和哈希值相同的对象逐个元素调用equals()进行属性值比较，比较结果为false就存入，为true则不存入。
2.将自定义类的对象存入HashSet去重复：
类中必须同时重写hashCode()和equals()。如果只重写了hashCode()，存储时hashCode值都不一样，但是比较equals()全都为false，因为equals()比较是按照对象的地址值进行比较的，所以重复的都没有去掉。
hashCode()：属性值相同的对象返回值必须相同，属性值不同的对象返回值尽量不同（这样做是提高效率，降低使用equals()）。尽量不同说明有几率一样，但尽量保证不一样。
equals()：属性值相同返回true，属性值不同返回false，返回false的时候存储。
LinkedHashSet
1、LinkedHashSet概述：
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable，哈希表和链表实现了Set接口，具有可预测的迭代次序。这种实现不同于HashSet，它维持于所有条 目的运行双向链表。该链表定义了迭代排序，它是将元素插入集合（插入顺序 ） 的顺序 。请注意，如果一个元件被重新插入到组插入顺序不受影响 。（元件e重新插入一组s如果当s.contains(e)将返回true之前立即调用s.add(e)被调用。）
普通方法全部继承自父类以及其间接父类。
java.util包下，使用需要导包。
可以保证怎么存就怎么取，且能保证元素唯一。LinkedHashSet底层是链表实现的，是Set集合中唯一一个能保证怎么存就怎么取的集合对象。因为是HashSet的子类，所以也是保证元素唯一的，与HashSet的原理一样。LinkedHashSet可以看成Linked和HashSet两部分。
如果没要求怎么存就怎么取，就用HashSet，HashSet效率稍微比LinkedHashSet高一点。
2、案例演示：产生10个1-20之间的随机数要求随机数不能重复。
需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。
import java.util.HashSet;
import java.util.Random;
/**
* 需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。
* 分析：
* 1.用Random类创建随机数对象。
* 2.需要存取10个随机数，而且不能重复。所以我们用HashSet集合。
* 3.条件：如果HashSet的size是小于10就可以不断地存储；如果大于等于10，就停止存储。
* 4.通过Random类中的nextInt(n)获取1到20之间的随机数，并将这些随机数存储在HashSet集合中。
* 5.遍历HashSet。
*/
public class Test1 {
public static void main(String[] args) {
//1.用Random类创建随机数对象。
Random r = new Random();
//2.需要存取10个随机数，而且不能重复。所以我们用HashSet集合。
HashSet<Integer> hs = new HashSet<>();
//3.条件：如果HashSet的size是小于10就可以不断地存储；如果大于等于10，就停止存储。
while(hs.size() < 10) {
//4.通过Random类中的nextInt(n)获取1到20之间的随机数，并将这些随机数存储在HashSet集合中。
hs.add(r.nextInt(20) + 1);
}
//5.遍历HashSet。
for (Integer integer : hs) {
System.out.println(integer);
}
}
}3、练习1：使用Scanner从键盘读取一行输入，去掉其中重复字符，打印出不同的那些字符：aaaabbbcccddd。
import java.util.HashSet;
import java.util.Scanner;
/**
* 练习：使用Scanner从键盘读取一行输入，去掉其中重复字符，打印出不同的那些字符：aaaabbbcccddd。
* 分析：
* 1.创建Scanner对象。
* 2.创建HashSet对象，将字符存储，去掉重复字符。
* 3.将字符串转换为字符数组，获取每一个字符存储在HashSet集合中，自动去除重复。
* 4.遍历HashSet集合，打印每一个字符。
*/
public class Test2 {
public static void main(String[] args) {
//1.创建Scanner对象。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一行字符串：");
//2.创建HashSet对象，将字符存储，去掉重复字符。
HashSet<Character> hs = new HashSet<>();
//3.将字符串转换为字符数组，获取每一个字符存储在HashSet集合中，自动去除重复。
String line = sc.nextLine();
char[] arr = line.toCharArray();
//遍历字符数组。
for (char c : arr) { //char自动装箱成包装类Character。所以也可以直接写Character。
hs.add(c);
}
//4.遍历HashSet集合，打印每一个字符。
for(Character ch : hs) {//同理，这里直接写char也是可以的，自动拆箱。集合存储对象，遍历是当char遍历。
System.out.print(ch);
}
}
}4、练习2：将集合中的重复元素去掉。
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
/**
* 练习：将集合中的重复元素去掉。
* 分析：
* 1.创建一个List集合，存储若干个重复元素。
* 2.单独定义方法去除重复。
* 3.再打印一下List集合。
*/
public class Test3 {
public static void main(String[] args) {
//1.创建一个List集合，存储若干个重复元素。
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
list.add("c");
//2.单独定义方法去除重复。
getSingle(list);
//3.再打印一下List集合。
System.out.println(list);
}
/**
* 分析：去除List集合中的重复元素。
* 1.创建一个LinkedHashSet集合。
* 2.将List集合中所有的元素添加到LinkedHashSet集合中。
* 3.将List集合中的元素清除。
* 4.将LinkedHashSet集合中的元素添加回List集合中。
*/
public static void getSingle(List<String> list) {
//1.创建一个LinkedHashSet集合。
LinkedHashSet<String> lhs = new LinkedHashSet<>();
//2.将List集合中所有的元素添加到LinkedHashSet集合中。
lhs.addAll(list);
//3.将List集合中的元素清除。
list.clear();
//4.将LinkedHashSet集合中的元素添加回List集合中。
list.addAll(lhs);
}
}TreeSet
1、案例演示：TreeSet存储Integer类型的元素并遍历。
import java.util.TreeSet;
/**
* 案例演示：TreeSet存储Integer类型的元素并遍历。
* TreeSet集合是用来对元素进行排序的，同时也能保证元素的唯一。
*/
public class Demo3_TreeSet {
public static void main(String[] args) {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(3);
ts.add(1);
ts.add(1);
ts.add(2);
ts.add(2);
ts.add(3);
ts.add(3);
System.out.println(ts);
}
}
2、TreeSet存储自定义对象。
import java.util.TreeSet;
import com.bean.Person;
/**
* 自定义类的对象需要具备比较性，让自定义类去实现Comparable接口，并重写compareTo方法。依赖此功能即可保证TreeSet中元素唯一。保证元素唯一其实都是依赖一些功能的。就像HashSet必须重写HashCode和equals方法。
* 当compareTo()返回0的时候，集合中只有一个元素。
* 当compareTo()返回正数的时候，集合会怎么存就怎么取（正序）。
* 当compareTo()返回负数的时候，集合会逆序存储。
*/
public class Demo4_TreeSet {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("张三", 23)); //ClassCastException
ts.add(new Person("李四", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
ts.add(new Person("张三", 23));
System.out.println(ts);
}
}
Comparable<T>接口概述：
public interface Comparable<T>，该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。参数类型：T - 可以将此对象与之进行比较的对象类型。
Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。
Comparable<T>接口的普通方法：
int compareTo(T o)，将此对象与指定的对象进行比较以进行排序。 返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。
3、TreeSet自然存储自定义对象和保证元素唯一的原理：
根据compareTo返回值。TreeSet底层是二叉树。
二叉树：两个叉。小的存储在左边（返回正数），大的存储在右边（返回负数），相等就不存（返回0）。
因此compareTo()，在TreeSet集合中如何存储元素取决于compareTo()的返回值。
ⅰ.返回值为0，集合中只有一个元素。首先第一个元素进集合作为二叉树的根，第二个元素进来调用compareTo()，compareTo()返回值是0，不储存该元素，同理剩余元素也不存储。
ⅱ.返回值为-1（负数），集合会将存储的元素倒序。首先第一个元素进集合作为二叉树的根，第二个元素进来调用compareTo()，compareTo()返回值是-1，-1表示该元素比根元素要小，所以存储在根元素的左边，第三个元素进来调用compareTo()与根元素作比较，compareTo()返回值是-1；再与第二个元素作比较，compareTo()返回值还是-1，成为第二个元素的左子树。同理其余元素进集合依次从根向下比较，返回值是-1就成为最底层元素的左子树。取的时候，树底层左边元素是最小的，再逐层依次向上取。
ⅲ.返回值为1（正数），集合会怎么存就怎么取。首先第一个元素进集合作为二叉树的根，第二个元素进来调用compareTo()，compareTo()返回值是1，1表示该元素比根元素要大，所以存储在根元素的右边，第三个元素进来调用compareTo()与根元素作比较，compareTo()返回值是1；再与第二个元素作比较，compareTo()返回值还是1，成为第二个元素的右子树。同理其余元素进集合依次从根向下比较，返回值是1就成为最底层元素的右子树。取的时候，根元素是最小的，再逐层依次向下取。
总结：比根元素小的存左边，比根元素大的存右边。比根元素大，比右子树小的存右子树左边。
取的时候从左边最小的开始取，取完根元素，到根元素的右边，先看右子树有没有他的左子树，有就先取他的左子树，再取他本身。
举例：自定义对象实现Comparable接口后重写的compareTo()：
//按照年龄排序 public int compareTo(Person o) { int num = this.age - o.age; //年龄是比较的主要条件 return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件 }String中重写了compareTo方法：int compareTo(String anotherString) 按字典顺序比较两个字符串。
4、练习1：案例演示：TreeSet存储自定义对象并遍历练习1(按照姓名排序)
import java.util.TreeSet;
import com.bean.Person;
/**
* 案例演示：TreeSet存储自定义对象并遍历练习1(按照姓名排序)
*/
public class Test4 {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("李四", 13));
ts.add(new Person("张三", 23));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
System.out.println('张' + 0); //24352
System.out.println('李' + 0); //26446
System.out.println('王' + 0); //29579
System.out.println('赵' + 0); //36213
System.out.println(ts);
}
}自定义类中重写的compareTo()
//按照姓名排序
public int compareTo(Person o) {
int num = this.name.compareTo(o.name); //姓名是比较的主要条件
return num == 0 ? this.age - o.age : num; //年龄是比较的次要条件
}5、练习2：案例演示：TreeSet存储自定义对象并遍历练习2(按照姓名的长度排序)
import java.util.TreeSet;
import com.bean.Person;
/**
* 案例演示：TreeSet存储自定义对象并遍历练习2(按照姓名的长度排序)
*/
public class Test5 {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("zhangsan", 23));
ts.add(new Person("lisi", 13));
ts.add(new Person("wangwu", 33));
ts.add(new Person("zhaoliu", 43));
ts.add(new Person("aaaa", 53));
System.out.println(ts);
}
}
自定义类中重写的compareTo()
//按照姓名的长度排序
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; //年龄是比较的次要条件
}
6、比较器排序：
案例演示：TreeSet保证元素唯一和比较器排序的原理及代码实现。
import java.util.Comparator;
import java.util.TreeSet;
/**
* 案例演示：TreeSet保证元素唯一和比较器排序的原理及代码实现。
*/
public class Test6 {
public static void main(String[] args) {
//需求：将字符串按照长度排序
TreeSet<String> ts = new TreeSet<>(new CompareByLen()); //Comparator c = new CompareByLen(); 父类引用指向子类对象
ts.add("aaaaaaaa"); //现在按比较器里的顺序排序
ts.add("z");
ts.add("wc");
ts.add("nba");
ts.add("cba");
System.out.println(ts);
}
}
class CompareByLen implements Comparator<String> { //CompareByLen使我们自己定义的比较器。
//重写了compare()，之所以没重写equals()也没报错，是因为所有类默认继承Object。所以从对象类里继承了equals方法。实现接口时，只要有该方法即可。
public int compare(String s1, String s2) { //按照字符串的长度比较
int num = s1.length() - s2.length(); //长度为比较的主要条件
return num == 0 ? s1.compareTo(s2) : num; //内容为比较的主要条件
}
}
首先，第一个元素进树集作根元素。第二个元素进树集，为s1，根元素为s2，用s1的长度减去s2的长度，跟compareTo()原理相同，正右负左零不存。第三个元素进树集，为s1，根元素为s2，用s1的长度减去s2的长度，正右负左零不存，如果第三个元素与第二个元素符号相同（正、负或0），则出现在根元素的同一边，即需要再做一次比较。此时，第三个元素为s1，第二个元素为s2，用s1的长度再减去s2的长度，正右负左零不存。其余元素与之前原理相同。
总结：谁来调用这个实现了Comparator接口的方法谁就是s1，集合中的元素就是s2。也是Compare()的返回值决定了排序方法，正右负左零不存。
7、TreeSet的构造方法：
TreeSet(Comparator<? super E> comparator) 构造一个新的，空的TreeSet(树集)，根据指定的比较器进行排序。
Comparator<T>接口概述：
public interface Comparator<T>，比较功能，对一些对象的集合施加了一个整体排序 。 可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。java.util包下，需要导包。
Comparator<T>接口方法：
int compare(T o1, T o2) 比较其两个参数的顺序。 返回负整数，零或正整数，因为第一个参数小于，等于或大于第二个参数。跟compareTo的原理相同，正右负左零不存。
boolean equals(Object obj) 指示某个其他对象是否等于此比较器。 该方法必须遵守Object.equals(Object)的一般合同。 另外， 只有指定的对象也是一个比较器，这个方法只能返回true ，并且它与这个比较器的顺序相同。
8、TreeSet原理：
1.特点：
TreeSet是用来排序的，可以指定一个顺序，对象存入之后会按照指定的顺序排列。TreeSet有两种排序方式：自然排序和比较器排序。
2.使用方式：
ⅰ.自然顺序(Comparable) 需要你存储的这个类去实现Comparable接口，这个类创建的对象要具备一个比较的功能（重写Comparable接口内的compareTo()）。
原理：
TreeSet类的add()方法中会把存入的对象提升为Comparable类型。不实现Comparable接口，就会报类型转换异常异常。
调用对象的compareTo()和集合中的对象比较。哪个元素存进去，谁就调compareTo()。把集合中的元素当做参数传进来与调用该方法的元素进行比较。
根据compareTo()返回的结果进行存储（正右负左零不存）。
ⅱ.比较器顺序(Comparator)。
原理：
创建TreeSet的时候可以制定 一个Comparator。
如果传入了Comparator的子类对象，那么TreeSet就会按照比较器中的顺序排序。
add()方法内部会自动调用Comparator接口中compare()排序。
调用对象的是compare方法的第一个参数，集合中的对象是compare方法的第二个参数。
ⅲ.两种方式的区别：
TreeSet构造函数什么都不传，默认按照类中Comparable的顺序去比较(没有Comparable就报ClassCastException)。
TreeSet如果传入Comparator比较器，就会优先按照Comparator去排序。
9、比较器练习1：在一个集合中存储了无序并且重复的字符串，定义一个方法,让其有序(字典顺序)，而且还不能去除重复。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
/**
* 练习：在一个集合中存储了无序并且重复的字符串，定义一个方法,让其有序(字典顺序)，而且还不能去除重复。
* 分析：
* 1.定义一个List集合，并存储重复的无序的字符串。
* 2.定义方法对其排序，保留重复。
* 3.打印List集合。
*/
public class Test7 {
public static void main(String[] args) {
//1.定义一个List集合，并存储重复的无序的字符串。
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("ccc");
list.add("ddd");
list.add("fffffffffff");
list.add("niubi");
list.add("itcast");
list.add("bbbb");
list.add("aaa");
list.add("aaa");
//2.定义方法对其排序，保留重复。
sort(list);
//3.打印List集合。
System.out.println(list);
}
/**
* 定义方法，排序并保留重复。
* 分析：
* 1.创建TreeSet集合对象。因为String本身就具备比较功能，但是重复不会保留，所以我们用比较器。
* 2.将list集合中所有的元素添加到TreeSet集合中，对其排序，保留重复。
* 3.清空list集合。
* 4.将TreeSet集合中排好序的元素添加到List集合中。
*/
public static void sort(List<String> list) {
//1.创建TreeSet集合对象。因为String本身就具备比较功能，但是重复不会保留，所以我们用比较器。
TreeSet<String> ts = new TreeSet<>(new Comparator<String>() { //new Comparator<>(){}代表Comparator的子类对象(实现了Comparator接口的方法)。匿名内部类。
public int compare(String s1, String s2) {
int num = s1.compareTo(s2); //比较内容为主要条件
return num == 0 ? 1 : num; //保留重复
}
});
//2.将list集合中所有的元素添加到TreeSet集合中，对其排序，保留重复。
ts.addAll(list);
//3.清空list集合。
list.clear();
//4.将TreeSet集合中排好序的元素添加到List集合中。
list.addAll(ts);
}
}10、比较器练习2：从键盘接收一个字符串，程序对其中所有字符进行排序，例如键盘输入：helloitcast。程序打印：acehillostt。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/**
* 练习：从键盘接收一个字符串，程序对其中所有字符进行排序，例如键盘输入：helloitcast。程序打印：acehillostt。
* 分析：
* 1.键盘录入字符串，Scanner。
* 2.将字符串转换成字符数组。
* 3.定义TreeSet集合，传入比较器对字符排序并保留重复。
* 4.遍历字符数组，将每一个字符存储在TreeSet集合中。
* 5.遍历TreeSet集合，打印每一个字符。
*/
public class Test8 {
public static void main(String[] args) {
//1.键盘录入字符串，Scanner。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//2.将字符串转换成字符数组。
char[] arr = line.toCharArray();
//3.定义TreeSet集合，传入比较器对字符排序并保留重复。
TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {
public int compare(Character c1, Character c2) {
// int num = c1.compareTo(c2); //作用相同
int num = c1 - c2; //自动拆箱，转换成int数运算
return num == 0 ? 1 : num;
}
});
//4.遍历字符数组，将每一个字符存储在TreeSet集合中。
for(char c : arr) {
ts.add(c); //自动装箱
}
//5.遍历TreeSet集合，打印每一个字符。
for(Character c : ts) {
System.out.print(c);
}
}
}
Character重写了compareTo()：
public int compareTo(character anotherCharacter) 根据数字比较两个 Character对象。所以直接TreeSet存储char字符元素，重复也会直接被干掉，所以只能写一个比较器。八种数据类型包装类都实现了Comparable并重写了comparet()。
11、练习：程序启动后，可以从键盘输入接收多个整数，直到输入quit时结束输入。把所有输入的整数倒序排列打印。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/**
* 练习：程序启动后，可以从键盘输入接收多个整数，直到输入quit时结束输入。把所有输入的整数倒序排列打印。
* 分析：
* 1.创建Scanner对象，键盘录入。
* 2.创建TreeSet集合对象，TreeSet集合中传入比较器。
* 3.无限循环不断接收整数，遇到quit退出。因为退出时quit，所以键盘录入的时候应该都以字符串的形式录入。
* 4.判断是quit就退出，不是就将其转换为Integer，并添加到集合中。
* 5.遍历TreeSet集合并打印每一个元素。
*/
public class Test9 {
public static void main(String[] args) {
//1.创建Scanner对象，键盘录入。
Scanner sc = new Scanner(System.in);
System.out.println("请输入多个整数:");
//2.创建TreeSet集合对象，TreeSet集合中传入比较器。
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
// int num = i2 - i1; //自动拆箱，倒序排列。
int num = i2.compareTo(i1);
return num == 0 ? 1 : num;
}
});
//3.无限循环不断接收整数，遇到quit退出。因为退出时quit，所以键盘录入的时候应该都以字符串的形式录入。
while(true) {
String line = sc.nextLine(); //将键盘录入的字符串存储在line中 。
//4.判断是quit就退出，不是就将其转换为Integer，并添加到集合中。
if("quit".equals(line)) {
break;
}
try {
Integer i = Integer.parseInt(line); //将数字字符串转换成数字c，自动装箱。
ts.add(i);
} catch (Exception e) {
System.out.println("您录入的数据有误,请输入一个整数:");
}
}
//5.遍历TreeSet集合并打印每一个元素。
for (Integer integer : ts) {
System.out.println(integer);
}
}
}12、案例演示：键盘录入学生信息按照总分排序后输出在控制台。
需求：键盘录入5个学生信息(姓名，语文成绩，数学成绩，英语成绩)，按照总分从高到低输出到控制台。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
import com.bean.Student;
/**
* 需求：键盘录入5个学生信息(姓名，语文成绩，数学成绩，英语成绩)，按照总分从高到低输出到控制台。
* 分析：
* 1.定义一个学生类。
* 成员变量：姓名，语文成绩，数学成绩，英语成绩，总成绩。
* 成员方法：空参、有参构造，有参构造的参数分别是姓名，语文成绩，数学成绩，英语成绩。toString()，在遍历集合中的Student对象、打印对象引用的时候显示属性值。
* 2.键盘录入Scanner，创建键盘录入对象。
* 3.创建TreeSet集合对象，在TreeSet的构造函数中传入比较器，按照总分比较。
* 4.录入五个学生，并以集合中的学生个数为判断条件，如果size小于五就进行存储。
* 5.将录入的字符串用逗号切割，会返回一个字符串数组，将字符串数组中的元素从第二个元素开始转换成int数。
* 6.将转换后的节后封装成Student对象，将Student对象添加到TreeSet集合中。
* 7.遍历TreeSet集合，打印每一个Student对象。
*/
public class Test10 {
public static void main(String[] args) {
//2.键盘录入Scanner，创建键盘录入对象。
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生成绩：（格式：姓名，语文成绩，数学成绩，英语成绩）");
//3.创建TreeSet集合对象，在TreeSet的构造函数中传入比较器，按照总分比较。
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
public int compare(Student s1, Student s2) {
int num = s2.getSum() - s1.getSum();
return num == 0 ? 1 : num;
}
});
//4.录入五个学生，并以集合中的学生个数为判断条件，如果size小于五就进行存储。
while(ts.size() < 5) {
//5.将录入的字符串用逗号切割，会返回一个字符串数组，将字符串数组中的元素从第二个元素开始转换成int数。
String line = sc.nextLine();
try {
String[] arr = line.split(",");
int chinese = Integer.parseInt(arr[1]); //转换语文成绩
int math = Integer.parseInt(arr[2]); //转换数学成绩
int english = Integer.parseInt(arr[3]); //转换英语成绩
//6.将转换后的节后封装成Student对象，将Student对象添加到TreeSet集合中。
ts.add(new Student(arr[0], chinese, math, english));
} catch (Exception e) {
System.out.println("录入格式有误,输入5个学生成绩格式是:(姓名,语文成绩,数学成绩,英语成绩");
}
}
//7.遍历TreeSet集合，打印每一个Student对象。
System.out.println("排序后的学生信息：");
for (Student s : ts) {
System.out.println(s);
}
}
}自定义类：
public class Student {
private String name;
private int chinese;
private int math;
private int english;
private int sum;
public Student() {
super();
}
public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
this.sum = this.chinese + this.math + this.english;
}
public int getSum() {
return sum;
}
public String toString() {
return name + "," + chinese + "," + math + "," + english + "," + sum;
}
}
List和Set迭代方式的区别：
1、List（4种迭代方式）
普通for循环, 使用get()逐个获取。
调用iterator()方法得到Iterator, 使用hasNext()和next()方法。
增强for循环, 只要可以使用Iterator的类都可以用。
Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法。
2、Set
a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法。
b.增强for循环, 只要可以使用Iterator的类都可以用。
3、总结：
只要能用迭代器迭代的，都能用增强for循环遍历。