Java Set系列集合

秒速五厘米 2024-03-27 17:25 0阅读 0赞

### Set 系列集合 ###

*  无序：存取顺序不一致
 *  不重复：可以去除重复
 *  无索引：没有带索引的方法，所以不能用普通for循环遍历，也不能通过索引获取元素

package com.myset;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.function.Consumer;
    
    public class SetDemo01 {
        
        public static void main (String[] args) {
        
    
            //1. 创建一个Set集合的对象
            Set<String> s = new HashSet<> ();
    
            //2. 添加元素：如果当前元素是第一次添加，那么可以添加成功，返回true，如果第二次添加，返回FALSE
            boolean r1 = s.add ("zhangsan");
            boolean r2 = s.add ("lisi");
            boolean r3 = s.add ("wangwu");
    
    
            //3. 打印集合：无序 ：[lisi, zhangsan, wangwu]
            System.out.println (s);
    
            //4. 迭代器遍历
            Iterator<String> iterator = s.iterator ();
            while (iterator.hasNext ()){
        
                String str = iterator.next ();
                System.out.println (str);
            }
    
            //5. 增强for遍历
            for (String str : s) {
        
                System.out.println (str);
            }
    
            //6. 匿名内部类
            s.forEach (new Consumer<String> () {
        
                @Override
                public void accept (String str) {
        
                    System.out.println (str);
                }
            });
            //6. Lambda 表达式
            s.forEach ((str)-> System.out.println (str));
            s.forEach (str-> System.out.println (str));
    
        }
    }

#### Set集合实现类 ####

*  HashSet ： 无序、不重复、无索引
 *  LinkedHashSet ： **有序**、不重复、无索引
 *  TreeSet ：**可排序**、不重复、无索引  
    ==Set 接口中的方法基本上与Collection 的API一致

#### HashSet 底层原理 ####

*  HashSet底层采取哈希表存储数据
 *  哈希表是一种对于增删改查数据性能都比较好的结构

1.  创建一个默认长度16的，默认加载因子0.75的数组，数组名：table
    
     *  0.75是当数组长度达到原长度的0.75倍时，数组自动扩容为原来的一倍
2.  根据元素的哈希值跟数组的长度计算出应存入的位置
    
     *  **int index = (数组长度 -1) & 哈希值**
3.  判断当前位置是否为null，如果是直接存入
4.  如果当前位置不为null，表示有元素，调用equals方法比较属性值
5.  一样：不存 不一样：存入数组，形成链表
    
     *  JDK8之前：新元素存入数组，老元素挂在新元素下面
     *  JDK8之后：新元素直接挂在老元素下面  
        JDK8 之后，链表长度**超过8**，并且数组长度**大于等于64**的时候，链表自动转换为红黑树  
        如果集合中存储的是自定义对象，必须要重写**hashCode**和**equals**方法

##### 哈希表的组成 #####

JDK8之前：数组+链表
    JDK8开始：数组+链表+红黑树

###### 哈希值 ######

哈希值：对象的整数表现形式
    int index = (数组长度 -1) & 哈希值

*  根据hashCode方法算出来的int 类型的数
 *  该方法定义在Object类中，所有的对象都可以调用，默认使用地址值进行计算
 *  一般情况下，会重写hashCode方法，利用对象内部的属性值计算哈希值

###### 对象的哈希值特点 ######

如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
    如果已经重写hashCode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
    在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样（哈希碰撞）

package com.myset;
    
    public class HashSetDemo01 {
        
        public static void main (String[] args) {
        
    
    
            //1. 创建对象
            Student s1 = new Student ("zhangsan", 23);
            Student s2 = new Student ("zhangsan", 23);
    
            //2. 如果没有重写hashCode
            System.out.println (s1.hashCode ());//1956725890
            System.out.println (s2.hashCode ());//356573597
    
            //2. 重写了hashCode
            System.out.println (s1.hashCode ());//-1461067292
            System.out.println (s2.hashCode ());//-1461067292
    
            //小部分情况的，哈希碰撞
            System.out.println ("abc".hashCode ());//96354
            System.out.println ("acD".hashCode ());//96354
    
        }
    }

package com.myset;
    
    import java.util.Objects;
    
    public class Student {
        
        private String name;
        private int age;
    
    
        public Student () {
        
        }
    
        public Student (String name, int age) {
        
            this.name = name;
            this.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);
        }
    
        /**
         * 获取
         * @return name
         */
        public String getName () {
        
            return name;
        }
    
        /**
         * 设置
         * @param name
         */
        public void setName (String name) {
        
            this.name = name;
        }
    
        /**
         * 获取
         * @return age
         */
        public int getAge () {
        
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge (int age) {
        
            this.age = age;
        }
    
        public String toString () {
        
            return "Student{name = " + name + ", age = " + age + "}";
        }
    }

