【Java笔记】Collection子接口：Set接口

最新推荐文章于 2024-03-11 19:37:56 发布
最新推荐文章于 2024-03-11 19:37:56 发布
阅读量441 收藏
点赞数 1
分类专栏： Java笔记总结 文章标签： java 开发语言 面向对象 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijibai_/article/details/124060677
版权

目录

Set接口的框架

如何理解Set接口的无序性与不可重复性

Set接口的使用要求

HashSet的使用

LinkedHashSet的使用

TreeSet的使用

TreeSet自然排序

TreeSet定制排序

有关Set接口的面试题 

Set接口的框架

Collection 接口：单列集合，用来存储一个一个的对象

        Set 接口：存储无序的、不可重复的数据

                HashSet：作为 Set 接口的主要实现类，线程不安全但效率高，可以储存 null 值

                        LinkedHashSet：作为 HashSet 的子类，遍历其内部数据时，可以按照添加的顺序                                                          遍历。对于频繁的遍历操作，LinkedHashSet 的效率高于                                                     HashSet

                TreeSet：可以按照添加对象的指定属性，进行排序

如何理解Set接口的无序性与不可重复性

以 HashSet 为例说明：

1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定

2. 不可重复性：保证添加的元素按照 equals（）判断时，不能返回 true。即相同的元素只能添加一个

Set接口的使用要求

Set 接口中没有额外定义新的方法，使用的都是 Collection 中声明过的方法

1. 向 Set 中添加的数据，其所在类一定要重写 hashCode（）和 equals（）

2. 重写的 hashCode（）和 equals（）尽可能保持一致，相等的对象必须具有相等的散列码（哈希值）

HashSet的使用

