1.Set集合概述和特点

Set集合特点

  • 不包含重复元素的集合
  • 没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习

  • 存储字符串并遍历
  1. package com.study_01;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. public class SetDemo {
  7.     public static void main(String[] args) {
  8.         // 创建集合对象
  9.         Set<String> set = new HashSet<String>();
  11.         set.add("hello");
  12.         set.add("world");
  13.         set.add("java");
  14.         // 不包含重复的元素
  15.         set.add("hello");
  17.         // 遍历
  18.         for (String s : set) {
  19.             System.out.println(s);
  20.         }
  21.     }
  22. }

2.哈希值

哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

  • public int hashCode():返回对象的哈希码值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
  1. package com.study_02;
  3. public class HashDemo {
  4.     public static void main(String[] args) {
  5.         // 创建学生对象
  6.         Student s1 = new Student("小黑", 36);
  8.         // 同一个对象多次调用 hashCode()方法返回的哈希值是相同的
  9.         System.out.println(s1.hashCode());// 2083562754
  10.         System.out.println(s1.hashCode());// 2083562754
  11.         System.out.println("-----");
  13.         Student s2 = new Student("小黑", 36);
  14.         // 默认情况下，不同对象的哈希值是不相同的
  15.         // 通过方法重写可以实现不同对象的哈希值是相同的
  16.         System.out.println(s2.hashCode());// 557041912
  17.         System.out.println("-----");
  19.         System.out.println("hello".hashCode());
  20.         System.out.println("world".hashCode());
  21.         System.out.println("java".hashCode());
  23.         System.out.println("hello".hashCode());
  24.         System.out.println("-----");
  26.         System.out.println("重地".hashCode());// 1179395
  27.         System.out.println("通话".hashCode());// 1179395
  28.         System.out.println("你好".hashCode());// 652829
  30.     }
  31. }
  1. package com.study_02;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  12.     public Student() {
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public int hashCode() {
  33.         return super.hashCode();
  34.     }
  35. }

3.HashSet的概述和特点

HashSet集合特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普遍for循环
  • 由于是Set集合，所以是不包含重复元素的集合

HashSet集合练习

  • 存储字符串并遍历
  1.     package com.study_03;
  3.     import java.util.HashSet;
  5.     public class HashSetDemo {
  6.         public static void main(String[] args) {
  7.             // 创建集合对象
  8.             HashSet<String> hs = new HashSet<>();
  10.             // 添加元素
  11.             hs.add("hello");
  12.             hs.add("world");
  13.             hs.add("java");
  15.             hs.add("world");
  16.             // 遍历
  17.             for(String s : hs) {
  18.                 System.out.println(s);
  19.             }
  20.         }
  21.     }

4.HashSet集合保证元素唯一性源码分析

HashSet集合添加一个元素的过程

Set - 图1

HashSet集合存储元素:

  • 要保证元素唯一性，需要重写hashCode()和equals()

