集合进阶-----Collection单列：Set

最新推荐文章于 2025-06-10 17:46:18 发布
最新推荐文章于 2025-06-10 17:46:18 发布
阅读量169 收藏
点赞数
分类专栏： java 文章标签： java 蓝桥杯 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z2021_000000/article/details/124768531
版权 

Set集合特点：
package 集合进阶.Collection单列.Set;

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

/*
        Set集合特点：
            不包含重复元素集合
            无序输出
            没有带索引的方法，所以不能使用普通for遍历
 */
public class Set集合特点 {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<String>();
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");

        set.add("hello");

        //遍历
        for (String s : set) {
            System.out.println(s);
        }
    }
}


HashSet集合概述和特点：

package 集合进阶.Collection单列.Set;

import java.util.HashSet;

/*
        hashSet集合特点：
            底层数据结构是哈希表
            对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
            没有带索引的方法，不能用普通for遍历
            由于是Set集合，所以不包含重复元素的集合
 */
//存储字符串并遍历
public class HashSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<String>();
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        //遍历
        for (String s : hs){
            System.out.println(s);
        }
    }
}

 

 

TreeSet集合概述和特点：

 

package 集合进阶.Collection单列.Set;
/*
        TreeSet集合特点：
        1.元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序取决于构造方法
              TreeSet():根据其元素的自然排序进行排序
              TreeSet（Comparator comparator）：根据指定的比较器进行排序
        2.没有索引的方法，不能使用普通for遍历
        3.由于Set集合，所以不包含重复元素集合
 */
//存储整数并遍历
import java.util.TreeSet;

public class TreeSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        //  <>里面要用引用类型因为int为基本类型
        //他的引用类型为包装类integer
        TreeSet<Integer> ts = new TreeSet<Integer>();
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);
        //遍历集合
        for (Integer i :ts){
            System.out.println(i);
        }
    }
}

 

 

LinkedHashSet集合特点：
package 集合进阶.Collection单列.Set;

import java.util.LinkedHashSet;

/*
        LinkedHashSet集合特点：
            哈希表和链表实现的Set接口，具有可预测的迭代次序。
            由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
            由哈希表保证元素唯一，没有重复元素
 */
//存储字符串并遍历
public class LinkedHashSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> LinkedHashSet=new LinkedHashSet<String>();
        //添加元素
        LinkedHashSet.add("hello");
        LinkedHashSet.add("world");
        LinkedHashSet.add("java");

        LinkedHashSet.add("world");
        //遍历集合
        for (String s : LinkedHashSet){
            System.out.println(s);
        }
    }
}

 案例

不重复的随机数：
package 集合进阶.Collection单列.Set;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

/*
        需求：
        编写一个程序，获取10个1-20之间的随机数，要求不能重复

        思路：
        创建set集合对象
        创建随机数对象
        判断集合的长度小于10
                是，产生一个随机数，添加到集合
                重复
        遍历集合
 */
public class 不重复的随机数 {
    public static void main(String[] args) {

        //创建set集合对象
//        Set<Integer> set = new HashSet<Integer>();//无序

        Set<Integer> set = new TreeSet<Integer>();//有序
        //创建随机数对象
        Random rand = new Random();

        //判断集合的长度小于10
        while(set.size()<10){
            int number = rand.nextInt(20)+1;
            set.add(number);
        }

        //遍历集合
        for(Integer i : set){
            System.out.println(i);
        }

    }
}

 

哈希值：
package 集合进阶.Collection单列.Set.哈希值;

public class Student {
    String name;
    int age;

    public Student() {
    }

    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;
    }

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

/*
    @Override
    public int hashCode() {
        return 0;
    }*/
}

package 集合进阶.Collection单列.Set.哈希值;
/*
            哈希值：
                是JDK根据对象的地址或者字符串或数字算出来的int类型的数值

            Object类中有一个方法可以获取对象的哈希值
                public int hashCode（）：返回对象的哈希码值
 */

public class HashDemo {
    public static void main(String[] args) {

        //创建学生对象
        Student s1=new Student("程序员",20);

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

        Student s2 = new Student("架构师",30);

        //默认情况下，不同对象的哈希值是不同的
        //通过方法重写，可以实现不同对象的哈希值相同
        System.out.println(s2.hashCode());//2137211482

        //不同对象哈希值相同，说明字符串重写了hashCode（）方法
        System.out.println("hello".hashCode());//99162322
        System.out.println("world".hashCode());//113318802
        System.out.println("java".hashCode());//3254818

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

        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }

}

 

Comparable.自然排序：
package 集合进阶.Collection单列.Set.Comparable.自然排序;

