devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中的Set系列集合超详解_set集合

作者：黑客灵魂 | 2024-08-13 08:06:42

赞

踩

set集合

 Set

 List是有序集合的根接口，Set是无序集合的根接口，无序也就意味着元素不重复。更严格地说，Set集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多一个空元素。
  使用Set存储的特点与List相反：元素无序、不可重复。常用的实现方式：HashSet、LinkedHashSet和TreeSet。

Set系列集合概述和特点

  • 底层数据结构是哈希表

  • 存取无序

  • 不可以存储重复元素

  • 没有索引,不能使用普通for循环遍历

set集合的基本应用

  1.  public static void main(String[] args) {
  2.         Set<String> s=new HashSet<String>();
  3.         boolean flag1= s.add("aaa");
  4.         boolean flag2 = s.add("aaa");
  5.         System.out.println(flag1);
  6.         System.out.println(flag2);
  7.         System.out.println(s);
  8.         //如果当前元素是第一次添加，那么可以添加成功，返回true
  9.         //如果当前元素是第二次添加，那么添加失败，返回false
  11.     }

        

存储字符串并遍历

方式一迭代器方式

  1.  public static void main(String[] args) {
  2.         Set<String> s=new HashSet<String>();
  3.         s.add("张三");
  4.         s.add("李四");
  5.         //迭代器
  6.         Iterator<String> it = s.iterator();
  7.         while(it.hasNext()){
  8.             String str = it.next();
  9.             System.out.println(str);
  10.         }
  11.  
  12.  
  13.     }

方式2-增强for

  1.  
  2.         //增强for
  3.         for (String str : s) {
  4.             System.out.println(str);
  5.         }

方式3lambda表达式

  1.  // Lambda表达式
  2.         s.forEach((String str)-> System.out.println(str));

总结

HashSet集合概述和特点

  • 底层数据结构是哈希表

  • 存取无序

  • 不可以存储重复元素

  • 没有索引,不能使用普通for循环遍历

哈希值

  • 哈希值简介

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

  • 如何获取哈希值

    Object类中的public int hashCode()：返回对象的哈希码值

  • 哈希值的特点

    • 同一个对象多次调用hashCode()方法返回的哈希值是相同的

    • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

  1. package set;
  2. /*
  3.            哈希值：
  4.                对象的整数表现形式
  5.                1. 如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
  6.                2. 如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
  7.                3. 但是在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。（哈希碰撞）
  9.         */
  10. public class demo3 {
  11.     public static void main(String[] args) {
  12.  
  13.         //   1. 如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
  14.         Student s1 = new Student("zhangsan",18);
  15.         Student s2 = new Student("zhangsan",18);
  16.       /*  System.out.println(s1.hashCode());//189568618
  17.         System.out.println(s2.hashCode());//793589513*/
  18.         //不一样,所以我们要重写hashCode()
  19.         //  2. 如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样
  20.         System.out.println("------------------");
  21.         System.out.println(s1.hashCode());//1461067297
  22.         System.out.println(s2.hashCode());//1461067297
  24.        // 3. 但是在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。（哈希碰撞）
  25.         //哈希碰撞
  26.         System.out.println("abc".hashCode());//96354
  27.         System.out.println("acD".hashCode());//96354
  28.     }
  29. }

练习

  1. package lx;
  2.  
  3. import java.util.HashSet;
  4.  
  5. public class demo1 {
  6.     public static void main(String[] args) {
  7.         Student s1 = new Student("张三", 8);
  8.         Student s2 = new Student("张三", 8);
  9.         Student s3 = new Student("李四", 18);
  10.         Student s4 = new Student("王五", 17);
  11.         HashSet<Student> set = new HashSet<Student>();
  12.         set.add(s1);
  13.         set.add(s2);
  14.         set.add(s3);
  15.         set.add(s4);
  16.         //重写hashCode方法就可以去重复的对象
  17.         //因为重写hashCode方法,比的是属性值,属性值一样,哈希值一样,所以添加不成功
  18.         //不重写比的是地址值,创建出来的对象地址值永远不一样,所以哈希值不一样,所以添加成功
  19.         //如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样
  20.         //重写equals方法也一样 比的也是地址值,不是属性值
  21.         for (Student student : set) {
  23.             System.out.println(student);
  24.         }
  27.     }
  28. }

