1 package cn.temptation; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 public class Sample01 { 7 public static void main(String[] args) { 8 /* 9 * 接口 Set ：一个不包含重复元素的 collection。10 * 11 * 特点：12 * 1、无序：指的是Set显示其元素的顺序 与 放入元素的顺序可能不一致13 * 2、唯一：放入其中的元素是唯一的14 */15 16 Set set = new HashSet<>();17 18 set.add("China");19 set.add("USA");20 set.add("Japan");21 set.add("China");22 23 System.out.println("set:" + set); // set:[USA, China, Japan]24 25 // 通过查看源码，发现会使用到元素的hashCode，hashCode相同的字符串添加时不重复添加26 System.out.println("China".hashCode()); // 6507858327 System.out.println("USA".hashCode()); // 8432328 System.out.println("Japan".hashCode()); // 7134103029 System.out.println((new String("China")).hashCode()); // 6507858330 }31 }32 // 查看HashSet类的源码33 //public boolean add(E e) {34 // return map.put(e, PRESENT)==null;35 //}36 37 //private transient HashMap map;38 39 // 查看HashMap类的源码40 //public V put(K key, V value) {41 // return putVal(hash(key), key, value, false, true);42 //} 1 package cn.temptation; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 public class Sample02 { 7 public static void main(String[] args) { 8 // 类 HashSet ：此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。 9 // 它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。10 11 Set set = new HashSet<>();12 13 set.add(new Student("张三", 18));14 set.add(new Student("李四", 20));15 set.add(new Student("王五", 22));16 set.add(new Student("张三", 18));17 18 // 分析：观察一下创建相同姓名、相同年龄的学生对象，它们的hashCode是否一致19 // 原因在于因为Student类的对象没有重写hashCode方法和equals方法，默认使用Object类的hashCode方法和equals方法20 21 System.out.println((new Student("张三", 18)).hashCode()); // 未重写时的值：118352462 重写后的值：77640822 System.out.println((new Student("张三", 18)).hashCode()); // 未重写时的值：1550089733 重写后的值：77640823 24 System.out.println("set:" + set);25 }26 } 1 package cn.temptation; 2 3 import java.util.LinkedHashSet; 4 import java.util.Set; 5 6 public class Sample03 { 7 public static void main(String[] args) { 8 /* 9 * 类 LinkedHashSet ：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。10 * 11 * 特点：有序唯一12 * 1、唯一：通过哈希表来保证唯一13 * 2、有序：通过链表来保证元素的有序14 */15 Set set = new LinkedHashSet<>();16 17 set.add("China");18 set.add("USA");19 set.add("Japan");20 set.add("China");21 set.add("France");22 set.add("England");23 24 System.out.println("set:" + set);25 }26 } 1 package cn.temptation; 2 3 import java.util.Set; 4 import java.util.TreeSet; 5 6 public class Sample04 { 7 public static void main(String[] args) { 8 /* 9 * 类 TreeSet ：10 * 基于 TreeMap 的 NavigableSet 实现。11 * 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 12 * 13 * 能够对其中的元素按照某种规则进行排序14 * 15 * 某种规则：16 * 1、可以按照自然顺序规则17 * 2、可以按照自定义排序规则18 */19 20 // 1、自然排序规则21 Set set1 = new TreeSet<>();22 23 set1.add(1);24 set1.add(3);25 set1.add(2);26 set1.add(4);27 28 System.out.println("treeset:" + set1); // treeset:[1, 2, 3, 4]29 30 System.out.println("-------------------------------------------");31 32 Set set2 = new TreeSet<>();33 34 set2.add('j');35 set2.add('A');36 set2.add('v');37 set2.add('a');38 set2.add('G');39 set2.add('O');40 set2.add('o');41 set2.add('D');42 43 System.out.println("treeset:" + set2); // treeset:[A, D, G, O, a, j, o, v]44 45 System.out.println("-------------------------------------------");46 47 Set set3 = new TreeSet<>();48 49 set3.add("USA");50 set3.add("China");51 set3.add("Japan");52 set3.add("Chile");53 54 System.out.println("treeset:" + set3); // treeset:[Chile, China, Japan, USA]55 56 System.out.println("-------------------------------------------");57 58 Set set4 = new TreeSet<>();59 60 set4.add("张三");61 set4.add("李四");62 set4.add("王五");63 set4.add("张飞");64 65 System.out.println("treeset:" + set4); // treeset:[张三, 张飞, 李四, 王五] 显然不是根据拼音的顺序66 67 System.out.println((int)'张' + " VS " + (int)'李' + " VS " + (int)'王'); // 24352 VS 26446 VS 2957968 System.out.println((int)'三' + " VS " + (int)'飞'); // 19977 VS 3913469 }70 } 1 package cn.temptation; 2 3 import java.util.Set; 4 import java.util.TreeSet; 5 6 public class Sample05 { 7 public static void main(String[] args) { 8 // 可以按照自定义排序规则 9 10 // 思路：11 // 考虑到Set容器中的元素是无序且唯一的，要让他们可以有顺序，其实就是让它们具备可比较的能力，即实现Comparable 接口12 13 /*14 * 接口 Comparable ：此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。15 * 16 * Comparable 接口的常用成员方法：17 * int compareTo(T o) ：比较此对象与指定对象的顺序。 18 */19 20 Set set = new TreeSet<>();21 22 // 执行异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.Comparable23 set.add(new Student("张三", 20));24 set.add(new Student("李四", 18));25 set.add(new Student("王五", 22));26 set.add(new Student("张飞", 20));27 28 for (Student item : set) {29 System.out.println(item);30 }31 }32 } 1 package cn.temptation; 2 3 import java.util.Comparator; 4 import java.util.Set; 5 import java.util.TreeSet; 6 7 public class Sample06 { 8 public static void main(String[] args) { 9 /*10 * 接口 Comparator ：11 * 强行对某个对象 collection 进行整体排序 的比较函数。12 * 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。13 * 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。14 */15 16 /*17 * TreeSet类的构造函数：18 * TreeSet(Comparator comparator) ：构造一个新的空 TreeSet，它根据指定比较器进行排序。19 */20 21 // 创建比较器对象22 Comparator comparator = new StudentCompartor();23 24 Set set = new TreeSet<>(comparator);25 26 set.add(new Student("张三", 20));27 set.add(new Student("李四", 18));28 set.add(new Student("王五", 22));29 set.add(new Student("张飞", 20));30 31 for (Student item : set) {32 System.out.println(item);33 }34 }35 } 1 package cn.temptation; 2 3 import java.util.Comparator; 4 import java.util.Set; 5 import java.util.TreeSet; 6 7 public class Sample07 { 8 public static void main(String[] args) { 9 // 观察到TreeSet类的构造函数TreeSet(Comparator comparator) ：构造一个新的空 TreeSet，它根据指定比较器进行排序。10 // 传入的是一个接口，所以考虑使用匿名内部类11 // 匿名内部类写法的优点：使用了匿名内部类，就不用再制作实现Comparator接口的实现类了12 13 Set set = new TreeSet<>(new Comparator () {14 @Override15 public int compare(Student student1, Student student2) {16 // 首先按年龄的自然顺序17 int resultAge = student1.getAge() - student2.getAge();18 19 /* 20 * 其次按姓名的自然顺序21 * 字符串的比较时，考虑使用String类的compareTo方法22 * String类的常用成员方法：23 * int compareTo(String anotherString) :按字典顺序比较两个字符串。 24 */25 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;26 27 return result;28 }29 });30 31 set.add(new Student("张三", 20));32 set.add(new Student("李四", 18));33 set.add(new Student("王五", 22));34 set.add(new Student("张飞", 20));35 36 for (Student item : set) {37 System.out.println(item);38 }39 }40 } 1 package cn.temptation; 2 3 import java.util.Set; 4 import java.util.TreeSet; 5 6 public class Sample08 { 7 public static void main(String[] args) { 8 Set set = new TreeSet<>(); 9 10 set.add(1);11 set.add(5);12 set.add(4);13 set.add(2);14 set.add(3);15 16 for (Integer item : set) {17 System.out.println(item);18 }19 }20 }21 // 【TreeSet存储规则】22 // 第一个元素存储时，直接作为根节点存储23 // 从第二个元素开始，每个元素存储时从根节点开始比较24 // 如果比根节点大，就作为根节点的右侧25 // 如果比根节点小，就作为根节点的左侧26 // 如果相等，就无视27 // 【TreeSet取出规则】28 // 取出时，根据（前序遍历、中序遍历、后序遍历）29 // 从根节点开始，按照左、中、右的原则依次取出元素30 31 // 查看TreeSet类的源码32 //public boolean add(E e) {33 // return m.put(e, PRESENT)==null;34 //}35 36 //private transient NavigableMap m;37 38 //查看TreeMap类的源码39 //public V put(K key, V value) {40 // Entry t = root;41 // if (t == null) {42 // compare(key, key); // type (and possibly null) check43 //44 // root = new Entry<>(key, value, null);45 // size = 1;46 // modCount++;47 // return null;48 // }49 // int cmp;50 // Entry parent;51 // // split comparator and comparable paths52 // Comparator cpr = comparator;53 // if (cpr != null) {54 // do {55 // parent = t;56 // cmp = cpr.compare(key, t.key);57 // if (cmp < 0)58 // t = t.left;59 // else if (cmp > 0)60 // t = t.right;61 // else62 // return t.setValue(value);63 // } while (t != null);64 // }65 // else {66 // if (key == null)67 // throw new NullPointerException();68 // @SuppressWarnings("unchecked")69 // Comparable k = (Comparable ) key;70 // do {71 // parent = t;72 // cmp = k.compareTo(t.key);73 // if (cmp < 0)74 // t = t.left;75 // else if (cmp > 0)76 // t = t.right;77 // else78 // return t.setValue(value);79 // } while (t != null);80 // }81 // Entry e = new Entry<>(key, value, parent);82 // if (cmp < 0)83 // parent.left = e;84 // else85 // parent.right = e;86 // fixAfterInsertion(e);87 // size++;88 // modCount++;89 // return null;90 //} 1 package cn.temptation; 2 3 // 注意：只定义Student类，放入到TreeSet集合中会产生执行异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.Comparable 4 //public class Student { 5 public class Student implements Comparable { 6 // 成员变量 7 private String name; 8 private int age; 9 10 // 构造函数11 public Student() {12 super();13 }14 15 public Student(String name, int age) {16 super();17 this.name = name;18 this.age = age;19 }20 21 // 成员方法22 public String getName() {23 return name;24 }25 26 public void setName(String name) {27 this.name = name;28 }29 30 public int getAge() {31 return age;32 }33 34 public void setAge(int age) {35 this.age = age;36 }37 38 // 为了去除重复内容的对象，需要重写hashCode方法和equals方法39 @Override40 public int hashCode() {41 final int prime = 31;42 int result = 1;43 result = prime * result + age;44 result = prime * result + ((name == null) ? 0 : name.hashCode());45 return result;46 }47 48 @Override49 public boolean equals(Object obj) {50 if (this == obj)51 return true;52 if (obj == null)53 return false;54 if (getClass() != obj.getClass())55 return false;56 Student other = (Student) obj;57 if (age != other.age)58 return false;59 if (name == null) {60 if (other.name != null)61 return false;62 } else if (!name.equals(other.name))63 return false;64 return true;65 }66 67 @Override68 public String toString() {69 return "学生 [姓名为：" + name + ", 年龄为：" + age + "]";70 }71 72 // 需要重写compareTo方法进行比较73 // 制定比较的规则：先比较年龄的大小，年龄相同时比较姓名的顺序74 @Override75 public int compareTo(Student anotherStudent) {76 // 首先按年龄的自然顺序77 int resultAge = this.age - anotherStudent.age;78 79 /* 80 * 其次按姓名的自然顺序81 * 字符串的比较时，考虑使用String类的compareTo方法82 * String类的常用成员方法：83 * int compareTo(String anotherString) :按字典顺序比较两个字符串。 84 */85 int result = (resultAge == 0) ? this.name.compareTo(anotherStudent.name) : resultAge;86 87 return result;88 }89 } 1 package cn.temptation; 2 3 import java.util.Comparator; 4 5 /** 6 * 实现比较器的类 7 * 这里没有在Student类上直接实现Comparator 接口，是因为Comparator 接口的compare方法比较的是两个对象 8 * 9 * Comparator 接口的常用成员方法：10 * 1、int compare(T o1, T o2) ：比较用来排序的两个参数。 11 * 2、boolean equals(Object obj) ：指示某个其他对象是否“等于”此 Comparator。12 * 13 * 注意：因为Object基类就有equals方法，所以不显式进行重写，就是使用Object基类的equals方法，不会提示语法出错14 */15 public class StudentCompartor implements Comparator {16 /*17 * 重写进行比较的方法18 * 制定比较的规则：先比较年龄的大小，年龄相同时比较姓名的顺序19 */20 @Override21 public int compare(Student student1, Student student2) {22 // 首先按年龄的自然顺序23 int resultAge = student1.getAge() - student2.getAge();24 25 /* 26 * 其次按姓名的自然顺序27 * 字符串的比较时，考虑使用String类的compareTo方法28 * String类的常用成员方法：29 * int compareTo(String anotherString) :按字典顺序比较两个字符串。 30 */31 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;32 33 return result;34 }35 }