public class Student implements Comparable<Student>{
    String name;
    int age;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public int compareTo(Student s) {
//        return 0;
//        return 1;
//        return -1;
        //按年龄大小排序
        int num=this.age-s.age;//从小到大
//        int num=s.age-this.age;//从大到小
        //年龄相同时，按照姓名的字母顺序排序
        int num2=num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

package 集合进阶.Collection单列.Set.Comparable.自然排序;

/*
        自然排序Comparable的使用
            存储学生对象并遍历，创建TreeSet集合使用无参构造方法
            要求：按年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
        结论：
            用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
            自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo(To)方法
            重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
 */

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts=new TreeSet<Student>();
        //创建学生对象
        Student s1=new Student("xishi",29);
        Student s2=new Student("wangzhaojun",28);
        Student s3=new Student("diaochan",30);
        Student s4=new Student("yangyuhuan",33);

        Student s5=new Student("linqingxia",33);
        Student s6=new Student("linqingxia",33);

        //添加学生对象到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历结合
        for (Student s : ts) {
            System.out.println(s.getName()+","+s.getAge());
        }

    }
}

 

Comparable.比较器：
package 集合进阶.Collection单列.Set.Comparable.比较器;

public class Student {
    String name;
    int age;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

package 集合进阶.Collection单列.Set.Comparable.比较器;
/*
        比较器Comparable的使用
            存储学生对象并遍历，创建TreeSet集合使用带参构造
            要求：按年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
        结论：
            用TreeSet集合存储自定义对象，有参构造方法使用的是比较器排序对元素进行排序的
            比较器排序，就是让集合构造方法接收Comparable的实现类对象，重写compare(To1，To2)方法
            重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
 */


import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //this.age-s.sge
                //s1,s2
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()) :num;
                return num2;
            }
        });

        //创建学生对象
        Student s1=new Student("xishi",29);
        Student s2=new Student("wangzhaojun",28);
        Student s3=new Student("diaochan",30);
        Student s4=new Student("yangyuhuan",33);

        Student s5=new Student("linqingxia",33);
        Student s6=new Student("linqingxia",33);
        //添加学生对象到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历结合
        for (Student s : ts) {
            System.out.println(s.getName()+","+s.getAge());
        }

    }
}

 

