java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致),java.util.HashSet底层的实现其实是一个java.util.HashMap支持
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
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 */ } }测试：
public class HashCodeDemo { public static void main(String[] args) { //同一个对象的哈希值是固定的 System.out.println("zhangsan".hashCode());//-1432604556 System.out.println("zhangsan".hashCode());//-1432604556 System.out.println("lisi".hashCode());//3322003 //默认情况下不同对象的哈希值是不同的 //而重写hashcode方法可以让不同对象的哈希值相同 //String重写了hashcode()方法 System.out.println("重地".hashCode());//1179395 System.out.println("通话".hashCode());//1179395 } }什么是哈希表呢？
在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。
看到这张图就有人要问了，这个是怎么存储的呢？为了方便大家的理解我们结合一个存储流程图来说明一下：
总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。
范例：
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public 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); } @Override public int hashCode() { return Objects.hash(name, age); } } public class HashSetDemo2 { public static void main(String[] args) { //创建集合对象 该集合中存储 Student类型对象 HashSet<Student> stuSet = new HashSet<Student>(); //存储 Student stu = new Student("于谦", 43); stuSet.add(stu); stuSet.add(new Student("郭德纲", 44)); stuSet.add(new Student("于谦", 43)); stuSet.add(new Student("郭麒麟", 23)); stuSet.add(stu); //重写toString方法后 for (Student stu2 : stuSet) { System.out.println(stu2); } } } /* 输出： Student{name='郭德纲', age=44} Student{name='于谦', age=43} Student{name='郭麒麟', age=23} */我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。
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()); } /* bbb aaa abc bbc * */ } }Treeset的底层实现是二叉树，可以进行默认排序，也可以自定义排序。自定义排序的时候有两种方式，1实现 Comparable 接口完成排序（重写compareTo()方法），2是实现 Comparator 接口完成排序(重写compare()方法)。
下面是使用TreeSet存储学生对象并按照要求排序的案例，分别通过自然排序和比较器排序的方法实现，二者功能相同。
案例：
public class Student implements Comparable<Student>{ private String name; private int age; public Student(){} public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } @Override public int compareTo(Student o) { // return 0; // return 1; // return -1; //按照年龄升序排序 int num=this.age-o.age; //降序 // int num=o.age-this.age; //年龄相同比较name，按字母顺序排序（String实现了compareTo()方法） int num2 = num==0 ? this.name.compareTo(o.name):num; return num2; } } public class ComparableTest { public static void main(String[] args) { TreeSet<Student> ts=new TreeSet<>(); ts.add(new Student("zhangsan",30)); ts.add(new Student("lisi",25)); ts.add(new Student("wangwu",28)); ts.add(new Student("zhaoliu",40)); ts.add(new Student("haoli",40)); for (Student s:ts) System.out.println(s.getName()+","+s.getAge()); // 不实现Comparable接口报错：Student cannot be cast to java.lang.Comparable // 实现后 // lisi,25 // wangwu,28 // zhangsan,30 // haoli,40 // zhaoliu,40 } }总结：
案例：
public class Student { private String name; private int age; public Student(){} public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } } public class ComparatorTest { public static void main(String[] args) { TreeSet<Student> ts=new TreeSet<>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { //this.age - s.age //s1,s2 int num = s1.getAge() -s2.getAge(); int num2 = num==0?s1.getName().compareTo(s2.getName()):num; return num2; } }); ts.add(new Student("zhangsan",30)); ts.add(new Student("lisi",25)); ts.add(new Student("wangwu",28)); ts.add(new Student("zhaoliu",40)); ts.add(new Student("haoli",40)); for (Student s:ts) System.out.println(s.getName()+","+s.getAge()); } }总结：
java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。public static void shuffle(List<?> list):打乱集合顺序。public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。 public class test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); // //原来写法 // list.add(10); // list.add(30); // list.add(20); //采用工具类添加元素 Collections.addAll(list,20,5,90,40);//[20, 5, 90, 40] Collections.sort(list);//[5, 20, 40, 90] // Collections.shuffle(list);//随机洗牌 System.out.println(list); } }代码演示之后 ，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？
我们发现还有个方法没有讲，public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。
我们还是先研究这个方法
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public class CollectionsDemo2 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("cba"); list.add("aba"); list.add("sba"); list.add("nba"); //排序方法 Collections.sort(list); System.out.println(list);//[aba, cba, nba, sba] } }结果：[aba, cba, nba, sba]
我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？
说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成。
那么我们采用的public static <T> void sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用
public static <T> void sort(List<T> list，Comparator<? super T> )方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：
public int compare(String o1, String o2)：比较其两个参数的顺序。
两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
如果要按照降序排序 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
public class CollectionsDemo3 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("cba"); list.add("aba"); list.add("sba"); list.add("nba"); //排序方法 按照第一个单词的降序 Collections.sort(list, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o2.charAt(0) - o1.charAt(0); } }); System.out.println(list);//[sba, nba, cba, aba] } }【Java笔记】系列
集合（一）Collection接口、List接口及其实现类集合（二）Set接口及其实现类、Collections集合（三）Map接口及其实现类