默认初始长度为16

  1. package com.study_03;
  3. import java.util.HashSet;
  5. public class HashSetDemo02 {
  6.     public static void main(String[] args) {
  7.         //创建HashSet集合对象
  8.         HashSet<Student> hs = new HashSet<>();
  10.         // 创建学生对象
  11.         Student s1 = new Student("林青霞",30);
  12.         Student s2 = new Student("张曼玉",35);
  13.         Student s3 = new Student("王祖贤",31);
  15.         Student s4 = new Student("王祖贤",31);
  17.         // 把学生添加到集合
  18.         hs.add(s1);
  19.         hs.add(s2);
  20.         hs.add(s3);
  21.         hs.add(s4);
  23.         // 遍历集合,增强for
  24.         for(Student s : hs) {
  25.             System.out.println(s);
  26.         }
  27.     }
  28. }
  1. package com.study_03;
  3. import java.util.Objects;
  5. public class Student {
  6.     private String name;
  7.     private int age;
  9.     public Student(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  14.     public Student() {
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  33.     @Override
  34.     public boolean equals(Object o) {
  35.         if (this == o) return true;
  36.         if (o == null || getClass() != o.getClass()) return false;
  37.         Student student = (Student) o;
  38.         return age == student.age && Objects.equals(name, student.name);
  39.     }
  41.     @Override
  42.     public int hashCode() {
  43.         return Objects.hash(name, age);
  44.     }
  46.     @Override
  47.     public String toString() {
  48.         return "Student{" +
  49.                 "name='" + name + '\'' +
  50.                 ", age=" + age +
  51.                 '}';
  52.     }
  53. }

5.常见数据结构之哈希表

哈希表

  • JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
  • JDK8以后，在长度比较长的时候，底层实现了优化

Set - 图2

6.学生案例

创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合要求:学生对象的成员变量值相同，我们就认为是

同一个对象

在学生类中重写两个方法hashCode()和equals)，自动生成即可

7.LinkedHashSet集合的概述和特点

LinkedHashSet集合特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代次序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是没有重复的元素

LinkedHashSet集合练习

  • 存储字符串并遍历
  1. package com.study_04;
  3. import java.util.LinkedHashSet;
  5. public class LinkedHashSetDemo {
  6.     public static void main(String[] args) {
  7.         // 创建集合对象
  8.         LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
  10.         // 添加元素
  11.         linkedHashSet.add("hello");
  12.         linkedHashSet.add("world");
  13.         linkedHashSet.add("java");
  15.         linkedHashSet.add("world");
  17.         // 遍历集合
  18.         for (String s : linkedHashSet) {
  19.             System.out.println(s);
  20.         }
  21.     }
  22. }

8.TreeSet集合概述和特点

间接的实现了Set接口

TreeSet集合特点

  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
    • TreeSet():根据其元素的自然排序进行排序
    • TreeSet(Comparator comparator):根据指定的比较器进行排序
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以不包含重复元素的集合

TreeSet集合练习

  • 存储整数并遍历
  1. package com.study_05;
  3. import java.util.TreeSet;
  5. public class TreeSetDemo01 {
  6.     public static void main(String[] args) {
  7.         // 创建集合对象
  8.         TreeSet<Integer> ts = new TreeSet<>();
  10.         // 添加元素
  11.         ts.add(10);
  12.         ts.add(30);
  13.         ts.add(50);
  14.         ts.add(20);
  16.         ts.add(30);
  18.         // 遍历集合
  19.         for (Integer i : ts) {
  20.             System.out.println(i);
  21.         }
  22.     }
  23. }

9.自然排序Comparable

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论

  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
  1. @Override
  2. public int compareTo(Student s) {
  3.     //        return 1;
  4.     //        return 0;
  5.     //        return -1;
  6.     // 按照年龄从小到大排序
  7.     int num = this.age - s.age;
  8.     //        int num = s.age - this.age;
  9.     // 年龄相同时,按照姓名字母顺序排序
  10.     int num2 = num == 0 ? this.name.compareTo(s.name):num;
  11.     return  num2;
  12. }
  1. package com.study_05;
  3. import java.util.TreeSet;
  5. public class TreeSetDemo02 {
  6.     public static void main(String[] args) {
  7.         // 创建集合对象
  8.         TreeSet<Student> ts = new TreeSet<>();
  10.         // 创建学生对象
  11.         Student s1 = new Student("林青霞",30);
  12.         Student s2 = new Student("张曼玉",35);
  13.         Student s3 = new Student("王祖贤",31);
  15.         Student s4 = new Student("xiaoli",31);
  16.         Student s5 = new Student("xiaoli",31);
  18.         // 添加到集合
  19.         ts.add(s1);
  20.         ts.add(s2);
  21.         ts.add(s3);
  22.         ts.add(s4);
  23.         ts.add(s5);
  25.         // 遍历集合
  26.         for (Student s : ts) {
  27.             System.out.println(s);
  28.         }
  29.     }
  30. }
  1. package com.study_05;
  3. import java.util.Objects;
  5. public class Student implements Comparable<Student>{
  6.     private String name;
  7.     private int age;
  9.     public Student(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  14.     public Student() {
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  33.     @Override
  34.     public int compareTo(Student s) {
  35. //        return 1;
  36. //        return 0;
  37. //        return -1;
  38.         // 按照年龄从小到大排序
  39.         int num = this.age - s.age;
  40. //        int num = s.age - this.age;
  41.         // 年龄相同时,按照姓名字母顺序排序
  42.         int num2 = num == 0 ? this.name.compareTo(s.name):num;
  43.         return  num2;
  44.     }
  46.     @Override
  47.     public String toString() {
  48.         return "Student{" +
  49.                 "name='" + name + '\'' +
  50.                 ", age=" + age +
  51.                 '}';
  52.     }
  53. }

10.比较器排序Comparator的使用

  • 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
  • 要求:按照年龄从小到大排序，年龄相同时，按照暇姓名的字母顺序排序

结论

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
  • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
  1. // 创建集合对象
  2. TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
  3.     @Override
  4.     public int compare(Student s1, Student s2) {
  5.         // this.age  -  s.age
  6.         // s1,s2
  7.         int num = s1.getAge() - s2.getAge();
  8.         int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
  9.         return num2;
  10.     }
  11. });
  1. package com.study_06;
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  6. public class TreeSetDemo01 {
  7.     public static void main(String[] args) {
  8.         // 创建集合对象
  9.         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
  10.             @Override
  11.             public int compare(Student s1, Student s2) {
  12.                 // this.age  -  s.age
  13.                 // s1,s2
  14.                 int num = s1.getAge() - s2.getAge();
  15.                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
  16.                 return num2;
  17.             }
  18.         });
  20.         // 创建学生对象
  21.         Student s1 = new Student("林青霞", 30);
  22.         Student s2 = new Student("张曼玉", 35);
  23.         Student s3 = new Student("王祖贤", 31);
  25.         Student s4 = new Student("xiaoli", 31);
  26.         Student s5 = new Student("xiaoli", 31);
  28.         ts.add(s1);
  29.         ts.add(s2);
  30.         ts.add(s3);
  31.         ts.add(s4);
  32.         ts.add(s5);
  34.         for (Student s : ts) {
  35.             System.out.println(s);
  36.         }
  37.     }
  38. }
  1. package com.study_06;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  12.     public Student() {
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  32.     @Override
  33.     public String toString() {
  34.         return "Student{" +
  35.                 "name='" + name + '\'' +
  36.                 ", age=" + age +
  37.                 '}';
  38.     }
  39. }