Collection-set
冬日的暖阳
02-06 228
1、set集合的概述 一个不包含重复元素的 collection。 案例演示：无需和唯一 public class MyTest { public static void main(String[] args) { HashSet<String> hashSet = new HashSet<>(); hashSet.add("张三...
Collection中的Set
qq_43515464的博客
10-24 283
Set接口是Collection的子接口，set接口没有提供额外的方法。但是比Collection接口更加严格了。 Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。 Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。 Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。 HashSet HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。 jav.
List与Set的区别，和Collection
YUEXINGZHONG的博客
09-11 2667
Collection,List,Set,Map Collection和list,Set的关系   在整个java类集中最常使用的类集接口有Collection、Set、List接口，注意以上都是接口。Collection是List和Set两个接口的基接口， List和Set的区别，List是有序的且可重复，但Set是无序的且不可重复。 注：（Set是因为不可重复，当放入两个相同的数值进入时
Collection中的set接口（集合）
nidiquge的博客
05-31 231
set没有提供除Collection接口中自带的其他方法。 set中不能添加相同元素，判断两个对象是否相等会调用equals()方法 Set中的实现类有HashSet、LinkedHashSet、TreeSet HashSet HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。 HashSet按照Hash（哈希）算法来储存元素，便于增删改查。 HashSet不保证元素的排列顺序，线程不安全，集合元素的值可以是null HashSet集合判断两个元素相等的标准：两个对象通过ha
Collection-set用法介绍
weixin_46103566的博客
08-02 714
Set 【特点】 Set是一个无序集合，既存入集合的顺序和取出的顺序不一致 Set集合中元素不重复 TreeSet 我们自定义类一个数据类型的时候(类),当需要对这个类对象进行排序,就需要我们自定义比较器用于比较。如果两种排序方式都有的话,优先使用compare()方法 想要让TreeSet集合中元素进行排序 有三种方式(实际两种): Comparator—>compare( ) Comparable------>compareTo( ) 1要添加的元素对应的类实现j
java进阶--Collection&泛型(IDEA版)
xiaohan0010的博客
03-03 715
本节目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ...
【进阶篇-Day9：JAVA中单列集合Collection、List、ArrayList、LinkedList的介绍】
Ma Sizhou
07-13 1059
注：集合分为单列集合和双列集合单列集合：一次添加一个元素，实现了Collection接口。双列集合：一次添加两个元素，实现了Map接口。2.2.2 增强for循环遍历：/*** 使用增强for循环遍历Student s1 = new Student("张三" , 11);//Student是自定义创建的类 Student s2 = new Student("李四" , 21);Student s3 = new Student("王五" , 31);
Java--集合进阶 Collection，迭代器，lambda表达式
2303_80261946的博客
09-09 575
Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到。boolean hasNext(): 判断当前位置是否有元素可以被取出。E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置。​ void remove(): 删除迭代器对象当前指向的元素。- 迭代器,集合的专用遍历方式。- Iterator中的常用方法。- 迭代器中删除的方法。- List集合的概述。- List集合的特点。
9 Java数据结构（中）：集合进阶之Collection(单列集合)：Collection、List接口（ArrayList、LinkedList实现类）、Set接口等、Collections工具类
smalltorch的博客
08-26 1133
前面已经学习过一些集合的基本知识：包装类、泛型，以及一个基本的集合ArrayList。本节我们将在前面的基础上面，更加系统的学习Java类里面集合这个概念。首先，第一步我们要弄明白Java里面的集合是个什么东西，我们要先从集合的体系结构开始学习。
Java集合进阶 单列集合collection和list
2302_80073130的博客
01-25 1893
Java当中一共有很多种集合之前学过的ArrayList只是其中的一类。Collection单列集合：添加一个元素Map双列集合：添加俩个元素。
Collections类 Set接口
qq_62574400的博客
05-22 295
java.utils.Collections是集合工具类，用来对集合进行操作 shuffle();将集合中的元素随机打乱 public static void main(String[]args){ List<Integer> list = new ArrayList<>(); // 往集合中添加⼀些元素 list.add(300); list.add(100); list...
Collection接口和Set接口对比与解析。
家乐的博客
08-05 4410
导语：越是接触更多新的知识，就发现旧的知识假若不扎实，便会影响到新的学习，在此重新回顾一下集合的概念。（小菜鸟写的，大神绕路。字有点多，加红的为重点。） 结尾处有对应Word文档下载，里面有简单的例子说明以上的知识点。 1. 集合 1.1. 什么是集合  存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式
Collection之Set
皮蛋小粥的博客
05-02 1611
Collection之List：点击打开链接同List集合一样，Set集合继承了了Collection接口。HashSet同TreeSet是我们经常使用的两个类。HashSet跟TreeSet都继承了 AbstractSet这个抽象类：但是TreeSet实现了SortedSet这个接口：所以TreeSet是有序的（因为它是一个红黑树的数据结构，是一种平衡二叉树（AVL树），下面会说到）HashSe...
Collection的集合体系 List、Set接口 及其实现类
我不是大王强的博客
07-08 1637
  /*    List接口是Collection下面的一个子接口。    List接口有以下特点： 1. 有序（有序不是顺序， 怎么存就怎么取） 2. 有索引。 3. 可以存放重复元素。   list接口下面常见的实现类。 ArrayList，LinkedList */public class Demo01list { public static void main(...
Java基础-Collection之Set的实现
Allin
08-08 2480
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-Collection体系： |–List——特点：元素有序（指的是元素的存入和取出的顺序一致），元素可重复 |–ArrayList——特点：底层是数组结构，查询快，增删慢；线程不同步，效率高 |–Vector——特点：底层是数组结构，查询快，增删慢；线程同步，效率低（基
Java学习笔记——Collection之Set
D77的博客
07-28 1176
Set接口常用的实现类有HashSet、LinkedHashSet、TreeSet。Set无序不可重复的集合，只能根据元素本身来访问。
collection接口之set接口
m0_60318777的博客
12-25 718
一：collection接口；单列集合，用来储存一个一个的对象 set接口：无序，不可重复--高中讲的集合 HashSet:作为set接口的主要实现类，线程不安全，可以储存null值 LinkedHashSet:作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历 优点：对于频繁的遍历操作，LinkedHashSet高于HashSet TreeSet:可以按照添加对象的指定属性进行排序 1.s.
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 57
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
优雅的系统重试
huangyujun9920123的博客
06-05 945
本文探讨了如何优雅实现方法重试机制。程序员A起初采用固定次数的循环重试方式，但发现多个接口存在重复代码。通过分析将重试框架与业务逻辑解耦，最终构建了可复用的重试策略类。该方案使用Supplier函数式接口接收业务逻辑，实现了：1) 统一的最大重试次数控制；2) 状态码判断；3) 异常处理。这种设计既消除了代码冗余，又通过lambda表达式灵活支持不同业务逻辑，为类似场景提供了可扩展的解决方案。
java黑马程序员集合进阶
02-10
### Java 高级集合进阶教程 #### Set 接口及其子类特性 Set接口是Java集合框架中的一个重要部分，它不允许存储重复元素。这使得`Set`非常适合用于去除重复项以及表示数学上的集合理论概念。 - **HashSet**: 实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

放码过来a

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值