注意像String Integer类型的,Java已经在底层重写好了HashSet和equals方法

LinkedHashSet

  1. package LinkedHashSet;
  2.  
  3. import lx.Student;
  4.  
  5.  
  6. import java.util.HashSet;
  7. import java.util.LinkedHashSet;
  8.  
  9. public class demo1 {
  10.     public static void main(String[] args) {
  11.  
  12.         Student s1 = new Student("张三", 8);
  13.  
  14.  
  15.         Student s2 = new Student("张三", 8);
  16.         Student s3 = new Student("李四", 18);
  17.         Student s4 = new Student("王五", 17);
  18.         LinkedHashSet<Student> set = new LinkedHashSet<Student>();
  19.         set.add(s3);
  20.         set.add(s1);
  21.         set.add(s3);
  22.         set.add(s4);
  23.         //LinkedHashSet的存和去顺序一样
  24.         for (Student student : set) {
  25.  
  26.             System.out.println(student);
  27.         }
  28.  
  29.     }
  30. }

 

TreeSet

  1. package TreeSet;
  2.  
  3. import java.util.TreeSet;
  4.  
  5. public class demo1 {
  6.     public static void main(String[] args) {
  7.         //利用TreeSet对整数进行排序
  8.         //默认升序
  9.         TreeSet<Integer> ts = new TreeSet<>();
  10.         //添加元素
  11.         ts.add(4);
  12.         ts.add(2);
  13.         ts.add(5);
  14.         ts.add(8);
  15.         ts.add(1);
  16.         //使用增强for
  17.         for (Integer t : ts) {
  18.             System.out.print(t + " ");
  19.         }
  20.  
  21.     }
  22. }

  1. package TreeSet;
  2.  
  3. import java.util.TreeSet;
  4.  
  5. public class demo2 {
  6.     public static void main(String[] args) {
  7.         //利用TreeSet对String类型进行排序
  8.         TreeSet<String> ts = new TreeSet<>();
  9.         ts.add("va");
  10.         ts.add("aaa");
  11.         ts.add("ha");
  12.         ts.add("aba");
  13.         ts.add("acd");
  14.         for (String t : ts) {
  15.             System.out.print(t + " ");
  16.         }
  17.     }
  18. }