11.Set案例

成绩排序:

需求:用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合

要求:按照总分从高到低出现

  1. package com.study_07;
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  6. public class TreeSetDemo01 {
  7.     public static void main(String[] args) {
  8.         // 创建TreeSet集合对象通过比较器进行排序
  9.         TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
  10.             @Override
  11.             public int compare(Student s1, Student s2) {
  12.                 int num = s1.getSum() - s2.getSum();
  13.                 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
  14.                 int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
  15.                 return num3;
  16.             }
  17.         });
  19.         // 创建学生对象
  20.         Student s1 = new Student("林青霞", 98, 100);
  21.         Student s2 = new Student("张曼玉", 95, 95);
  22.         Student s3 = new Student("王祖贤", 100, 93);
  23.         Student s4 = new Student("柳岩", 100, 97);
  24.         Student s5 = new Student("风清扬", 98, 98);
  26.         Student s6 = new Student("左冷禅", 97, 99);
  28. //        Student s7 = new Student("左冷禅",97,99);
  29.         Student s7 = new Student("赵云", 97, 99);
  31.         ts.add(s1);
  32.         ts.add(s2);
  33.         ts.add(s3);
  34.         ts.add(s4);
  35.         ts.add(s5);
  36.         ts.add(s6);
  37.         ts.add(s7);
  39.         for (Student s : ts) {
  40.             System.out.println(s);
  41.         }
  42.     }
  43. }
  1. package com.study_07;
  3. public class Student {
  4.     private String name;
  5.     private int chinese;
  6.     private int math;
  8.     public Student(String name, int chinese, int math) {
  9.         this.name = name;
  10.         this.chinese = chinese;
  11.         this.math = math;
  12.     }
  14.     public Student() {
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getChinese() {
  26.         return chinese;
  27.     }
  29.     public void setChinese(int chinese) {
  30.         this.chinese = chinese;
  31.     }
  33.     public int getMath() {
  34.         return math;
  35.     }
  37.     public void setMath(int math) {
  38.         this.math = math;
  39.     }
  41.     public int getSum() {
  42.         return  this.chinese+this.math;
  43.     }
  45.     @Override
  46.     public String toString() {
  47.         return "Student{" +
  48.                 "name='" + name + '\'' +
  49.                 ", chinese=" + chinese +
  50.                 ", math=" + math +
  51.                 ", sum=" + this.getSum() +
  52.                 '}';
  53.     }
  54. }

12.不重复的随机数案例

案例:不重复的随机数
需求:编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

  1. package com.study_08;
  3. import java.util.HashSet;
  4. import java.util.Random;
  5. import java.util.Set;
  6. import java.util.TreeSet;
  8. public class SetDemo {
  9.     public static void main(String[] args) {
  10.         // 创建Set集合对象
  11. //        Set<Integer> set = new HashSet<Integer>();
  12.         Set<Integer> set = new TreeSet<Integer>(); // 有序的
  14.         // 创建随机数对象
  15.         Random r = new Random();
  17.         // 判断集合承兑是不是小于0
  18.         while (set.size() < 10) {
  19.             /*
  20.             * 返回伪随机数，从0（包括）和指定值（排除）之间均匀分布的int值，从该随机数生成器的序列中抽取出来。
  21.             * nextInt的一般合同是指定范围内的一个int值被伪随机生成并返回
  22.             * */
  23.             int number = r.nextInt(20) + 1;
  24.             set.add(number);
  25.         }
  27.         // 遍历集合
  28.         for(Integer i : set) {
  29.             System.out.println(i);
  30.         }
  31.     }
  32. }