Set接口和常用方法

已于 2022-04-04 11:06:52 修改
阅读量803 收藏 2
点赞数
分类专栏： Java基础 文章标签： java spring restful
于 2021-10-15 21:50:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WXxz0/article/details/120791323
版权

Set接口和常用方法

Set接口基本介绍

  1. 无序(添加和取出的顺序不一致)，没有索引

  1. 不允许重复元素，所以最多包含一个null

  2. JDK API中Set接口的实现类有:

请添加图片描述

Set接口的常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样.

Set接口的遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。
1.可以使用迭代器
2.增强for
3.不能使用索引的方式来获取.

package www.xz.set_;

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

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class SetMethod {
    public static void main(String[] args) {

        //1.以Set接口的实现类HashSet 来演示Set接口的方法
        //2.set 接口的 实现类的 对象(Set接口对象)，不能存放重复的元素，可以添加一个 null
        //3.set 接口对象存放数据是无序的(即添加的顺序和取出的顺序不一致)
        //4.注意:取出的顺序的顺序虽然不是添加的顺序，但是他的顺序是固定的。
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复
        set.add("jack");
        set.add("xz");
        set.add(null);
        set.add(null);//重复

        System.out.println("set=" + set);

        //进行遍历
        System.out.println("====迭代器遍历====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("next=" + next);
        }

        set.remove(null);

        System.out.println("====增强for遍历====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }

        //set 接口对象，不能通过索引来获取
        //换言之，set 接口对象不可以用普通for进行遍历

    }
}

Set接口实现类- HashSet

HashSet的全面说明

  1. HashSet实现了Set接口

  2. HashSet实际上是HashMap

public HashSet() {
	map = new HashMap<>();
}
  1. 可以存放null值，但是只能有一个null

  1. HashSet不保证元素是有序的,取决于hash后，再确定索引的结果。

  2. 不能有重复元素/对象.在前面Set接口使用提到过

package www.xz.set_;

import java.util.HashSet;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSet01 {
    public static void main(String[] args) {

        HashSet set = new HashSet();

        System.out.println(set.add("john"));
        System.out.println(set.add("lucy"));
        System.out.println(set.add("john"));
        System.out.println(set.add("jack"));
        System.out.println(set.add("Rose"));

        set.remove("john");

        System.out.println("set=" + set);


        set = new HashSet();
        System.out.println("set=" + set);
        set.add("lucy");//添加成功
        set.add("lucy");//添加不了：因为lucy是存放在常量池中的，上面的添加过之后下面的无法添加
        set.add(new Dog("tom"));//OK
        set.add(new Dog("tom"));//OK  两个Dog并不是同一个对象
        System.out.println("set" + set);

        //再次加深理解！非常经典的面试题
        //看源码，做分析  看完源码就会了然
        set.add(new String("xz"));//OK
        set.add(new String("xz"));//加入不了
        System.out.println("set=" + set);
    }
}

class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

HashSet底层机制说明

➢分析HashSet底层是HashMap, HashMap底层是(数组+链表+红黑树)

简单的数组+链表结构如图：

请添加图片描述

package www.xz.set_;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetStructure {
    public static void main(String[] args) {
        //模拟个HashSet的底层 (HashMap的底层结构)

        //1. 创建一个数组，数组的类型是Node[]
        //2. 有些人，直接把Node[]数组称为 表
        Node[] table = new Node[16];
        System.out.println("table=" + table);
        //3.创建节点
        Node john = new Node("john", null);

        table[2] = john;
        Node jack = new Node("jack", null);
        john.next = jack;//将jack 结点挂载到john
        Node rose = new Node("Rose", null);
        jack.next = rose;//将rose 结点挂载到jack

        Node lucy = new Node("lucy", null);
        table[3] = lucy;//把Lucy放到table表的索引为3的位置。
        System.out.println("table=" + table);

    }
}

class Node {//结点，存储数据，可以指向下一个结点，从而形成链表
    Object item;//存放数据
    Node next;  //指向下一个结点

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "item=" + item +
                '}';
    }
}