import org.junit.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest {
    @Test
    public void test(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add(true);
        set.add("CC");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

>>> AA
    CC
    456
    123
    true

我们向 HashSet 中添加元素 a ，首先调用元素 a 所在类的 hashCode（）方法，计算元素 a 的哈希值，此哈希值接着通过某种算法计算出在 HashSet 底层数组中的存放位置（即为索引位置），判断数组此位置上是否已经有元素：

        如果此位置上没有其他元素，则元素 a 添加成功

        如果此位置上有其他元素 b（或以链表形式存在的多个元素），则比较元素 a 与元素 b 的哈                希值：

                如果哈希值不相同，则元素 a 添加成功

                如果哈希值相同，进而需要调用元素 a 所在类的 equals（）方法：

                        equals（）返回 true，元素 a 添加失败

                        equals（）返回 false，则元素 a 添加成功

对于添加成功的后两种情况，元素 a 与已经存在指定索引位置上的数据以链表的方式存储

JDK 7.0：元素 a 放到数组中，返回原来的元素

JDK 8.0：原来的元素在数组中，指向元素 a

总结：七上八下

        

 HashSet 底层：数组 + 链表的结构

LinkedHashSet的使用

LinkedHashSet 作为 HashSet 的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据

import org.junit.Test;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class SetTest {
    @Test
    public void test(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add(true);
        set.add("CC");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

>>> 456
    123
    AA
    true
    CC

TreeSet的使用

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态

TreeSet 底层使用红黑树结构存储数据

    

TreeSet 两种排序方法：自然排序和定制排序，默认情况下，TreeSet 采用自然排序

TreeSet自然排序

自然排序中，比较两个对象是否相同的标准为：compareTo（）返回 0，不再是 equals（）

import org.junit.Test;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SetTest {
    @Test
    public void test(){
        Set set = new TreeSet();
        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",13));
        set.add(new Person("Mike",5));
        set.add(new Person("Jim",34));
        set.add(new Person("Peter",20));
        set.add(new Person("Peter",29));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
class Person implements Comparable{
    private String name;
    private  int age;

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
    //按照姓名字母从小到大排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person){
            Person person = (Person)o;
            return this.name.compareTo(person.name);
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

>>> Person{name='Jerry', age=13}
    Person{name='Jim', age=34}
    Person{name='Mike', age=5}
    Person{name='Peter', age=20} //只出现了一个 Peter 是因为我们没有重写年龄的 compareTo 方法，比较姓名发现相同，则只存储一个 Peter 数据
    Person{name='Tom', age=12}

TreeSet定制排序

定制排序中，比较两个对象是否相同的标准为：compare（）返回 0，不再是 equals（）

import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class SetTest {
    @Test
    public void test(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person)o1;
                    Person p2 = (Person)o2;
                    return Integer.compare(p1.getAge(), p2.getAge());
                }else{
                    throw new RuntimeException("输入的数据格式不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",13));
        set.add(new Person("Mike",5));
        set.add(new Person("Jim",34));
        set.add(new Person("Peter",20));
        set.add(new Person("Peter",29));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
class Person {
    private String name;
    private  int age;

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

>>> Person{name='Mike', age=5}
    Person{name='Tom', age=12}
    Person{name='Jerry', age=13}
    Person{name='Peter', age=20}
    Person{name='Peter', age=29}
    Person{name='Jim', age=34}

有关Set接口的面试题 

// Person 类中重写了 hashCode() 和 equals()
import org.junit.Test;
import java.util.HashSet;

public class MyTest {
    @Test
    public void test() {
        HashSet set = new HashSet();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");
        set.add(p1);
        set.add(p2);
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);
        set.add(new Person(1001,"CC"));
        System.out.println(set);
        set.add(new Person(1001,"AA"));
        System.out.println(set);
    }
}

>>> [Person{name='CC', age=1001}, Person{name='BB', age=1002}]
    [Person{name='CC', age=1001}, Person{name='CC', age=1001}, Person{name='BB', age=1002}]
    [Person{name='CC', age=1001}, Person{name='CC', age=1001}, Person{name='AA', age=1001}, Person{name='BB', age=1002}]

p1 . name = "CC" 之后，remove p1，寻找的是名为 CC 的哈希值索引数据，并没有对原来 AA 哈希值位置的数据操作，所以没有删除 p1

再添加 Person(1001,"CC")，寻找的是 CC 哈希值位置的数据，发现为 null，则添加数据

最后 Person(1001,"AA")，寻找哈希值为 AA 的哈希值数据，发现有元素存在，则调用 equals（）方法，发现 AA 与 CC 不同，添加成功

java小白。。
关注
专栏目录
java集合Collection之Set接口--Java笔记
m0_57638904的博客
12-19 388
目录 一.Set接口是Collection接口的子接口 二.实现Set接口的类 1.HashSet add（）（添加第一个元素）例： 2.LinkedHashSet 3.HashSet 是无序的（添加和取出的顺序不一致），LinkedHashSet 是有序的（添加和取出的顺序一致） 一.Set接口是Collection接口的子接口 ①.无序（添加和取出的顺序不一致），没有索引 ②.不能有重复的元素，只能有一个null ③.可以使用 迭代器和 增强for 循环来进行遍历，由于没...
Java学习笔记 --- Collection接口方法
乌云的博客
10-30 670
1、Iterator 对象称为迭代器，主要用于遍历 Collection 集合中的元素2、所有实现了 Collection 接口的集合类都有一个 iterator() 方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器3、Iterator 的结构4、Iterator 仅用于遍历集合，Iterator 本身并不存放对象。
集合（上）Collection接口，List集合，Set集合的使用
最新发布
weixin_74141222的博客
03-11 905
集合可以看作一个没有容量限制的数组。集合还可添加各样任意类型的元素。并且集合中的每个对象，既容易从中取出，也容易将其存放到集合中，还能按照一定顺序进行摆放。Java提供不同的集合类，这些集合类具有不同的存储对象的方法；同时都提供了相应的方法对集合进行遍历、添加、删除和查找指定的对象。集合是java的必学点。以上就是关于集合的部分内容，本文仅仅简单介绍了Collection接口与List、Set集合的使用，集合是我们学习java的必须掌握的内容。
java集合之Collection ->Set接口
yangtuan_123的博客
03-15 102
Set集合通常不能记住元素添加的顺序，其他的操作和它的父接口基本相同。只是行为上有细微的差别，Set集合不能包含相同的元素。如果尝试添加相同的元素，调用add()方法将返回false，且新元素不能被加入容器。 下面是Set接口的三个实现类，将一一介绍： 1. HashSet HashSet 类具备以下特征： 1. 不能保证元素的排列顺序，可能和添加的顺序不相同，也有可能会发生变化。 2. Hash...
Java Set子接口
wangtao的博客
01-05 263
1.Set 1.存储一组无序的，不可重复的数据,Set接口没有像List接口一样对Collection接口进行大量的扩充,而是简单的继承了Collection接口;  2.public interface Set<E>extends Collection<E>{}  3.Set本身是接口，操作List需要利用子类(实现类)  4.可以使用HashSet，TreeSet，...
Java List子接口
wangtao的博客
01-05 516
1.Collection接口 1.COllection接口    a.COllection是整个集合之中单值保存的最大父接口;   public interface Collection<E> extends Iterable<E>                  2.常用的方法     add();向集合中保存数据;     addAll();追加一个集合;    ...
java集合框架------Collection接口，List接口与实现类，Set接口与实现类
m0_64365419的博客
11-30 813
对于多个同一类型的数据进行存放和处理时，相信很多人想到的第一个方法就是使用数组，但是数组的使用有非常多的局限性，比如长度不够啦，增删操作需要移动多个元素啦。对于此种问题，采用集合才是最好的解决办法，由于java语言对数据结构进行了封装，我们只需要在java已有的集合框架中选择对我们问题最合适的类，就可以完成创建和操作数据结构的任务，在应用的过程中，我们并不需要考虑数据结构和算法的实现细节，而所抽象出来的数据结构和操作统称为java集合框架。集合框架通过提供有用的数据结构和算法，能够使程序员将重心放在程序更为
Java笔记20——Map和Set
m0_61608447的博客
05-24 425
掌握 Map/Set 及实际实现类 HashMap/TreeMap/HashSet/TreeSet 的使用 掌握 TreeMap 和 TreeSet 背后的数据结构搜索树的原理和简单实现 掌握 HashMap 和 HashSet 背后的数据结构哈希表的原理和简单实现
java学习笔记
12-22
6. **集合**：Collection是最基本的接口，List和Set是其子接口。ArrayList和LinkedList是List的实现，HashSet和TreeSet是Set的实现。Collections是集合操作的工具类。 7. **多线程** - **创建多线程**：通过继承...
java笔记（六）：集合，容器
芙兰泣露的博客
06-23 425
这一节是java最复杂的体系之一，包含各种各样的容器和方法。传统遗留枚举（Enumeration），位集合（BitSet），向量（Vector），栈（Stack），字典（Dictionary），哈希表（Hashtable），属性（Properties）均是java遗留的数据结构，现在已经很少使用。
Java 类集简介（Set子接口）
Java软贱攻城狮
04-12 250
Set接口下的两个常用子类:HashSet、TreeSet。import java.util.HashSet; import java.util.Set; public class Demo { public static void main(String[] args) throws Exception { Set<String> all = new HashSet<...
Java类集框架（三）：Set子接口
MeowingCat
04-30 516
Set子接口只是简单地继承了Collection接口，并没有扩充其他的方法。Set集合中不允许保存重复的数据。在Set接口下有两个常用的子类：HashSet、TreeSet。HashSet是散列存放数据，而TreeSet是有序存放的子类，默认按照字母的升序排列。在实际开发中如果没有排序要求，应优先考虑HashSet子类。 关于数据排序 TreeSet子类中保存的内容的排序，是依靠比较器接口...
java--20--Set及其实现类与子接口
BtWangZhi的博客
05-13 681
1 Set 1.1 代码简要说明： A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. As implied by it
Java集合篇（集合框架、Collection接口、List、Set、Queue等接口及其实现类）
weixin_51612062的博客
08-06 1455
Java学习的第19、20天，Java集合：Java集合框架概述，Collection接口常用功能，Collection子接口之一：List接口(ArrayList、LinkedList、Vector三个实现类)，Collection子接口之二：Queue接口，Collection子接口之三：Set接口......
java中Collection的子接口Set接口
weixin_44022886的博客
05-10 276
一.Set接口概述 Set接口是Collection的子接口，Set接口没有提供额外的方法，它用来存储无序的，不可重复的数据。 Set集合不允许包含相同的元素，如果试把二个相同的元素加入到同一个Set集合中，则添加操作失败。 Set判断二个对象是否相同不是使用 ==运算符，而是根据equals()方法。 Set接口有三个实现类，HashSet,LinkedHashSet,TreeSet,但...
Java接口——子接口是否能直接通过子接口名调用父接口类方法
weixin_53132064的博客
01-29 987
Java接口的默认方法实质就是有方法体的实例方法，为了不破坏接口初衷而硬弄出来这么个东西
java--Collection接口与List、Set接口详解
lzq00277的博客
06-03 240
一、几种接口或类的关系 二、常用方法概览 1、Collection接口常用方法： 增 add(Object obj) addAll(Collection c) 删 remove(Object obj) removeAll(Collection c) clear() 遍历 增强for循环：for (Object obj:list) {System.out.println(obj);} 迭代器：Iterator iterator = list.iterator();wh
java什么是子接口_java集合体系--Collecion的各种子接口、实现类（下）
weixin_35027170的博客
02-24 661
LinkedList实现类，不仅实现了List接口还实现了Deque接口，它可以被当成双端队列来使用，即可被当成“栈”来使用，也可以当成队列使用。LinkedList内部以链表的形式来保存集合中的元素，因此随机访问集合元素时性能较差，但在插入、删除元素时性能比较出色。ArrayList 和LinkedList比较：ArrayList是基于数组的线性表，由于数组以一块连续内存区来保存所有的数组元素，...
JAVA中Collection子接口Set
幻染雨停轻的博客
06-29 270
Collection子接口Set 存储元素特点：无序，不可重复, 特点：                1、元素没有下标的概念          2、元素不能重复（调用元素的equal方法判断元素是否重复，同意元素的地址，两个相同内容的对象）       既然元素不能重复，那要怎么做才能快速的判断即将要存入的元素是否在集合中已经存在了呢？       最直接的方法就是直接判断，但要是元素多了，...
Java学习笔记：框架、物件容器与输入输出解析
Collection接口是所有集合类的父接口，它包括了List和Set两个子接口。List接口代表有序的集合，元素的顺序可以被维护，允许重复元素。Set接口则不允许重复元素，且每个元素都有其特定的排序规则。 1. **Collection...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

java小白。。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值