#### 练习： ####

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

package com.myset;
    
    import java.util.HashSet;
    
    public class HashSetDemo02 {
        
        public static void main (String[] args) {
        
            /*
                需求：创建一个存储学生对象的集合，存储多个学生对象
                使用程序实现在控制台遍历该集合
                要求：学生对象的成员变量值相同，我们就认为是同一个对象
             */
    
            //1. 创建三个学生对象
            Student s1 = new Student ("zhangsan", 23);
            Student s2 = new Student ("lisi", 24);
            Student s3 = new Student ("wangwu", 25);
            Student s4 = new Student ("zhangsan", 23);
    
            //2. 创建集合用来添加学生
            HashSet<Student> hs = new HashSet<> ();
    
            //3. 添加元素
            System.out.println (hs.add (s1));
            System.out.println (hs.add (s2));
            System.out.println (hs.add (s3));
            System.out.println (hs.add (s4));
    
            //4. 打印集合
            System.out.println (hs);
        }
    }

### LinkedHashSet ###

#### 底层原理 ####

*  有序、不重复、无索引
 *  这里的有序指的是存储和取出的元素顺序是一致的
 *  原理：底层结构依旧是哈希表，只是每个元素又额外多了一个双链表的机制，记录储存的顺序

package com.myset;
    
    import java.util.LinkedHashSet;
    
    public class LinkedHashSetDemo {
        
        public static void main (String[] args) {
        
            //1. 创建4个学生对象
            Student s1 = new Student ("zhangsan", 23);
            Student s2 = new Student ("lisi", 24);
            Student s3 = new Student ("wangwu", 25);
            Student s4 = new Student ("zhangsan", 23);
    
            //2. 创建集合用来添加学生
            LinkedHashSet<Student> lhs = new LinkedHashSet<> ();
    
            //3. 添加元素
            System.out.println (lhs.add (s3));
            System.out.println (lhs.add (s2));
            System.out.println (lhs.add (s1));
            System.out.println (lhs.add (s4));
    
            //4. 打印集合
            System.out.println (lhs);
            
            /*
                true
                true
                true
                false
                [Student{name = wangwu, age = 25}, Student{name = lisi, age = 24}, Student{name = zhangsan, age = 23}]
             */
        }
    }

### 总结（HashSet、LinkedHashSet） ###

#### 在以后如果数据要去重，我们使用哪个？ ####

默认使用HashSet
    如果要求去重并且有序，使用LinkedHashSet

### TreeSet ###

#### 特点 ####

*  不重复、无索引、可排序
 *  可排序：按照元素默认规则：**从小到大**排序
 *  底层是基于**红黑树**的数据结构实现排序的，增删改查性能都较好

#### TreeSet集合默认的规则 ####

*  对于数值型：Integer，Double，默认按照从小到大的顺序进行排序
 *  对于字符、字符串类型：**按照字符在ASCII码表中的数字升序进行排序**

##### 案例 #####

package com.myset;
    
    import java.util.Iterator;
    import java.util.TreeSet;
    import java.util.function.Consumer;
    
    public class TreeSetDemo01 {
        
        public static void main (String[] args) {
        
    
    
            //1. 创建集合对象
            TreeSet<Integer> ts = new TreeSet<> ();
    
            //2. 添加元素
            ts.add (2);
            ts.add (3);
            ts.add (5);
            ts.add (1);
            ts.add (4);
    
            //3. 打印集合
            System.out.println (ts);
            System.out.println ("-------------------------------------------------");
    
            //4. 遍历集合
    
            Iterator<Integer> it = ts.iterator ();
            while (it.hasNext ()){
        
                Integer integer = it.next ();//自动装箱，自动拆箱Integer和int可以自动转换
                System.out.println (integer);
            }
            System.out.println ("-------------------------------------------------");
    
            for (Integer t : ts) {
        
                System.out.println (t);
            }
            System.out.println ("-------------------------------------------------");
    
            ts.forEach (new Consumer<Integer> () {
        
                @Override
                public void accept (Integer integer) {
        
                    System.out.println (integer);
                }
            });
            System.out.println ("-------------------------------------------------");
    
            ts.forEach (i-> System.out.println (i));
        }
    }

### TreeSet 的排序规则（两种方式） ###

使用原则：默认使用第一种，如果第一种不能满足当前需求，就使用第二种

#### 方式一： ####