➢分析HashSet的添加元素底层是如何实现 (hash() +equals())

  1. HashSet底层是HashMap
  2. 添加一个元素时，先得到hash值 会转成->索引值
  3. 找到存储数据表table ,看这个索引位置是否已经存放的有元素
  4. 如果没有，直接加入
  5. 如果有,调用equals比较，如果相同，就放弃添加，如果不相同，则
    添加到最后
  6. 在Java8中，如果一条链表的元素个数到达TREEIFY THRESHOLD(默认是8),
    并且table的大小>=MIN_TREEIFY_CAPACITY(默认64),
    就会进行树化(红黑树)
package www.xz.set_;

import java.util.HashSet;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetSource {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet();
        hashSet.add("java");
        hashSet.add("php");
        hashSet.add("java");
        System.out.println("hashSet=" + hashSet);


    }
}

➢分析HashSet的扩容和转成红黑树机制

  1. HashSet底层是HashMap,第一次添加时，table 数组扩容到16,临界值
    (threshold)是16*加载因子 (loadFactor)是0.75 = 12
  2. 如果table数组使用到了临界值12,就
    会扩容到 16 * 2 = 32,新的临界值就是 32*0.75 = 24,依次类推
  3. 在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8),
    并且table的大小>=MIN_TREEIFY_CAPACITY(默认64),就
    会进行树化(红黑树)，否则仍然采用数组扩容机制
package www.xz.set_;

import java.util.HashSet;
import java.util.Objects;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetIncrement {
    public static void main(String[] args) {
        /*
            HashSet底层是HashMap, 第一次添加时，tabLe 数组扩容到16，
            临界值(threshold)是 16*加载因子(loadFactor)是0.75 = 12
            如果table 数组使用到了临界值12，就会扩容到16 * 2 = 32,
            新的临界值就是32 * 0.75 = 24,依次类推
        */
        HashSet hashSet = new HashSet();
//        for (int i = 1; i <= 100; i++) {
//            hashSet.add(i);//1,2,3,4,5,...,100
//        }

        /*
            在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，
            并且tabLe的大小>= MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)，
            否则仍然采用数组扩容机制
        */

//        for (int i = 1; i <= 12; i++) {
//            hashSet.add(new A(i));
//        }


        /*
            当我们向hashset增加一个元素，-> Node ->加入table，就算是增加了一个size++
        */

        for (int i = 1; i <= 7; i++) {//在 table 的某一条链表上增加了 7 个对象
            hashSet.add(new A(i));
        }
        for (int i = 1; i <= 7; i++) {//在 table 的另一条链表上增加了 7 个对象
            hashSet.add(new A(i));
        }
    }
}

class A {
    private int n;

    public A(int n) {
        this.n = n;
    }

    @Override
    public int hashCode() {
        return 100;
    }
}

class B {
    private int n;

    public B(int n) {
        this.n = n;
    }

    @Override
    public int hashCode() {
        return 200;
    }
}

HashSetExercise

请添加图片描述

package www.xz.set_;

import java.util.HashSet;
import java.util.Objects;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetExercise {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet();
        hashSet.add(new Employee("tom", 18));
        hashSet.add(new Employee("jack", 21));
        hashSet.add(new Employee("tom", 18));
        System.out.println(hashSet);

        for (Object o : hashSet) {
            System.out.println(o);
        }
    }
}

class Employee {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

请添加图片描述

package www.xz.set_;

import java.util.HashSet;
import java.util.Objects;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetExercise01 {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        MyDate myDate1 = new MyDate(2001, 2, 12);
        MyDate myDate2 = new MyDate(2001, 5, 18);
        MyDate myDate3 = new MyDate(2001, 2, 12);

        hashSet.add(new Staff("jack", 5000, myDate1));
        hashSet.add(new Staff("tom", 10000, myDate2));
        hashSet.add(new Staff("jack", 5000, myDate3));

        for (Object o : hashSet) {
            System.out.println(o);
        }
    }
}

class Staff {
    private String name;
    private double sal;
    private MyDate birthday;

