• 43、集合的第一大类：Set

    一、基本介绍： 

    1、Set接口的特点：

    1）无序（添加和取出的顺序不一致） ，没有索引

    2）不允许重复元素，所以最多包含一个null

    3） JDK API中Set接口的实现类有：

     2、Set接口的常用方法：

    和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样.

    3、Set接口的遍历方式：

    同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。

    （1）可以使用迭代器

    （2）增强for

    （3）不能使用索引的方式来获取．

    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Iterator;
    5. import java.util.Set;
    6.  
    7. public class SetMethod {
    8.     @SuppressWarnings({"all"})
    9.     public static void main(String[] args) {
    10.         Set set=new HashSet();
    11.         set.add("john");
    12.         set.add("lucky");
    13.         set.add("john");
    14.         set.add("jack");
    15.         set.add(null);
    16.         set.add(null);
    17.         System.out.println("set="+set);
    18.         //set=[lucky, null, john, jack]
    19.         //取出的顺序是固定的，不会说同样的代码每次输出都不一样
    20.  
    21.         set.add("smith");
    22.         System.out.println("set="+set);
    23.         //set=[lucky, null, smith, john, jack]
    24.  
    25.         //遍历
    26.         //1、使用迭代器
    27.         System.out.println("=========使用迭代器=========");
    28.         Iterator iterator=set.iterator();
    29.         while (iterator.hasNext()) {
    30.             Object obj =  iterator.next();
    31.             System.out.println("obj="+obj);
    32.         }
    33.  
    34.         //2、增强for
    35.         System.out.println("=========增强for=========");
    36.         for (Object o :set) {
    37.             System.out.println("o="+o);
    38.         }
    39.  
    40.     }
    41. }
    42. //=========使用迭代器=========
    43. //obj=lucky
    44. //obj=null
    45. //obj=smith
    46. //obj=john
    47. //obj=jack
    48. //=========增强for=========
    49. //o=lucky
    50. //o=null
    51. //o=smith
    52. //o=john
    53. //o=jack

    4、Set接口常用的实现类：有HashSet、TreeSet.

    二、HashSet：

    1、基本介绍： 

    （1） HashSet实现了Set接口

    （2）HashSet底层实际上是HashMap， 看下源码．

    1. public HashSet(){
    2.         map = new HashMap<>();
    3. }

    （3） 可以存放null值，但是只能有一个null.

    （4）HashSet不保证元素是有序的，取决于hash后，再确定索引的结果．即，不保证存放元素的顺序和取出顺序一致

    （5） 不能有重复元素／对象．

    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5. @SuppressWarnings({"all"})
    6. public class HashSet_ {
    7.     public static void main(String[] args) {
    8.         Set hashSet = new HashSet();
    9.         hashSet.add(null);
    10.         hashSet.add(null);
    11.         System.out.println("hashset="+hashSet);
    12.         //hashset=[null]
    13.     }
    14. }
    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5. @SuppressWarnings({"all"})
    6. public class HashSet_ {
    7.     public static void main(String[] args) {
    8.         Set set=new HashSet();
    9.         set.add("john");
    10.         set.add("tom");
    11.  
    12.  
    13.         set =new HashSet();
    14.         System.out.println("set="+set);//set=[]
    15.         set.add("lucy");//ok
    16.         set.add("lucy");//no
    17.         set.add(new Dog("tom"));//ok
    18.         set.add(new Dog("tom"));//ok 不同对象
    19.         System.out.println("set="+set);
    20.         //set=[Dog{name='tom'}, Dog{name='tom'}, lucy]
    21.  
    22.         //经典面试题
    23.         set.add(new String("hsp"));//ok
    24.         set.add(new String("hsp"));//加入不了 看源码
    25.         System.out.println("set="+set);
    26.         //set=[Dog{name='tom'}, hsp, Dog{name='tom'}, lucy]
    27.     }
    28. }
    29. class Dog{
    30.     private String name;
    31.  
    32.     public Dog(String name) {
    33.         this.name = name;
    34.     }
    35.  
    36.     @Override
    37.     public String toString() {
    38.         return "Dog{" +
    39.                 "name='" + name + '\'' +
    40.                 '}';
    41.     }
    42. }

     2、HashSet底层机制说明：（主要研究源码）

    HashSet底层是HashMap，HashMap底层是（数组＋链表＋红黑树）

    1. package Collection_;
    2. @SuppressWarnings({"all"})
    3. public class HashSetStructure {
    4.     public static void main(String[] args) {
    5.         //1、创建一个Node类型的数组
    6.         Node[] table=new Node[16];
    7.         System.out.println("table="+table);
    8.  
    9.         //2、创建结点
    10.         Node john=new Node("jonh",null);
    11.         table[2]=john;
    12.         Node jack=new Node("jack",null);
    13.         john.next=jack;//将jack结点挂载到john
    14.         Node rose=new Node("Rose",null);
    15.         jack.next=rose;//将rose结点挂载到jack
    16.         System.out.println("table="+table);
    17.     }
    18. }
    19. class Node{//结点，存储数据，可以指向下一个结点，从而形成链表
    20.     Object item;//存放数据
    21.     Node next;//指向下一个结点
    22.  
    23.     public Node(Object item, Node next) {
    24.         this.item = item;
    25.         this.next = next;
    26.     }
    27.  
    28.     @Override
    29.     public String toString() {
    30.         return "Node{" +
    31.                 "item=" + item +
    32.                 ", next=" + next +
    33.                 '}';
    34.     }
    35. }

    注意：equals的判断标准并不能简单地认为是两个字符串比较，因为String已经重写了equals方法，所以equals的判断标准和String没有关系，要视具体情况而定

    1. //源码部分，非战斗人员，请做好撤退准备
    2. package Collection_;
    3.  
    4. import javax.swing.tree.TreeNode;
    5. import java.util.HashMap;
    6. import java.util.HashSet;
    7. @SuppressWarnings({"all"})
    8. public class HashSetSource {
    9.     public static void main(String[] args) {
    10.         HashSet hashSet=new HashSet();
    11.         hashSet.add("java");
    12.         hashSet.add("php");
    13.         hashSet.add("java");
    14.         System.out.println("set="+hashSet);
    15.         /*
    16.         追源码：
    17.         //1、执行HashSet()
    18.         public HashSet() {
    19.                 map = new HashMap<>();
    20.             }
    21.         //2、执行add方法
    22.         public boolean add(E e) {
    23.                 return map.put(e, PRESENT)==null;
    24.                 //PRESENT的源码： private static final Object PRESENT = new Object();主要起到占位的作用
    25.             }
    26.         //3、执行put方法，该方法会执行hash(key)，得到key对应的hash值，
    27.         //（hash(key)与hashcode不一样，hash(key)里面还包含了算法）相关算法： (h = key.hashCode()) ^ (h >>> 16)
    28.         public V put(K key, V value) {//是PRESENT的值
    29.                 return putVal(hash(key), key, value, false, true);
    30.             }
    31.         //4、执行 putVal（核心代码）
    32.          final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
    33.                            boolean evict) {
    34.                 Node[] tab; Node p; int n, i;//定义了辅助变量
    35.                 //table是HashMap的一个数组，类型是Node[]
    36.                 //if语句表示如果当前table是null，或者大小=0
    37.                 //就是第一次扩容到16个空间
    38.                 if ((tab = table) == null || (n = tab.length) == 0)
    39.                     n = (tab = resize()).length;
    40.                 //（1）根据key，得到hash去计算该key应该存放到table表的哪个索引位置
    41.                 //并把这个位置的对象，赋给p
    42.                 //（2）判断p是否为null
    43.                 //（2.1）如果p为null，表示还没有存放元素，就创建一个Node(key="java",value=PRESENT)
    44.                 //（2.2）否则，就放在该位置tab[i] = newNode(hash, key, value, null);
    45.                 if ((p = tab[i = (n - 1) & hash]) == null)
    46.                     tab[i] = newNode(hash, key, value, null);
    47.                 else {
    48.                 //一个开发技巧提示：在需要局部变量（辅助变量）时，再创建
    49.                     Node e; K k;
    50.                     //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
    51.                     //并且满足下面两个条件之一：
    52.                     //（1）准备加入的key和p指向的Node的结点的key是同一个对象
    53.                     //（2）p指向的Node结点的key的equals()和准备加入的key比较后相同
    54.                     //就不能加入
    55.                     if (p.hash == hash &&
    56.                         ((k = p.key) == key || (key != null && key.equals(k))))
    57.                         e = p;
    58.                         //再判断p是不是一棵红黑树
    59.                         //如果是一棵红黑树，就调用putTreeVal来进行添加
    60.                     else if (p instanceof TreeNode)
    61.                         e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
    62.                     else {
    63.                     //如果table对应索引位置，已经是一个链表，就使用for循环比较
    64.                     //（1）依次和该链表的每一元素比较后，都不相同，就加入到该链表的最后
    65.                     //    注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点
    66.                     //    就调用treeifyBin()对当前这个链表进行树化（转成红黑树）
    67.                     //    注意，在转成红黑树时，要进行判断，判断条件
    68.                     //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
    69.                     //            resize();
    70.                     //    如果上面条件成立，先table扩容
    71.                     //    只有上面条件不成立时，才进行转成红黑树
    72.                     //（2）依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break
    73.                         for (int binCount = 0; ; ++binCount) {
    74.                             if ((e = p.next) == null) {
    75.                                 p.next = newNode(hash, key, value, null);
    76.                                 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    77.                                     treeifyBin(tab, hash);
    78.                                 break;
    79.                             }
    80.                             if (e.hash == hash &&
    81.                                 ((k = e.key) == key || (key != null && key.equals(k))))
    82.                                 break;
    83.                             p = e;
    84.                         }
    85.                     }
    86.                     if (e != null) { // existing mapping for key
    87.                         V oldValue = e.value;
    88.                         if (!onlyIfAbsent || oldValue == null)
    89.                             e.value = value;
    90.                         afterNodeAccess(e);
    91.                         return oldValue;
    92.                     }
    93.                 }
    94.                 ++modCount;
    95.                 //size就是我们每加入一个结点Node(k,v,h,next),size++
    96.                 if (++size > threshold)
    97.                     resize();
    98.                 afterNodeInsertion(evict);
    99.                 return null;
    100.             }
    101.             */
    102.     }
    103. }

    3、练习题：

    （1）

    //我的代码：

    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Iterator;
    5.  
    6. @SuppressWarnings({"all"})
    7. public class HashSetExercise {
    8.     public static void main(String[] args) {
    9.         HashSet hashSet = new HashSet();
    10.         Employee[] employees = new Employee[4];
    11.         employees[0]=new Employee("jack", 18);
    12.         employees[1]=new Employee("tom", 19);
    13.         employees[2]=new Employee("rose", 20);
    14.         employees[3]=new Employee("rose", 20);
    15.         hashSet.add(employees[0]);
    16.         for (int i = 1; i < employees.length; i++) {
    17.             int tmp=0;
    18.             Iterator iterator=hashSet.iterator();
    19.             while (iterator.hasNext()) {
    20.                 Object next =  iterator.next();
    21.                 if (employees[i].getAge() == hashSet.hashCode()|| employees[i].getName().equals(hashSet.hashCode())) {
    22.                     break;
    23.                 }
    24.             }
    25.             hashSet.add(employees[i]);
    26.         }
    27.         for (Object o :hashSet) {
    28.             System.out.println(o);
    29.         }
    30.     }
    31. }
    32. class Employee{
    33.     private String name;
    34.     private int age;
    35.  
    36.     public Employee(String name, int age) {
    37.         this.name = name;
    38.         this.age = age;
    39.     }
    40.  
    41.     public String getName() {
    42.         return name;
    43.     }
    44.  
    45.     public void setName(String name) {
    46.         this.name = name;
    47.     }
    48.  
    49.     public int getAge() {
    50.         return age;
    51.     }
    52.  
    53.     public void setAge(int age) {
    54.         this.age = age;
    55.     }
    56.  
    57.     @Override
    58.     public String toString() {
    59.         return "Employee{" +
    60.                 "name='" + name + '\'' +
    61.                 ", age=" + age +
    62.                 '}';
    63.     }
    64. }

     //老师的代码：

    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Objects;
    5. @SuppressWarnings({"all"})
    6. public class HashSetExercise {
    7.     public static void main(String[] args) {
    8.         HashSet hashSet = new HashSet();
    9.         hashSet.add(new Employee("milan",18));
    10.         hashSet.add(new Employee("jack",28));
    11.         hashSet.add(new Employee("milan",18));
    12.         System.out.println("hashSet="+hashSet);
    13.     }
    14. }
    15. class Employee{
    16.     private String name;
    17.     private int age;
    18.  
    19.     public Employee(String name, int age) {
    20.         this.name = name;
    21.         this.age = age;
    22.     }
    23.  
    24.     public String getName() {
    25.         return name;
    26.     }
    27.  
    28.     public void setName(String name) {
    29.         this.name = name;
    30.     }
    31.  
    32.     public int getAge() {
    33.         return age;
    34.     }
    35.  
    36.     public void setAge(int age) {
    37.         this.age = age;
    38.     }
    39.  
    40.     @Override
    41.     public String toString() {
    42.         return "Employee{" +
    43.                 "name='" + name + '\'' +
    44.                 ", age=" + age +
    45.                 '}';
    46.     }
    47.     //重写equals()方法和hashCode()方法：
    48.     @Override
    49.     public boolean equals(Object o) {
    50.         if (this == o) return true;
    51.         if (o == null || getClass() != o.getClass()) return false;
    52.         Employee employee = (Employee) o;
    53.         return age == employee.age && Objects.equals(name, employee.name);
    54.     }
    55.  
    56.     @Override
    57.     public int hashCode() {
    58.         return Objects.hash(name, age);
    59.     }
    60. }
    61. //hashSet=[Employee{name='milan', age=18}, Employee{name='jack', age=28}]

    ·重写equals()方法和hashCode()方法：

    alt+insert---->---->下一步---->---->下一步---->

     （2）

     //我的代码

    1. package Collection_;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Objects;
    5.  
    6. @SuppressWarnings({"all"})
    7. public class HashSetExercise02 {
    8.     public static void main(String[] args) {
    9.         HashSet hashSet=new HashSet();
    10.         MyDate jack=new MyDate(2000,1,1);
    11.         MyDate tom=new MyDate(2001,2,2);
    12.         hashSet.add(new Employee("jack",20000,jack));
    13.         hashSet.add(new Employee("tom",30000,tom));
    14.         hashSet.add(new Employee("jack",20000,jack));
    15.         System.out.println(hashSet);
    16.     }
    17. }
    18. class Employee{
    19.     private String name;
    20.     private double sal;
    21.     private MyDate birthday;
    22.  
    23.     public Employee(String name, double sal, MyDate birthday) {
    24.         this.name = name;
    25.         this.sal = sal;
    26.         this.birthday = birthday;
    27.     }
    28.  
    29.     public String getName() {
    30.         return name;
    31.     }
    32.  
    33.     public void setName(String name) {
    34.         this.name = name;
    35.     }
    36.  
    37.     public double getSal() {
    38.         return sal;
    39.     }
    40.  
    41.     public void setSal(double sal) {
    42.         this.sal = sal;
    43.     }
    44.  
    45.     public MyDate getBirthday() {
    46.         return birthday;
    47.     }
    48.  
    49.     public void setBirthday(MyDate birthday) {
    50.         this.birthday = birthday;
    51.     }
    52.  
    53.     @Override
    54.     public String toString() {
    55.         return "Employee{" +
    56.                 "name='" + name + '\'' +
    57.                 ", sal=" + sal +
    58.                 ", birthday=" + birthday +
    59.                 '}';
    60.     }
    61.  
    62.     @Override
    63.     public boolean equals(Object o) {
    64.         if (this == o) return true;
    65.         if (o == null || getClass() != o.getClass()) return false;
    66.         Employee employee = (Employee) o;
    67.         return Objects.equals(name, employee.name) && Objects.equals(birthday, employee.birthday);
    68.     }
    69.  
    70.     @Override
    71.     public int hashCode() {
    72.         return Objects.hash(name, birthday);
    73.     }
    74. }
    75. class MyDate{
    76.     private int year;
    77.     private int month;
    78.     private int day;
    79.  
    80.     public MyDate(int year, int month, int day) {
    81.         this.year = year;
    82.         this.month = month;
    83.         this.day = day;
    84.     }
    85.  
    86.     public int getYear() {
    87.         return year;
    88.     }
    89.  
    90.     public void setYear(int year) {
    91.         this.year = year;
    92.     }
    93.  
    94.     public int getMonth() {
    95.         return month;
    96.     }
    97.  
    98.     public void setMonth(int month) {
    99.         this.month = month;
    100.     }
    101.  
    102.     public int getDay() {
    103.         return day;
    104.     }
    105.  
    106.     public void setDay(int day) {
    107.         this.day = day;
    108.     }
    109.  
    110.     @Override
    111.     public String toString() {
    112.         return "MyDate{" +
    113.                 "year=" + year +
    114.                 ", month=" + month +
    115.                 ", day=" + day +
    116.                 '}';
    117.     }
    118. }
    119. //[Employee{name='jack', sal=20000.0, birthday=MyDate{year=2000, month=1, day=1}}, Employee{name='tom', sal=30000.0, birthday=MyDate{year=2001, month=2, day=2}}]
    120.

     三、LinkedHashSet

    1、基本介绍：

    （1）LinkedHashSet 是 HashSet的子类

    （2）LinkedHashSet 底层是一个 LinkedHashMap，底层维护了一个数组＋双向链表

    （3）LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，同时使 用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

    （4）LinkedHashSet 不允许添重复元素

    2、LinkedHashSet底层机制：

    1. package Collection_;
    2.  
    3. import java.util.LinkedHashSet;
    4. import java.util.Set;
    5. @SuppressWarnings({"all"})
    6. public class LinkedHashSetSource {
    7.     public static void main(String[] args) {
    8.         Set set=new LinkedHashSet();
    9.         set.add(new String("AA"));
    10.         set.add(456);
    11.         set.add(456);
    12.         set.add(new Customer("刘",1001));
    13.         set.add(123);
    14.         set.add("HSP");
    15.     }
    16. }
    17. class Customer{
    18.     private String name;
    19.     private int no;
    20.  
    21.     public Customer(String name, int no) {
    22.         this.name = name;
    23.         this.no = no;
    24.     }
    25. }

     3、练习题：

     //我的代码：

    1. package Collection_;
    2.  
    3. import java.util.LinkedHashSet;
    4. import java.util.Objects;
    5. import java.util.Set;
    6. @SuppressWarnings({"all"})
    7. public class LinkedHashSet_ {
    8.     public static void main(String[] args) {
    9.         Set linkedHashSet=new LinkedHashSet();
    10.         linkedHashSet.add(new Car("奥拓",1000));
    11.         linkedHashSet.add(new Car("奥迪",300000));
    12.         linkedHashSet.add(new Car("法拉利",10000000));
    13.         linkedHashSet.add(new Car("保时捷",70000000));
    14.         linkedHashSet.add(new Car("奥迪",300000));
    15.         System.out.println("linkedHashSet="+linkedHashSet);
    16.     }
    17.     public static class Car {
    18.         private String name;
    19.         private double price;
    20.  
    21.         public Car(String name, double price) {
    22.             this.name = name;
    23.             this.price = price;
    24.         }
    25.  
    26.         public String getName() {
    27.             return name;
    28.         }
    29.  
    30.         public void setName(String name) {
    31.             this.name = name;
    32.         }
    33.  
    34.         public double getPrice() {
    35.             return price;
    36.         }
    37.  
    38.         public void setPrice(double price) {
    39.             this.price = price;
    40.         }
    41.  
    42.         @Override
    43.         public String toString() {
    44.             return "Car{" +
    45.                     "name='" + name + '\'' +
    46.                     ", price=" + price +
    47.                     '}';
    48.         }
    49.  
    50.         @Override
    51.         public boolean equals(Object o) {
    52.             if (this == o) return true;
    53.             if (o == null || getClass() != o.getClass()) return false;
    54.             Car car = (Car) o;
    55.             return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    56.         }
    57.  
    58.         @Override
    59.         public int hashCode() {
    60.             return Objects.hash(name, price);
    61.         }
    62.     }
    63. }
    64. //linkedHashSet=[Car{name='奥拓', price=1000.0}, Car{name='奥迪', price=300000.0}, Car{name='法拉利', price=1.0E7}, Car{name='保时捷', price=7.0E7}]

  • 相关阅读:
    LeetCode50天刷题计划第二季（Day 32 — 阶乘后的零（13.20-14.00）
    @SpringBootApplication 注解报红
    软件设计师考试学习1
    如何解决跨区域文件传输存在的安全管控问题？
    Java高级技术之Gradle
    Spring Cloud和Dubbo有哪些区别？
    Nginx缓存
    6235. 逐层排序二叉树所需的最少操作数目
    (shorthand) pixelNeRF: Neural Radiance Fields from One or Few Images
    基于闪电搜索优化的BP神经网络（分类应用） - 附代码
  • 原文地址：https://blog.csdn.net/weixin_72052233/article/details/128031401