目录
1.案例：
Set mys = new HashSet<>();
// 增加值
mys.add(true);
mys.add("哈哈");
mys.add('a');
mys.add(1);
// 循环取值
for (Object object : mys) {
System.out.println(object);
}输出结果：
可以看到内容是打乱输出的。所以，得出特点1：无序。
2.同样是上面的案例，只是往集合里面增加了一组重复值：mys.add("哈哈")
Set mys = new HashSet<>();
// 增加值
mys.add(true);
mys.add("哈哈");
mys.add('a');
mys.add(1);
mys.add("哈哈");
// 循环取值
for (Object object : mys) {
System.out.println(object);
}输出结果：
可以看到输出结果是4个，并没有输出重复值。所以，得出特点2：不能重复。
总结：
1.无序；
2.（对象）不能重复(eqauls)。
eqauls 从 Object 继承，默认比较的地址补充：和List集合的特点相反。
方式一：foreach
for (Object object : mys) {
System.out.println(object);
}方式二：迭代器 Iterator（官方推荐，安全可靠性更高）
Iterator it = mys.iterator();
while(it.hasNext()) {
Object next = it.next();
System.out.println(next);
}注意：不能使用for循环，Set不能单独取值，没有下标。
区别：
1.HashSet不可以排序。（但内部已经按照自己的规则排序好了：把所有值转换成Hash表内的Hash值）
2.TreeSet可以排序。（根据某种规则对里面的元素进行排序）
规则1: java.lang.Comparable (基础语言包)
规则2: java.util.Comparator (工具包)
补充：它们都是接口
1.Comparable：自然排序接口
2.Comparator：比较器接口
Comparable 和 Comparator 接口的存在就是为了对象比较和多个对象进行排序。
4.1.Comparable
该接口位于 java.lang 包下，接口中只有一个抽象方法 compareTo()。
案例：使用Comparable自然排序接口实现对象排序
首先写一个类，实现了 Comparable 接口，并在重写的 compareTo() 方法里面定义了排序规则。
/**
* 学生类
* @author wang'qing
*
*/
public class User implements Comparable<User> {
private int id;// 学号
private String name;// 姓名
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(User o) {
// 拿学生学号和学生对象学号进行排序
if(this.id < o.id){
return -1;
}else if(this.id == o.id){
return 0;
}else {
return 1;
}
}
}然后通过对对象、数组、集合进行排序。
Collections：工具类，提供一组静态方法操作 Collection 集合；
Arrays：工具类，提供了一组静态方法操作数组；
public static void main(String[] args) {
// 1.两个对象
User u1 = new User(1, "周婷");
User u2 = new User(2, "乐媛");
// 找出学号比较大的学生
if(u1.compareTo(u2) > 0) {
System.out.println(u1.id + "\t" + u1.name);
}else {
System.out.println(u2.id + "\t" + u2.name);
}
// 2.数组
// User[] user = new User[] {
// new User(1, "周婷"),
// new User(3, "乐媛"),
// new User(2, "金眉")
// };
//
// Arrays.sort(user);
// for (User u : user) {
// System.out.println(u);
// }
// 3.集合
// List<User> listUser = new ArrayList<User>();
//
// listUser.add(new User(1,"王晴"));
// listUser.add(new User(3,"金眉"));
// listUser.add(new User(4,"周婷"));
// listUser.add(new User(5,"乐媛"));
// listUser.add(new User(2,"王欣雨"));
//
// Collections.sort(listUser);
// for (User user : listUser) {
// System.out.println("学号：" + user.id + "\t" + "姓名：" + user.name);
// }
// System.out.println(listUser);
}4.2.Comparator
该接口位于 java.util 包下，如果我们想要使用这个接口，只需要实现一个抽象方法 compare 就可以了。
案例1：使用 Comparator 比较器接口实现比大小
比较原理：通过 HashCode() 返回整形字符，然后进行比较。
首先要有一个类，并实现 HashCode() 方法;
package com.zking.Test;
public class Student {
public Integer id;// 学号
public String name;// 姓名
publicInteger age;// 年龄
public Student() {
}
public Student(Integer id, String name, Integer age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public Student(Integer id) {
super();
this.id = id;
}
@Override
public int hashCode() {
return this.id.hashCode();
}
}继承 Comparator 接口，传两个学生对象进行比较（比较的前提是 Student 类必须有内置的HashCode() 方法）;
public class Test implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.hashCode() - o2.hashCode();
}
}因为我进行的是年龄的比大小，所以类里面的 HashCode() 方法只传入了年龄的参数，可以根据实际情况传入其他参数，比如要比较学号或姓名的大小。
public static void main(String[] args) {
Test t = new Test();
// 两个学生进行年龄的比大小
Student s1 = new Student(2);
Student s2 = new Student(1);
int compare = t.compare(s1, s2);
System.out.println(compare);
/**
* 输出结果：
* 如果s1大于s2，输出正数
* 如果s2大于s1，输出负数
* 如果两个值相等，输出0
*/
}案例2：Comparator对对象进行排序
同样写一个类；
public class Student {
public Integer id;// 学号
public String name;// 姓名
public Integer age;// 年龄
public Student() {
}
public Student(Integer id, String name, Integer age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public Student(Integer id) {
super();
this.id = id;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}重写 compare() 方法定义排序规则；
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
if(o1.id > o2.id)
return 1;
else if(o1.id == o2.id)
return 0;
else
return -1;
}
}通过对象和集合进行排序；
public static void main(String[] args) {
// 1.两个对象
// Student s1 = new Student(1, "啦啦", 20);
// Student s2 = new Student(2, "哗哗", 20);
//
// Test t = new Test();
//
// if(t.compare(s1, s2) > 0) {
// System.out.println("学号：" + s1.id + "\t姓名：" + s1.name + "\t年龄：" + s1.age);
// }else {
// System.out.println("学号：" + s2.id + "\t姓名：" + s2.name + "\t年龄：" + s2.age);
// }
// 2.集合
List<Student> listStudent = new ArrayList<>();
listStudent.add(new Student(2, "啦啦", 20));
listStudent.add(new Student(1, "哗哗", 30));
listStudent.add(new Student(4, "嘻嘻", 40));
listStudent.add(new Student(3, "哈哈", 50));
Collections.sort(listStudent, new Test());
for (Student s : listStudent) {
System.out.println(s);
}
}其他案例：使用 Arrays.sort() 实现冒泡排序
int[] a = {40,50,20,10,60,30};
Arrays.sort(a);
System.out.println(Arrays.toString(a));输出：
特点：
1.元素是有顺序的；
2.元素是不重复的；
3.底层数据结构是按照链表的结构存贮的 Linked 。
泛型主要是让我们类里面的数据类型更加的灵活，默认Object。语法：<>。
举例：List集合
List<E> myl = new ArrayList<E>();完。