Java集合：Set集合的使用

最新推荐文章于 2024-07-12 15:30:09 发布
最新推荐文章于 2024-07-12 15:30:09 发布
阅读量3.8k 收藏 16
点赞数 6
分类专栏： Java学习进阶 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59212867/article/details/125340499
版权

先看集合框架图：

Set有HashSet和TreeSet两种实现类。

先看Set：

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法

增、删、遍历、判断与collection一致

看代码：

package com.collections.set;

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

/**
 * set的使用
 * 特点：（1）无序（2）不能重复
 * @author 华子
 */
public class Demo01 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
//        添加
        set.add("小米");
        set.add("苹果");
        set.add("华为");
        set.add("华为");
        System.out.println(set.size());
        System.out.println(set.toString());
//        删除
//        set.remove("苹果");
//        System.out.println("删除后:"+set.size());
//        System.out.println(set.toString());
//        遍历
//       增强for
        for (String s :set
             ) {
            System.out.println(s);
        }
        System.out.println("------------------------");
//        迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("------------------------");
        for (String s :set) {
            System.out.println(s);
        }
//        判断
        System.out.println(set.contains("华为"));
        System.out.println(set.isEmpty());
    }
}

和之间的集合使用方法类似。

HasSet【重点】

存储结构：哈希表（数组+链表+红黑树）

存储过程（重复依据）

  1. 根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
  2. 再执行equals方法，如果equals为true，则认为是重复，否则形成链表

特点

存储过程：

  • 基于HashCode计算元素存放位置
    • 利用31这个质数，减少散列冲突
      • 31提高执行效率 31 * i = (i << 5) - i 转为移位操作
    • 当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入

新建集合 HashSet<String> hashSet = new HashSet<String>();

添加元素 hashSet.add( );

删除元素 hashSet.remove( );

遍历操作

​ 1. 增强for for( type type : hashSet)

​ 2. 迭代器 Iterator<String> it = hashSet.iterator( );

判断 hashSet.contains( ); hashSet.isEmpty();

先看HashSet的使用：

    package com.collections.set;

    import java.util.HashSet;
    import java.util.Iterator;

    /**
     * HashSet的使用
     * 存储结构：哈希表（数组+链表+红黑树）
     * @author 华子
     */
    public class Demo02 {
        public static void main(String[] args) {
            HashSet<String> hashSet = new HashSet<>();
    //        1.添加元素
            hashSet.add("刘德华");
            hashSet.add("郭富城");
            hashSet.add("张学友");
            hashSet.add("黎明");
            System.out.println("元素个数为："+hashSet.size());
            System.out.println(hashSet.toString());
    //        删除元素
    //        hashSet.remove("刘德华");
    //        System.out.println("删除后："+hashSet.size());
    //        System.out.println(hashSet.toString());

    //        遍历元素
    //       增强for
            for (String s :hashSet
            ) {
                System.out.println(s);
            }
            System.out.println("------------------------");
    //        迭代器
            Iterator<String> iterator = hashSet.iterator();
            while (iterator.hasNext()){
                String s = iterator.next();
                System.out.println(s);
            }

        }
    }

 还是差不多。

再来看HashSet存储Person类：

package com.collections.set;

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 存储过程：
 * （1）根据hashCode值计算保存的位置，如果为空，直接保存，如果不为空，则进入第二步
 * （2）执行equals，如果为true，则判断为重复，否则，形成链表
 * @author 华子
 */
public class Demo03 {
    public static void main(String[] args) {
        HashSet<Person> hashSet = new HashSet<>();
        Person p1 = new Person("刘德华",20);
        Person p2 = new Person("郭富城",21);
        Person p3 = new Person("张学友",22);
        Person p4 = new Person("黎明",23);
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        hashSet.add(p4);
        hashSet.add(new Person("刘德华",20));
        System.out.println("元素个数为："+hashSet.size());
        System.out.println(hashSet.toString());
//        删除
//        hashSet.remove(new Person("刘德华",20));
//        System.out.println("元素个数为："+hashSet.size());
//        System.out.println(hashSet.toString());

//        遍历元素
//       增强for
        for (Person p :hashSet
        ) {
            System.out.println(p);
        }
        System.out.println("------------------------");
//        迭代器
        Iterator<Person> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            Person p = iterator.next();
            System.out.println(p);
        }
    }
}

