集合——Set

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量78 收藏
点赞数 2
分类专栏： 集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxk1241/article/details/119714171
版权

Set

1. 特点

  • 元素存取无序

  • 没有索引，只能通过迭代器或增强for循环遍历

  • 不能存储重复的元素

  • 创建集合对象

    • Set<String> set = new HashSet<String>();

2. 哈希值

2.1 概述

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

2.2 获取哈希值

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

2.3 特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的
  • 可以通过重写hashCode()方法，实现不同的对象的哈希值相同
  • 在极少数的情况下，变量/对象的哈希码值会重复，称为"哈希碰撞"、“哈希冲突”，例如"重地"、"通话"的哈希码值就是相同的

2.4 代码示例

public class HashDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("哈哈哈", 12);

        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode()); //356573597
        System.out.println(s1.hashCode()); //356573597

        Student s2 = new Student("哈哈哈", 12);
        //默认情况下，不同对象调用hashCode()方法返回的哈希值是不同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        System.out.println(s2.hashCode()); //1735600054

        System.out.println("hello".hashCode()); //99162322
        System.out.println("world".hashCode()); //113318802

        //哈希碰撞 哈希冲突
        System.out.println("重地".hashCode()); //1179395
        System.out.println("通话".hashCode()); //1179395
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3. HashSet集合

3.1 特点

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

3.2 代码示例

3.2.1 基本使用
import java.util.HashSet;

public class Demo01 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<>();

        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        //这里添加一个重复的元素测试 set集合是否不包含重复元素
        hs.add("world");

        //利用增强for循环遍历集合
        for (String s : hs) {
            System.out.println(s);
        }
    }
}
/* 输出结果
world        从输出结果可以看出，集合的迭代顺序与存储顺序不一致
java         且不会出现重复的数据
hello
 */
3.2.2 存储学生对象并遍历<唯一性>
import java.util.HashSet;

//HashSet集合存储学生对象并遍历
/*
1.定义学生类
2.创建HashSet集合对象
3.创建学生类
4.添加学生对象
5.遍历 增强for
 */
public class Test01 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student> hs = new HashSet<>();

        Student s1 = new Student("哈哈哈", 12);
        Student s2 = new Student("嘻嘻嘻", 13);
        Student s3 = new Student("吼吼吼", 14);

        Student s4 = new Student("哈哈哈", 12);

        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        for (Student s : hs) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //如果这里不重写equals and hashCode 就不能保证学生对象的唯一性
    //学生对象变量值相同，我们就认为是同一个对象
    //快捷生成重写代码 Alt + Insert ---> equals() and hashCode()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

4. 哈希表

  • 本质时元素为链表的数组，默认初始容量为16

image-20210814174701374

  • 图解
    • 首先得到每个对象的哈希值，并取余
    • 取余得到的结果就是其对象的存放位置
    • "hello"的哈希值取余结果为2，所以存放至2的位置
    • "world"的哈希值取余结果也为2，在存放前先与"hello"进行比较（哈希值、内容），不相等就以链表的形式存入
    • 重复的元素不会存储

5. LinkedHashSet集合

5.1 特点

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

5.2 创建集合对象

LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

6 TreeSet集合

6.1 特点

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

6.2 创建集合对象

TreeSet<Integer> ts = new TreeSet<Integer>();

6.3 自然排序Comparable

6.3.1 代码示例
  • 测试类
import java.util.TreeSet;

/*存储学生对象并遍历，创建集合使用无参构造
  要求：按照年龄从小到大排序
        如果年龄想用，按姓名字母顺序排序*/
