• Java—Set

    目录

    3. Set

    3.1Set集合概述和特点

    3.2 哈希值

    3.3常见数据结构之哈希表

    案例:HashSet集合存储学生对象并遍历

    3.4LinkedHashSet集合概述和特点

    3.5TreeSet集合概述和特点

    3.6自然排序Comparable的使用

    3.7比较器排序Comparator的使用

    3. Set

    3.1Set集合概述和特点

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

    HashSet对集合的迭代顺序不做保证

    1. package zyy07;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) {
    8.         //创建集合对象
    9.         Set s=new HashSet<>();
    10.         //添加元素
    11.         s.add("zyy");
    12.         s.add("and");
    13.         s.add("jw");
    14.         s.add("zyy");
    15.         for(String s1: s){
    16.             System.out.println(s1);
    17.         }
    18.     }
    19. }

    3.2 哈希值

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

    Object类中有一个方法可以获取对象的哈希值
            public int hashCode():返回对象的哈希码值

    对象的哈希值特点
            同一个对象多次调用hashCode)方法返回的哈希值是相同的
            默认情况下，不同对象的哈希值是不同的。而重写hashCode0方法，可以实现让不同对象的哈希值相后

    1. package zyy07;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) {
    8.         //创建集合对象
    9.         HashSet h=new HashSet<>();
    10.         h.add("zyy");
    11.         h.add("and");
    12.         h.add("kiki");
    13.         for(String s: h){
    14.             System.out.println(s);
    15.         }
    16.     }
    17. }

    3.3常见数据结构之哈希表

                    重复元素不存储

    案例:HashSet集合存储学生对象并遍历

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

    思路:

            定义学生类
            创建HashSet集合对象

            创建学生对象
            把学生添加到集合

            遍历集合(增强for)
            在学生类中重写两个方法
                    hashCode()和equals()自动生成即可

    学生类：

    1. package com.test;
    2.  
    3. public class student {
    4.     //成员变量
    5.     private String name;
    6.     private int age;
    7.  
    8.     //构造方法
    9.     public student(){
    10.     }
    11.     public student(String name,int age){
    12.         this.name=name;
    13.         this.age=age;
    14.     }
    15.  
    16.     //成员方法
    17.     public void setName(String name){
    18.         this.name=name;
    19.     }
    20.     public String getName(){
    21.         return name;
    22.     }
    23.     public void setAge(int age){
    24.         this.age=age;
    25.     }
    26.     public int getAge(){
    27.         return age;
    28.     }
    29.     //为了保证元素的唯一性要重写equals和hashcode两个方法
    30.     @Override
    31.     public boolean equals(Object o) {
    32.         if (this == o) return true;
    33.         if (o == null || getClass() != o.getClass()) return false;
    34.  
    35.         student student = (student) o;
    36.  
    37.         if (age != student.age) return false;
    38.         return name != null ? name.equals(student.name) : student.name == null;
    39.     }
    40.  
    41.     @Override
    42.     public int hashCode() {
    43.         int result = name != null ? name.hashCode() : 0;
    44.         result = 31 * result + age;
    45.         return result;
    46.     }
    47. }

    测试类：

    1. package com.test;
    2.  
    3. import java.util.HashSet;
    4.  
    5. public class studentdemo {
    6.     public static void main(String[] args) {
    7.         //创建对象
    8.         HashSet a=new HashSet<>();
    9.         //创建学生对象
    10.         student s1=new student("zyy",14);
    11.         student s2=new student("jwei",18);
    12.         student s3=new student("hwj",14);
    13.         student s4=new student("hwj",14);
    14.         //把学生添加到集合
    15.         a.add(s1);
    16.         a.add(s2);
    17.         a.add(s3);
    18.         a.add(s4);
    19.         //增强for
    20.         for(student s: a){
    21.             System.out.println(s.getName()+","+s.getAge());
    22.         }
    23.     }
    24. }

    3.4LinkedHashSet集合概述和特点

    LinkedHashSet集合特点
            哈希表和链表实现的Set接口，具有可预测的迭代次序
            由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

            由哈希表保证元素唯一，也就是说没有重复的元素

    LinkedHashSet集合练习
            存储字符串并遍历

    1. package zyy07;
    2.  
    3. import java.util.LinkedHashSet;
    4.  
    5. public class Demo {
    6.     public static void main(String[] args) {
    7.         //创建集合对象
    8.         LinkedHashSet h=new LinkedHashSet<>();
    9.         //添加元素
    10.         h.add("zyy");
    11.         h.add("and");
    12.         h.add("kiki");
    13.         h.add("kiki");
    14.         //遍历集合
    15.         for(String s: h){
    16.             System.out.println(s);
    17.         }
    18.     }
    19. }

    3.5TreeSet集合概述和特点

    TreeSet集合特点
            1、元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
                    TreeSet):根据其元素的自然排序进行排序
                    TreeSet(Comparatorcomparator):根据指定的比较器进行排序

           2、 没有带索引的方法，所以不能使用普通for循环谝历

           3、由于是Set集合，所以不包含重复元素的集合

    TreeSet集合练习
            存储整数并遍历

    1. package zyy07;
    2.  
    3.  
    4. import java.util.TreeSet;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) {
    8.         //创建集合对象
    9.         TreeSet h=new TreeSet<>();
    10.         //添加元素
    11.         h.add(12);
    12.         h.add(11);
    13.         h.add(16);
    14.         h.add(14);
    15.         h.add(14);
    16.         //遍历集合
    17.         for(Integer s: h){
    18.             System.out.println(s);
    19.         }
    20.     }
    21. }

    3.6自然排序Comparable的使用

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

    结论
            用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

            自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(To)方法

            重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

    学生类：

    1. package com.test;
    2.  
    3. public class student implements Comparable {
    4.     //成员变量
    5.     private String name;
    6.     private int age;
    7.  
    8.     //构造方法
    9.     public student(){
    10.     }
    11.     public student(String name,int age){
    12.         this.name=name;
    13.         this.age=age;
    14.     }
    15.  
    16.     //成员方法
    17.     public void setName(String name){
    18.         this.name=name;
    19.     }
    20.     public String getName(){
    21.         return name;
    22.     }
    23.     public void setAge(int age){
    24.         this.age=age;
    25.     }
    26.     public int getAge(){
    27.         return age;
    28.     }
    29.  
    30.     @Override
    31.     public int compareTo(student o) {
    32.         //return 0;返回0认为相同元素，所以不添加
    33.         //return 1;返回正数按升序存储
    34.         //return -1;返回复数按降序存储
    35.         int num= this.age-o.age;//升序
    36.         //int num1=o.age-this.age;//降序
    37.         int num2=num==0?this.name.compareTo(o.name):num;
    38.         return num2;
    39.     }
    40. }

    测试类：

    1. package com.test;
    2.  
    3.  
    4. import java.util.TreeSet;
    5.  
    6. public class studentdemo {
    7.     public static void main(String[] args) {
    8.         //创建对象
    9.         TreeSet a=new TreeSet<>();
    10.         //创建学生对象
    11.         student s1=new student("zyy",14);
    12.         student s2=new student("jwei",18);
    13.         student s3=new student("hwj",13);
    14.         student s4=new student("kiki",12);
    15.         //把学生添加到集合
    16.         a.add(s1);
    17.         a.add(s2);
    18.         a.add(s3);
    19.         a.add(s4);
    20.         //增强for
    21.         for(student s: a){
    22.             System.out.println(s.getName()+","+s.getAge());
    23.         }
    24.     }
    25. }

    3.7比较器排序Comparator的使用

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

    结论
            用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
            比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(To1To2)方法

            重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

    学生类：

    1. package com.test;
    2.  
    3. public class student implements Comparable {
    4.     //成员变量
    5.     private String name;
    6.     private int age;
    7.  
    8.     //构造方法
    9.     public student(){
    10.     }
    11.     public student(String name,int age){
    12.         this.name=name;
    13.         this.age=age;
    14.     }
    15.  
    16.     //成员方法
    17.     public void setName(String name){
    18.         this.name=name;
    19.     }
    20.     public String getName(){
    21.         return name;
    22.     }
    23.     public void setAge(int age){
    24.         this.age=age;
    25.     }
    26.     public int getAge(){
    27.         return age;
    28.     }
    29.  
    30.     @Override
    31.     public int compareTo(student o) {
    32.         //return 0;返回0认为相同元素，所以不添加
    33.         //return 1;返回正数按升序存储
    34.         //return -1;返回复数按降序存储
    35.         int num= this.age-o.age;//升序
    36.         //int num1=o.age-this.age;//降序
    37.         int num2=num==0?this.name.compareTo(o.name):num;
    38.         return num2;
    39.     }
    40. }

    测试类：

    1. package com.test;
    2.  
    3.  
    4. import java.util.Comparator;
    5. import java.util.TreeSet;
    6.  
    7. public class studentdemo {
    8.     public static void main(String[] args) {
    9.         //创建对象
    10.         TreeSet a=new TreeSet(new Comparator() {
    11.             @Override
    12.             public int compare(student o1, student o2) {
    13.                 int num=o1.getAge()-o2.getAge();
    14.                 int num2=num==0?o1.getName().compareTo(o2.getName()):num;
    15.                 return num2;
    16.             }
    17.         });
    18.         //创建学生对象
    19.         student s1=new student("zyy",14);
    20.         student s2=new student("jwei",18);
    21.         student s3=new student("hwj",13);
    22.         student s4=new student("kiki",12);
    23.         //把学生添加到集合
    24.         a.add(s1);
    25.         a.add(s2);
    26.         a.add(s3);
    27.         a.add(s4);
    28.         //增强for
    29.         for(student s: a){
    30.             System.out.println(s.getName()+","+s.getAge());
    31.         }
    32.     }
    33. }
  • 相关阅读:
    datepicker设置中文
    计算二叉树的最大宽度
    10.1select并发服务器以及客户端
    【数字实验室】在时序逻辑中使用阻塞赋值会怎么样？
    c# 反射专题—————— 介绍一下是什么是反射[ 一]
    C++ 34 之 单例模式
    3D激光SLAM：ALOAM---后端lasermapping 里程计到地图位姿更新维护
    计算机毕业设计 基于微信小程序的学习资料销售平台的设计与实现 Java实战项目 附源码+文档+视频讲解
    6 循环和迭代
    程序员的成长之路——道和术的思考
  • 原文地址：https://blog.csdn.net/qq_62799214/article/details/126186212