练习

  1.  @Override
  2.     public int compareTo(Student o) {
  3.         //只看年龄按照升序排序
  4.        int tmp=this.getAge() - o.getAge();
  5.       tmp= tmp==0?this.getName().compareTo(o.getName()):tmp;
  6.       return tmp;
  7.     }
  1. package TreeSet;
  2.  
  3. import javax.print.DocFlavor;
  4. import java.util.TreeSet;
  5. import java.util.function.Consumer;
  6.  
  7. public class demo3 {
  8.     public static void main(String[] args) {
  9.         //利用TreeSet对学生类型进行排序
  10.         TreeSet<Student> ts = new TreeSet<>();
  11.         //要求: 按照学生的年龄进行排序
  12.         //同年按照姓名字母排序
  13.         //同姓名,同年龄认为同一个人
  14.         Student s1 = new Student("zhangsan", 18);
  15.         Student s2 = new Student("lisi", 19);
  16.         Student s3 = new Student("wangwu", 19);
  18.         ts.add(s2);
  19.         ts.add(s3);
  20.         ts.add(s1);
  21.         System.out.println(ts);
  22.         //方式一:默认的排序方式,Student实现一个接口(comparable接口)重写里面的抽象方法
  23.         //再指定比较规则
  27.         //hashCode和equals方法跟哈希表有关
  28.         //TreeSet底层红黑树有关
  29.         //所以不需要重写hashCode和equals方法
  30.     }
  31. }

  1. package TreeSet;
  2.  
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  5.  
  6. public class demo4 {
  7.     public static void main(String[] args) {
  8.         //方法二:比较器排序
  9.         //1.创建集合
  10.         //2.o1表示当前要添加的元素
  11.         //3.o2表示已经在红黑树存在的元素
  12.         //返回值规则跟之前一样
  13.         TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
  14.             @Override
  15.             /*
  16.             需求：请自行选择比较器排序和自然排序两种方式；
  17.             要求：存入四个字符串， “c”, “ab”, “df”, “qwer”
  18.             按照长度排序，如果一样长则按照首字母排序
  19.  
  20.             采取第二种排序方式：比较器排序
  21.              */
  22.             public int compare(String o1, String o2) {
  23.                 //按照长度来
  24.                 int tmp = o1.length() - o2.length();
  25.                 //如果一样长则按照首字母排序
  26.                     tmp = tmp == 0 ? o1.compareTo(o2) : tmp;
  27.                 return tmp;
  28.             }
  29.         });
  30.         //2.添加元素
  31.         ts.add("c");
  32.         ts.add("ab");
  33.         ts.add("df");
  34.         ts.add("qwer");
  35.         System.out.println(ts);
  36.     }
  37. }

  1. package lx2;
  2.  
  3. import java.util.TreeSet;
  4.  
  5. /*  需求：创建5个学生对象
  6.         属性：(姓名,年龄，语文成绩,数学成绩,英语成绩),
  7.         按照总分从高到低输出到控制台
  8.         如果总分一样，按照语文成绩排
  9.         如果语文一样，按照数学成绩排
  10.         如果数学成绩一样，按照英语成绩排
  11.         如果英文成绩一样，按照年龄排
  12.         如果年龄一样，按照姓名的字母顺序排
  13.         如果都一样，认为是同一个学生，不存。
  15.         第一种：默认排序/自然排序
  16.         第二种：比较器排序
  17.  
  18.         默认情况下，用第一种排序方式，如果第一种不能满足当前的需求，采取第二种方式。
  19.  
  20.  
  21.         课堂练习：
  22.             要求：在遍历集合的时候，我想看到总分。
  23.  
  24.       */
  25. public class demo1 {
  26.     public static void main(String[] args) {
  27.         //1.创建学生对象
  28.         Student s1 = new Student("zhangsan", 23, 90, 99, 50);
  29.         Student s2 = new Student("lisi", 24, 90, 98, 50);
  30.         Student s3 = new Student("wangwu", 25, 95, 100, 30);
  31.         Student s4 = new Student("zhaoliu", 26, 60, 99, 70);
  32.         Student s5 = new Student("qianqi", 26, 70, 80, 70);
  33.         TreeSet<Student> st=new TreeSet<>();
  34.         st.add(s1);
  35.         st.add(s2);
  36.         st.add(s3);
  37.         st.add(s4);
  38.         st.add(s5);
  39.         for (Student student : st) {
  40.             System.out.println(student);
  41.         }
  43.     }
  44. }

  1. package lx2;
  2.  
  3. //第一种：默认排序/自然排序
  4. public class Student implements Comparable<Student> {
  5.     private String name;
  6.     private int age;
  7.     //语文成绩
  8.     private int chinese;
  9.     //数学成绩
  10.     private int math;
  11.     //英语成绩
  12.     private int english;
  13.  
  14.     public Student() {
  15.     }
  16.  
  17.     public Student(String name, int age, int chinese, int math, int english) {
  18.         this.name = name;
  19.         this.age = age;
  20.         this.chinese = chinese;
  21.         this.math = math;
  22.         this.english = english;
  23.     }
  24.  
  25.     /**
  26.      * 获取
  27.      *
  28.      * @return name
  29.      */
  30.     public String getName() {
  31.         return name;
  32.     }
  33.  
  34.     /**
  35.      * 设置
  36.      *
  37.      * @param name
  38.      */
  39.     public void setName(String name) {
  40.         this.name = name;
  41.     }
  42.  
  43.     /**
  44.      * 获取
  45.      *
  46.      * @return age
  47.      */
  48.     public int getAge() {
  49.         return age;
  50.     }
  51.  
  52.     /**
  53.      * 设置
  54.      *
  55.      * @param age
  56.      */
  57.     public void setAge(int age) {
  58.         this.age = age;
  59.     }
  60.  
  61.     /**
  62.      * 获取
  63.      *
  64.      * @return chinese
  65.      */
  66.     public int getChinese() {
  67.         return chinese;
  68.     }
  69.  
  70.     /**
  71.      * 设置
  72.      *
  73.      * @param chinese
  74.      */
  75.     public void setChinese(int chinese) {
  76.         this.chinese = chinese;
  77.     }
  78.  
  79.     /**
  80.      * 获取
  81.      *
  82.      * @return math
  83.      */
  84.     public int getMath() {
  85.         return math;
  86.     }
  87.  
  88.     /**
  89.      * 设置
  90.      *
  91.      * @param math
  92.      */
  93.     public void setMath(int math) {
  94.         this.math = math;
  95.     }
  96.  
  97.     /**
  98.      * 获取
  99.      *
  100.      * @return english
  101.      */
  102.     public int getEnglish() {
  103.         return english;
  104.     }
  105.  
  106.     /**
  107.      * 设置
  108.      *
  109.      * @param english
  110.      */
  111.     public void setEnglish(int english) {
  112.         this.english = english;
  113.     }
  114.  
  115.     public String toString() {
  116.         return "Student{name = " + name + ", age = " + age + ", chinese = " + chinese + ", math = " + math + ", english = " + english + "}";
  117.     }
  118.  
  119.     @Override
  120.     public int compareTo(Student o) {
  121.        /* 按照总分从高到低输出到控制台
  122.         如果总分一样，按照语文成绩排
  123.         如果语文一样，按照数学成绩排
  124.         如果数学成绩一样，按照英语成绩排
  125.         如果英文成绩一样，按照年龄排
  126.         如果年龄一样，按照姓名的字母顺序排
  127.         如果都一样，认为是同一个学生，不存。*/
  128.         int sum1 = this.getChinese() + this.getMath() + this.getEnglish();
  129.         int sum2=o.getChinese() + o.getMath() + o.getEnglish();
  130.         int tmp = sum2-sum1;
  131.         // 如果总分一样，按照语文成绩排
  132.         tmp = tmp == 0 ? this.getChinese() - o.getChinese() : tmp;
  133.         // 如果语文一样，按照数学成绩排
  134.         tmp = tmp == 0 ? this.getMath() - o.getMath() : tmp;
  135.         //如果数学成绩一样，按照英语成绩排
  136.         tmp = tmp == 0 ? this.getEnglish() - o.getEnglish() : tmp;
  137.         //如果英文成绩一样，按照年龄排
  138.         tmp = tmp == 0 ? this.getAge() - o.getAge() : tmp;
  139.         // 如果年龄一样，按照姓名的字母顺序排
  140.         tmp = tmp == 0 ? this.getName().compareTo(o.getName()) : tmp;
  141.  
  142.  
  143.         return tmp;
  144.     }
  145. }

TreeSet二种排序方式

  1. public class test {
  2.     public static void main(String[] args) {
  3.         TreeSet<String> ts = new TreeSet<>((o1, o2) -> o1.compareTo(o2));
  4.           ts.add("c");
  5.           ts.add("ab");
  6.           ts.add("df");
  7.           ts.add("qwer");
  8.         System.out.println(ts);//默认是通过Stirng排序方法,也就是说通过首字母排序的方法来的,不是根据长度来的
  9.     }
  10. }

 

如果使用默认的排序方法,则不能满足需求,可以使用第二种排序方法,并定义规矩进行重写

排序的原理图:



总结

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/973919
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号