public class Test01 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>();

        Student s1 = new Student("hahaha", 12);
        Student s2 = new Student("xixixi", 15);
        Student s3 = new Student("houhouhou", 13);

        Student s4 = new Student("aoligei", 15);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge()); //ClassCastException
        }
    }
}
  • 学生类
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student s) {
        // return 0;
        // return 1;  升序
        // return -1; 降序
        //按照年龄从小到大排序

        /*
        首先输入的是s1
        然后再输入s2，s2需要与s1比较
        this.age代表的就是s2,
        s.age代表的就是s1  依此类推
         */
        //int num = this.age - s.age; 谁在要在前面，就把谁写在减号左边
        int num = this.age - s.age;

        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

6.4 比较器排序Comparator

6.4.1 代码示例
  • 测试类
import java.util.Comparator;
import java.util.TreeSet;

public class Test01 {
    public static void main(String[] args) {
        //匿名内部类
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            //s1写在减号左边，就是升序 s2写在减号左边 就是降序
            public int compare(Student s1, Student s2) {
                int num = s1.getAge()-s2.getAge();
                int num2 = num == 0? s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });

        Student s1 = new Student("hahaha", 12);
        Student s2 = new Student("xixixi", 15);
        Student s3 = new Student("houhouhou", 13);

        Student s4 = new Student("aoligei", 15);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}
  • 学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

7. 案例

7.1 成绩排序

  • 测试类
import java.util.Comparator;
import java.util.TreeSet;

//成绩排序
/*
1. 定义学生类
2. 创建TreeSet集合对象，通过比较器排序进行排序
3. 创建学生对象
4. 将学生对象添加到集合
5. 遍历集合
 */
public class Test {
    public static void main(String[] args) {
        // TreeSet有参构造  比较器排序 匿名内部类
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            /*@Override  //降序
            public int compare(Student s1, Student s2) {
                int num = s2.getsum() - s1.getsum(); //判断总分排序
                //如果总分相等
                int num2 = num == 0 ? s2.getMath() - s1.getMath() : num; //判断数学成绩排序
                //如果数学成绩也相等，那么说明成绩完全相同，按照姓名字母排序
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) :num2;

                return num3;*/
            @Override
            public int compare(Student s1, Student s2) {
                //说明： 当s1在前面 则代表升序  当s2在前面 则代表降序
                int num = s1.getsum() - s2.getsum(); //判断总分排序
                //如果总分相等
                int num2 = num == 0 ? s1.getMath() - s2.getMath() : num; //判断数学成绩排序
                //如果数学成绩也相等，那么说明成绩完全相同，按照姓名字母排序
                int num3 = num2 == 0 ? s2.getName().compareTo(s1.getName()) :num2;

                return num3;
            }
        });


        Student s1 = new Student("张三", 96, 95);
        Student s2 = new Student("李四", 93, 95);
        Student s3 = new Student("王五", 96, 95);
        Student s4 = new Student("赵六", 96, 93);
        Student s5 = new Student("胡七", 88, 93);
        Student s6 = new Student("何八", 93, 88);



        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        System.out.println("姓名 \t数学成绩 \t语文成绩 \t总分");
        for (Student s : ts) {
            System.out.println(s.getName() + "\t\t" + s.getMath() + "\t\t\t" + s.getChinese() + "\t\t\t"  + s.getsum());
        }
    }
}
  • 学生类
public class Student {
    private String name;
    private int math;
    private int chinese;

    public Student() {
    }

    public Student(String name, int math, int chinese) {
        this.name = name;
        this.math = math;
        this.chinese = chinese;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getsum(){
        return this.chinese + this.math;
    }
}

7.2 不重复的随机数

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

//不重复的随机数
/*
1.创建Set集合对象
2.创建随机数对象
3.判断集合的长度是不是小于10
    是：产生一个随机数，添加到集合
    回到3继续
4.遍历集合
 */
public class test {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<Integer>();
        //生成一个随机数
        Random r = new Random();
        //判断集合长度是不是小于1
        while(set.size()<10){
            //nextInt 默认取值范围[0,20)
            int number = r.nextInt(20) + 1;
            set.add(number);
        }