    public Staff(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Staff staff = (Staff) o;
        return Double.compare(staff.sal, sal) == 0 && Objects.equals(name, staff.name) && Objects.equals(birthday, staff.birthday);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sal, birthday);
    }

    @Override
    public String toString() {
        return "Staff{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyDate myDate = (MyDate) o;
        return year == myDate.year && month == myDate.month && day == myDate.day;
    }

    @Override
    public int hashCode() {
        return Objects.hash(year, month, day);
    }

    @Override
    public String toString() {
        return "MyDate=" + year + "-" + month + "-" + day;
    }
}

Set接口实现类- LinkedHashSet

LinkedHashSet的全面说明

  1. LinkedHashSet是HashSet的子类

    请添加图片描述

  2. LinkedHashSet 底层是一个 LinkedHashMap, 底层维护了一个

数组 + 双向链表

  1. LinkedHashSet 根据元素的 hashCode值来决定元素的存储位置，同时使
    用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

  2. LinkedHashSet不允许添重复元素

详细说明

  1. 在LinkedHastSet 中维护了一个hash表和双向链表
    ( LinkedHashSet有head和tail )
  1. 每一个节点有pre和next属性，这样可以形成双向链表

  1. 在添加一个元素时，先求hash值，再求索引，确定该元素在
    hashtable的位置，然后将添加的元素加入到双向链表(如果
    已经存在，不添加[原则和hashset一样])

    1) tail.next = newElement; //简单指定
   newElement.pre = tail;
   tail = newEelment;
2)
  1. 这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致
package www.xz.set_;

import java.util.LinkedHashSet;
import java.util.Set;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class LinkedHashSetSource {
    public static void main(String[] args) {
        //分析一下LinkedHashSet的底层机制
        Set set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer(" 刘", 1001));
        set.add(123);
        set.add("XZ");


        for (Object o : set) {
            System.out.println(o);
        }

        //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致
        //2. LinkedHashSet 底层维护的是一个 LinkedHashMap(是HashMap的子类)
        //3. LinkedHashSet 底层结构 (数组table + 双向链表)
        //4. 添加第一次时，直接将数组 table 扩容到16, 存放的结点类型是 LinkedHashMap$Entry
        //5. 数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry 类型
    }
}

class Customer {
    private String name;
    private int num;

    public Customer(String name, int num) {
        this.name = name;
        this.num = num;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", num=" + num +
                '}';
    }
}

LinkedHashSetExercise

请添加图片描述

package www.xz.set_;

import java.util.LinkedHashSet;
import java.util.Objects;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class LinkedHashSetExercise {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car("奥拓", 1000));
        linkedHashSet.add(new Car("奥迪", 300000));
        linkedHashSet.add(new Car("法拉利", 10000000));
        linkedHashSet.add(new Car("奥迪", 300000));
        linkedHashSet.add(new Car("保时捷", 70000000));
        linkedHashSet.add(new Car("奥迪", 300000));

        for (Object o : linkedHashSet) {
            System.out.println(o);
        }
    }
}