Person类：

package com.collections.set;

import java.util.Objects;

/**
 * 人类
 * @author 华子
 * 实现Comparable接口
 */
public class Person implements Comparable<Person>{
    private String name;
    private  int age;

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
//  重写了比较方法，先按姓名比，再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.getAge() - o.getAge();
        return n1==0?n2:n1;
    }
}

由于存储方式是先看HashCode计算位置，那个位置不为空，才进行equal，

我们再Person类中重写hasCode和equal方法：

使得它的haCode的是通过name和age生成，且equal比较的是属性。

这样就可以实现相同属性无法添加了、可以通过属性相同进行删除

 

运行结果：

 

可见HashSet的存储方式。

TreeSet：

特点

  • 基于排列顺序实现元素不重复
  • 实现SortedSet接口，对集合元素自动排序
  • 元素对象的类型必须实现Comparable接口，指定排序规则
  • 通过CompareTo方法确定是否为重复元素

存储结构：红黑树

创建集合 TreeSet<String> treeSet = new TreeSet<>()

添加元素 treeSet.add();

删除元素 treeSet.remove();

遍历 1. 增强for 2. 迭代器

判断 treeSet.contains();

补充：TreeSet集合的使用

Comparator 实现定制比较（比较器）

Comparable 可比较的

TreeSet的使用：

package com.collections.set;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * TreeSet的使用
 * @author 华子
 *
 */
public class Demo04 {
    public static void main(String[] args) {
//        创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("xxx");
        treeSet.add("yyy");
        treeSet.add("zzz");
        treeSet.add("xxx");
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
//        删除
//        treeSet.remove("xxx");
//        System.out.println("删除之后："+treeSet.size());
//        遍历
//        增强for循环
        for (String s:treeSet) {
            System.out.println(s);
        }
        System.out.println("----------------------------");
//        使用迭代器
        Iterator<String> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
    }
}

和其他集合方法使用类似。 

TreeSet存储Person类：

因为TreeSet存储的元素对象的类型必须实现Comparable接口，指定排序规则，而Peron中的对象没有固定的属性方法，所以Person要实现Comparable接口并重写compareTo方法。

Person类：

package com.collections.set;

import java.util.Objects;

/**
 * 人类
 * @author 华子
 * 实现Comparable接口
 */
public class Person implements Comparable<Person>{
    private String name;
    private  int age;

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
//  重写了比较方法，先按姓名比，再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.getAge() - o.getAge();
        return n1==0?n2:n1;
    }
}

 

 

 

这样就可以进行元素存储了（排序方式先比姓名，再比年龄）：

package com.collections.set;

import java.util.TreeSet;

/**
 * TreeSet存储Peron类
 * 存储结构：红黑树
 * 要求：元素必须实现Comparable接口，compareTo返回值为0，则确认为重复
 * @author 华子
 */
public class Demo05 {
    public static void main(String[] args) {
        TreeSet<Person> treeSet = new TreeSet<>();
        Person p1 = new Person("aaa",18);
        Person p2 = new Person("bbb",19);
        Person p3 = new Person("ccc",20);
        Person p4 = new Person("ddd",21);
        Person p5 = new Person("ddd",22);
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        treeSet.add(p5);
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());

    }
}

运行结果：

 

还可以用Comparator 定制比较器（使用匿名内部类）：

直接再匿名内部类里重写比较方法：

package com.collections.set;

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

/**
 * @author 华子
 * TreeSet的使用
 * Comparator 定制比较（比较器） 使用匿名内部类
 * Comparable，可比较的
 */
public class Demo06 {
    public static void main(String[] args) {
        TreeSet<Person> treeSet = new TreeSet(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                int n1 = p1.getAge() - p2.getAge();
                int n2 = p1.getName().compareTo(p2.getName());
                return n1==0?n2:n1;
            }
        });
        Person p1 = new Person("aaa",18);
        Person p2 = new Person("bbb",19);
        Person p3 = new Person("ccc",20);
        Person p4 = new Person("ddd",21);
        Person p5 = new Person("eee",21);
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        treeSet.add(p5);
        System.out.println(treeSet.toString());

    }
}