        for (Integer i : set) {
            System.out.println(i);
        }
    }
}
wxk1241
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合——Set
L04593的博客
08-09 7万+
集合——Set Set接口 特点：无序且不可重复 实现类： HashSet LinkedHashSet TreeSet 1.LikedHashSet 1.1 常用方法： package com.study.linkedhashset; import java.util.LinkedHashSet; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; public class Test0
java 有序不重复_Java中自定义有序不重复的集合——SetList
weixin_28863779的博客
02-13 2397
由于课程设计的需要，笔者需要将数据库中的某个表的数据拿出来处理例如楼层和建筑表，有外键限制一开始是使用List保存的，但实际操作中发现，从表中取出来楼层数据中的建筑有些是重复的List接口实现的存储是有序可重复的，Set接口是无序不重复的，不能用下标定位数据结合他们之间的优缺点和数据量，在不考虑性能的情况下，笔者写了有序不重复的集合总体是基于LinkedList实现的，重写其add方法List为空...
Java集合——Set
qq_51553982的博客
04-16 548
Java集合——SetSet案例 Set 无重复元素，无序，随机 Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 案例 package set; import org.w3c.dom.ls.LSOutput; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class demo1 { public static void main(String[] arg
Java集合——Set详解
热门推荐
阿Q的小窝
02-27 5万+
前几天简单介绍了一下单列集合中的List，今天就给大家讲一下它的同胞兄弟Set的简介与使用情况。 Set存取无序，元素唯一 代码演示： public static void demo1() { HashSet&lt;String&gt; hs = new HashSet&lt;&gt;(); //创建HashSet对象 boolean b1 = hs.add("a"); b...
c++ STL 之集合—— set 详解
zhhg0123的博客
03-24 2058
set是 stl 的一个关联容器,名叫“集合”，何为“集合”？其实就是一个数组，但有了数组何必还需集合？
java——集合——Set集合——Set集合存储元素不重复的原理
小白龙白龙马的博客
11-19 185
java——集合——Set集合——LinkedHashSet集合
小白龙白龙马的博客
11-19 153
LinkedHashSet集合 java.util.LinkedHashSet集合 extends HashSet集合 LinkedHashSet集合特点:底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序 public classDemo04LinkedHashSet { public static void main(Stri...
java——集合——Set集合——HashSet集合存储数据的结构（哈希表）
小白龙白龙马的博客
11-19 140
java集合——set的线程安全
HD243608836的博客
03-04 7170
转载自：https://blog.csdn.net/l153097889/article/details/77891250 使用Guava构建ConcurrentHashSet 谷歌的guava其实已经实现了线程安全的ConcurrentHashSet， Set&lt;String&gt; s = Sets.newConcurrentHashSet(); public sta...
Kotlin 基础——Set集合详解
一名互联网时代苟且偷生的 Android码农
04-14 5196
Kotlin基础——Set集合详解一、声明和创建二、使用Set的方法三、遍历Set四、可变的Set4.1、添加元素4.2、删除元素 Kotlin的集合类由两个接口派生：Collection和Map。 Kotlin的集合分为两大类：可变集合和不可变集合。只有可变集合才能添加、删除、修改元素，不可变集合只能读取元素。 Kotlin的Collection集合和Set集合的功能基本相同，Set集合只是为C...
【后端】java基础（4.3）java中级基础之集合——Set
03-29
java似乎早就想好了给我们提供了集合（Collection）.我们今天要讲的是Collection的子类——List. List又有三个实现类： ArrayList LinkedList Vector 这三个都是list，至于什么是子类，我们会在对象那章去普及。他们...
Java学习|集合（三）——set
01-06
文章目录Set常用方法介绍HashSet元素顺序底层算法TreeSet![在这里插入图片描述](https://img-blog.csdnimg.cn/20200217154420892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0...
浅谈Python 集合(set)类型的操作——并交差
09-21
下面小编就为大家带来一篇浅谈Python 集合(set)类型的操作——并交差。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
python开发入门——set的使用
01-21
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。 set 持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1091
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 768
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 740
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1311
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
Java集合框架深度解析：Map、Set、List源码探秘
"这份PDF文档详细解析了Java编程中常见的集合框架——Map、Set、List的底层实现原理，并结合数据结构的基础知识，特别是树的概念，进行了深入的探讨。文档内容包括Map底层原理分析、LinkedList和ArrayList的原理分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值