自然/默认排序规则：自定义类实现Comparable接口，重写里面的抽象方法，在指定比较规则  
![在这里插入图片描述][73796feee53649ad82896b60cb101740.png]

package com.myset;
    
    import sun.reflect.generics.tree.Tree;
    
    import java.util.TreeSet;
    
    public class TreeSetDemo02 {
        
        public static void main (String[] args) {
        
            /*
                创建TreeSet集合，并添加三个学生对象
                学生对象属性：
                    姓名、年龄
                按照学生的年龄进行排序
                同年龄按照姓名首字母排序（暂时不考虑中文）
                同姓名、同年龄认为是同一个人
    
                方式一：
                    默认的排序规则
                        Student实现Comparable接口，重写里面的抽象方法，在指定比较规则
             */
    
            //1. 创建学生对象
            Student s1 = new Student ("zhangsan", 23);
            Student s2 = new Student ("lisi", 24);
            Student s3 = new Student ("wangwu", 25);
    
            //2. 创建集合用来添加学生
            TreeSet<Student> ts = new TreeSet<> ();
    
            //3. 添加元素
            ts.add (s2);
            ts.add (s1);
            ts.add (s3);
    
            //4. 打印集合
            System.out.println (ts);
    
        }
    }

package com.myset;
    
    import java.util.Objects;
    
    public class Student implements Comparable<Student>{
        
        private String name;
        private int age;
    
        @Override
        public int compareTo (Student o) {
        
            /*
                指定排序规则
                只看年龄
             */
            return this.getAge () - o.getAge ();
        }
    
        public Student () {
        
        }
    
        public Student (String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        /**
         * 获取
         * @return name
         */
        public String getName () {
        
            return name;
        }
    
        /**
         * 设置
         * @param name
         */
        public void setName (String name) {
        
            this.name = name;
        }
    
        /**
         * 获取
         * @return age
         */
        public int getAge () {
        
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge (int age) {
        
            this.age = age;
        }
    
        public String toString () {
        
            return "Student{name = " + name + ", age = " + age + "}";
        }
    }

#### 方式二： ####

比较器排序：创建TreeSet对象的时候，传递比较器Comparator指定规则

package com.myset;
    
    import java.util.Comparator;
    import java.util.TreeSet;
    
    public class TreeSetDemo03 {
        
        public static void main (String[] args) {
        
            /*
                需求：存入四个字符串："c","ab","df","qwer"
                    首先按照长度排序，如果一样按照首字母排序
    
             */
    
            /*
                1. 创建集合
                o1：表示当前要添加的元素
                o2：表示已经在红黑树上的元素
                返回值跟之前是一样的
             */
    /*        TreeSet<String> ts = new TreeSet<> (new Comparator<String> () {
                @Override
                public int compare (String o1, String o2) {
                    //按照长度排序
                    int i = o1.length () - o2.length ();
                    //如果一样长按照首字母排序
                    i = i == 0 ? o1.compareTo (o2) : i;
                    return i;
                }
            });*/
    
            //使用Lambda 表达式，简化
            TreeSet<String> ts = new TreeSet<> ((o1,o2)->{
        
                int i = o1.length () - o2.length ();
                i = i == 0 ? o1.compareTo (o2) : i;
                return i;
            });
    
            //2. 添加元素
            ts.add ("c");
            ts.add ("ab");
            ts.add ("df");
            ts.add ("qwer");
    
            //3. 打印集合
            System.out.println (ts);
        }
    }

#### TreeSet对象排序练习题 ####

需求：创建5个学生对象
    属性：(姓名,年龄，语文成绩,数学成绩,英语成绩)，
    按照总分从高到低输出到控制台
    如果总分一样，按照语文成绩排
    如果语文一样，按照数学成绩排
    如果数学成绩一样，按照英语成绩排
    如果英文成绩一样，按照年龄排
    如果年龄一样，按照姓名的字母顺序排
    如果都一样，认为是同一个学生，不存。

package com.myset;
    
    import java.util.TreeSet;
    
    public class TreeSetDemo04 {
        
        public static void main (String[] args) {
        
            /*
                需求：创建5个学生对象
                属性：(姓名,年龄，语文成绩,数学成绩,英语成绩)，
                按照总分从高到低输出到控制台
                如果总分一样，按照语文成绩排
                如果语文一样，按照数学成绩排
                如果数学成绩一样，按照英语成绩排
                如果英文成绩一样，按照年龄排
                如果年龄一样，按照姓名的字母顺序排
                如果都一样，认为是同一个学生，不存。
             */
            Student2 s1 = new Student2 ("zahngsan", 23, 98, 99, 38);
            Student2 s2 = new Student2 ("lisi", 21, 92, 91, 98);
            Student2 s3 = new Student2 ("wangwu", 25, 99, 88, 138);
            Student2 s4 = new Student2 ("wangcai", 22, 93, 121, 58);
            Student2 s5 = new Student2 ("dahuang", 23, 97, 76, 78);
    
            //2. 创建集合
            TreeSet<Student2> ts = new TreeSet<> ();
    
            //3. 添加元素
            ts.add (s1);
            ts.add (s2);
            ts.add (s3);
            ts.add (s4);
            ts.add (s5);
    
            //4. 打印集合
            for (Student2 t : ts) {
        
                System.out.println (t);
            }
        }
    }

package com.myset;
    
    public class Student2 implements Comparable<Student2>{
        
        private String name;
        private int age;
        private int chinese;
        private int math;
        private int english;
    
        public Student2 () {
        
        }
    
        public Student2 (String name, int age, int chinese, int math, int english) {
        
            this.name = name;
            this.age = age;
            this.chinese = chinese;
            this.math = math;
            this.english = english;
        }
    
            /*
                按照总分从高到低输出到控制台
                如果总分一样，按照语文成绩排
                如果语文一样，按照数学成绩排
                如果数学成绩一样，按照英语成绩排
                如果英文成绩一样，按照年龄排
                如果年龄一样，按照姓名的字母顺序排
                如果都一样，认为是同一个学生，不存。
             */
    
        @Override
        public int compareTo (Student2 o) {
        
            int sum1 = this.getChinese ()+this.getEnglish ()+getMath ();
            int sum2 = o.getChinese ()+o.getMath ()+o.getMath ();
    
            //比较两者的总分
            int i = sum1 - sum2;
            //如果总分一样，按照语文成绩排
            i = i == 0 ? this.getChinese () - o.getChinese ():i;
            //如果语文一样，按照数学成绩排
            i = i == 0 ? this.getMath () - o.getMath ():i;
            //如果数学成绩一样，按照英语成绩排（可以不写）
            i = i == 0 ? this.getEnglish () - o.getEnglish ():i;
            //如果英文成绩一样，按照年龄排
            i = i == 0 ? this.getAge () - o.getAge ():i;
            //如果年龄一样，按照姓名的字母顺序排
            i = i == 0 ? this.getName ().compareTo (o.getName ()):i;
            return i;
        }
    
        /**
         * 获取
         * @return name
         */
        public String getName () {
        
            return name;
        }
    
        /**
         * 设置
         * @param name
         */
        public void setName (String name) {
        
            this.name = name;
        }
    
        /**
         * 获取
         * @return age
         */
        public int getAge () {
        
            return age;
        }
    
        /**
         * 设置
         * @param age
         */
        public void setAge (int age) {
        
            this.age = age;
        }
    
        /**
         * 获取
         * @return chinese
         */
        public int getChinese () {
        
            return chinese;
        }
    
        /**
         * 设置
         * @param chinese
         */
        public void setChinese (int chinese) {
        
            this.chinese = chinese;
        }
    
        /**
         * 获取
         * @return math
         */
        public int getMath () {
        
            return math;
        }
    
        /**
         * 设置
         * @param math
         */
        public void setMath (int math) {
        
            this.math = math;
        }
    
        /**
         * 获取
         * @return english
         */
        public int getEnglish () {
        
            return english;
        }
    
        /**
         * 设置
         * @param english
         */
        public void setEnglish (int english) {
        
            this.english = english;
        }
    
        public String toString () {
        
            return "Student2{name = " + name + ", age = " + age + ", chinese = " + chinese + ", math = " + math + ", english = " + english + "}";
        }
    }

#### TreeSet 总结 ####

![在这里插入图片描述][46ff716f11744de791601fa54e5fdbe2.png]

### 集合总结 ###

1.  如果想要集合中的元素可重复
    
     *  ArrayList集合，基于数组的（用的最多）
2.  如果想要集合中的元素可重复，而且当前的增删操作明显多余查询
    
     *  用LinkedList集合，基于链表的
3.  如果想要对集合中的元素去重
    
     *  用HashSet集合，基于哈希表的（用的最多）
4.  如果想对集合中的元素去重，而且保证存取顺序
    
     *  用LinkedHashSet集合，基于哈希表和双链表，效率地狱HashSet
5.  如果想要对集合中的元素排序
    
     *  用TreeSet集合，基于红黑树。后续也可以用List集合实现排序

[73796feee53649ad82896b60cb101740.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/424aa3d219404306ba83e57b88a1d518.png
[46ff716f11744de791601fa54e5fdbe2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1c678831a17948d295dd44ad74d0b2e4.png