class Car {
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

Set接口实现类- TreeSet

TreeSet是有序的，并且可以指定排序规则，TreeSet的底层是TreeMap

package www.xz.set_;

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

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class TreeSet_ {
    public static void main(String[] args) {
//        TreeSet treeSet = new TreeSet();//默认按字符串排序
        //可使用构造器（传入比较器） 指定排序规则
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照首字母从后往前排序
//                return ((String) o2).compareTo((String) o1);
                //按照字符串长度排序
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("xz");
        treeSet.add("marry");

        System.out.println(treeSet);
    }
}
程序员正正
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java中set接口使用方法详解
09-02
主要为大家详细介绍了java中set接口使用方法，介绍了Java中Set集合接口实现插入对象不重复的原理，感兴趣的小伙伴们可以参考一下
QQ常用接口
04-30
QQ常用接口：获取群验证消息、获取群成员列表、获取禁言列表、获取群相关信息、获取群公告、删除群文件、群签到、发布群公告、邀请加群、部落签到等接口
Collectio集合概述和常用方法
10-26
Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。
C#数组排序的两种常用方法
01-01
本文实例讲述了C#数组排序的两种常用方法。分享给大家供大家参考。具体如下： 1.第一个例子 定义代码 #region Array数组排序1 public class Pigeon : IComparable //类元素本身继承比较接口 { int XValue; int ...
java中set、list和map的使用方法实例
10-04
// java中对象容器主要有Set,List和Map三个接口类。 // 迭代器（Iterator）模式，又叫做游标（Cursor）模式。 // GOF给出的定义为：提供一种方法访问一个容器（container）对象中的各个元素， // 而又不需暴露该...
Set和Map1
08-04
第一节 Set接口1.1 Set接口常用方法千锋JAVA教学部方法名描述确保此 collection 包含指定的元素（可选操作）。extends移除此 coll
Set接口方法
weixin_34297300的博客
03-22 292
import java.util.HashSet;import java.util.Iterator;import java.util.Set;public class demo7 { public static void main(String[] args) { Set<String> set = new HashSet<String>(); ...
Set接口常用方法总结（Java：集合与泛型(二)）
weixin_44785966的博客
04-15 912
一、Set接口概述： Set接口继承Collection接口。 Set接口的常用实现类有：HashSet, LinkedHashSet和TreeSet. Set和List一样是接口,不能直接实例化,只能通过其实现类来实例化. 二、Set接口常用方法总结: 注:该博客代码中引包代码均省略,eclipse用户可通过CTRL+shift+o来进行快捷引包 add(Object obj)：向Set集...
Set接口常见的使用方法
drinkingcode
10-10 1517
package com.atguigu.java; import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; import java.util.TreeSet; i
Set接口的基本方法
CCQDDQ的博客
08-02 144
package Set; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class SetTest { public static void main(String[] args) { Set<String> s1 =new HashSet<>(); System.out.println("---------------添加
set接口方法
weixin_44223212的博客
09-26 119
public class SetMethod { public static void main(String[] args) { Set set = new HashSet(); //1.以set的接口实现类HashSet演示Set接口的方法 //2.set接口的实现类的对象（Set接口的对象），不能存放重复的元素，可以添加一个null //3.set接口对象存放数据是无序的(即添加到顺序和取出的顺序不一致) //4.
Collection 之Set接口概述及常用方法
weixin_52629592的博客
12-19 789
一.Set接口的概述 Set接口是Collection的子接口,未额外提供自己的方法,即使用的方法为Collection中的方法 Set不允许包含相同的元素,即不可重复性 如果试加入两个相同元素,则加入失败 Set判断是否相等 不适用 == ,而是使用equals()方法 二.Set接口的实现类 HashSet 无序 LinkedHashSet LinkedHashSet作为HashSet的子类,在添加数据时,每个...
Set 接口及其常用方法
最新发布
Gefangenes的博客
06-17 204
Set接口是Collection接口的一个子接口，其主要特点如下：Set接口的实现类不会包含重复的元素。更正式地说，不包含任何一对使得成立的元素e1和e2，并且最多只能有一个null元素。当尝试添加重复元素时，添加操作将被忽略。Set接口取出元素的顺序和添加元素的顺序不一致（但是每次取出的顺序是固定的），即无法通过索引访问Set中的元素。Set接口的常用实现类有HashSetTreeSet和。可以使用迭代器和增强 for 循环遍历元素，但是不能使用普通 for 循环（不能使用索引）。
Set接口介绍
liangcheng0213的博客
06-02 3534
文章目录前言一、Set接口：1.Set接口特点：2.Set的实现类：Set接口提供的方法API：二、HashSet1.HashSet的特点：2.HashSet的属性：3.HashSet的构造函数：4.HashSet方法：三、LinkedHashSet：1.LinkedHashSet的特点：2.LinkedHashSet的继承关系和构造器：3、LinkedHastSet的应用场景：四、TreeSet1.TreeSet的特点：2.属性：3.构造器方法总结 前言 Set接口是Collection接口的子类，..
set get方法接口
03-25
回答：set和get方法接口是面向对象编程中常用的方法，用于对类中的属性进行操作。set方法用于设置属性的值，get方法用于获取属性的值。一个典型的set方法的实现如下： public void setProperty(String value) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序员正正

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

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

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

打赏作者

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

抵扣说明：

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

余额充值