运行结果：

这样也可以添加元素。 

TreeSet案例：

使用TreeSet实现字符串按长度排序：hello world zhangsan lisi wangwu xian najing 

package com.collections.set;

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

/**
 * TreeSet案例：使用TreeSet实现字符串按长度排序
 * hello world zhangsan lisi wangwu xian najing
 * @author 华子
 *
 */
public class Demo07 {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length()- o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        treeSet.add("hello world");
        treeSet.add("zhangsan");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("xian");
        treeSet.add("najing");
        System.out.println(treeSet.toString());
    }
}

运行结果：

 

 

 

 

 

 

 

 

 

 

芝麻干
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java实现Redis的集合(set)命令操作
08-18
Java实现Redis的集合(set)命令操作是指在Java语言中使用Redis客户端来操作Redis数据库中的集合类型数据结构。Redis是当前使用最广泛的NoSQL数据库之一，集合类型是Redis中的一种常用的数据结构。集合类型可以用来...
java中的Set集合详解
m0_53222768的博客
08-29 1万+
原文之部分某处有争论，读者谨慎阅读，后期本人再进行本文内容修正 1.简介 Set集合中的元素是无序的且不可重复， 如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入。 2.HasheSet底层数据结构 HashSet底层数据结构是哈希表，因此具有很好的存取和查找性能。 哈希表：一个元素为链表的数组，综合了链表（存储速度快）和数组（查询速度快）的优点。 3.哈希表的存取原理 3.1 调用对象的hashCode()方法，获得要存储元素的哈希值。
Java常用集合之Set
m0_62609939的博客
03-27 3333
Java常用集合之Set
Java中的Set系列集合超详解
最新发布
weixin_65752158的博客
07-12 1208
底层数据结构是哈希表存取无序不可以存储重复元素没有索引,不能使用普通for循环遍历底层数据结构是哈希表存取无序不可以存储重复元素没有索引,不能使用普通for循环遍历。
Java Set集合详解
qq_51751452的博客
11-22 2万+
一：set集合框架体系图 二：set集合介绍 Set接口继承了Collection接口,含有许多常用的方法。 int size();返回集合的长度 boolean isEmpty();判断集合是否为空 boolean contains(Object o);是否包含某个值 boolean add(E e);添加元素 boolean remove(Object o);删除元素 Set接口的存储特点是无序不可重复，可以存放唯一一个null值，Set的常用实现类有HashSet，TreeSet。 Set集合的
Java中set集合的使用
凯耐的博客
08-22 2716
(一).Set集合 1.添加到容器中的元素不能重复，就算重复只按一个元素算！ 2.Set集合继承Collection接口，方法全部来自Collection接口，自身没有定义其他方法。 3.Set接口主要两个实现类为HashSet、TreeSet。 4.Set集合中的元素不按特定顺序排序。因此我们无法向list一样根据索引获取数据。 (二).HashSet集合的使用 - 1.存取Hash...
Java集合-Set
刘程云的博客
12-02 2242
java.util.Set接口和java.util.List接口一样，同样继承Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格，与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Java中的Set集合简单汇总解析
08-25
Java中的Set集合简单汇总解析 Set接口简介： Set接口是Java集合框架中的一个重要接口，它继承自Collection接口，并没有对Collection接口进行功能上的扩充。Set接口的主要特点是元素无序，并且都会以某种规则保证...
Java-Java集合体系-List-Set
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
Java基础篇：Java集合.pdf
04-24
该文档主要详细总结了Java集合的相关知识，包括Collection和Map接口、Collection接口的子接口List和Set接口以及具体的实现类、存储原理等；Map接口的子接口HashMap、LinkedHashMap、TreeMap、Properties等
Java集合Set、List、Map的遍历方法
09-04
首先，我们来看Set集合。Set接口代表不包含重复元素的集合，它的遍历方法主要有两种： 1. 利用`Iterator`接口：这是所有集合通用的遍历方式，通过调用`iterator()`方法获取迭代器，然后使用`hasNext()`和`next()`...
Java集合Set用法总结
别说话写代码的博客
08-17 5702
本文转自：https://www.jianshu.com/p/b48c47a42916 Set继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashSet和TreeSet两大实现类。在判断重复元素的时候，Set集合会调用hashCode()和equal()方法来实现。 HashSet是哈希表结构，主要利用HashMap的key来存储元素，计算插入元素的hashCode来获取元素在集合中的位置； TreeSet是红黑树结构，每一个元素都是树中的一个节点，插入的元素都会进
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...
Java Set＜String＞ 的基础用法
博客
01-04 9651
Java Set<String> 的基础用法
Java--set集合的几种常用方法
weixin_64224337的博客
01-25 1494
add(E e): 将指定的元素添加到Set集合中。如果元素已经存在，则不进行添加，返回false；否则添加成功，返回true。
【Java】Set 集合概述与使用
yao_yaoya的博客
11-28 1766
基于HashCode实现元素不重复，当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。基于排列顺序实现元素不重复。实现了SortedSet接口，对集合元素自动排列。
Java基础之Set
qq_45344586的博客
04-06 9632
Java基础之Set
java常用集合之Set
weixin_64938628的博客
06-30 3764
目录Set集合的基础知识Set集合的实现类一.HashSet二.TreeSet 特点：1.无序性：set集合是无序的2.不重复：set集合是不可以重复的遍历方法：foreach，迭代器扩容： 初始容量16，负载因子0.75，扩容增量1倍Set和List一样属于接口，无法直接创建实例化对象，需要实现类来set接口。关系图HashSet实现Set接口，底层由HashMap来实现，为哈希表结构，新增元素相当于HashMap的key，value默认为一个固定的Object。当有元素插入的时候，会计算元素的hashC
【Java 基础篇】Java Set 集合详解：轻松管理不重复元素
繁依Fanyi的博客
09-12 1407
Set是 Java 集合框架中的一部分，它代表了一个不重复元素的集合。这意味着Set不允许包含重复的元素，每个元素在集合中都是唯一的。Set集合通常用于存储无序的、不重复的对象，例如一组唯一的整数或字符串。Set集合是 Java 中一种非常有用的数据结构，用于存储不重复的元素。本博客介绍了Set集合的基本概念、创建和初始化、基本操作、遍历、不同实现类、性能考虑、使用注意事项、高级用法以及示例代码。希望通过本文的介绍，您对Set集合有了更深入的了解，并能够在实际编程中灵活运用。
java中set集合用法
05-12
在Java中，Set是一种集合类型，它不允许重复元素，并且没有固定的顺序。常见的Set实现类有HashSet、LinkedHashSet和TreeSet。下面是Set的用法示例： 1. 创建Set对象 可以使用以下语法创建Set对象： ```java Set<T> set = new HashSet<>(); // 创建HashSet对象 Set<T> set = new LinkedHashSet<>(); // 创建LinkedHashSet对象 Set<T> set = new TreeSet<>(); // 创建TreeSet对象 ``` 其中，T表示元素的类型。 2. 添加元素 可以使用add()方法向Set中添加元素： ```java set.add(element); // 将元素添加到Set中，如果Set中已经存在该元素，add()方法不会执行任何操作 ``` 3. 删除元素 可以使用remove()方法从Set中删除元素： ```java set.remove(element); // 从Set中删除指定元素，如果Set中不存在该元素，remove()方法不会执行任何操作 ``` 4. 判断元素是否存在 可以使用contains()方法判断Set中是否存在指定元素： ```java set.contains(element); // 如果Set中存在该元素，返回true；否则返回false ``` 5. 遍历元素 可以使用foreach循环或者迭代器遍历Set中的元素： ```java for (T element : set) { // 对元素进行操作 } Iterator<T> iterator = set.iterator(); while (iterator.hasNext()) { T element = iterator.next(); // 对元素进行操作 } ``` 6. 获取元素个数 可以使用size()方法获取Set中元素的个数： ```java set.size(); // 返回Set中元素的个数 ``` 7. 清空Set 可以使用clear()方法清空Set中的所有元素： ```java set.clear(); // 清空Set中的所有元素 ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

芝麻干

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

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

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

打赏作者

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

抵扣说明：

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

余额充值