11.Java集合框架_Set接口

news/2024/10/11 23:25:13

Set接口和常用方法

基本介绍

  1. 无序（添加和取出的顺序不一致），没有索引。
  2. 不允许重复元素，所以最多包含一个null。
  3. JDK API中Set接口的实现类有HashSet、LinkedHashSet和TreeSet。

set接口常用方法

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

Modifier and Type Method and Description
boolean add(E e)如果指定的元素不存在，则将其指定的元素添加（可选操作）。
boolean addAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合（如果尚未存在）（可选操作）。
void clear()从此集合中删除所有元素（可选操作）。
boolean contains(Object o)如果此集合包含指定的元素，则返回 true 。
boolean containsAll(Collection<?> c)返回 true如果此集合包含所有指定集合的元素。
boolean equals(Object o)将指定的对象与此集合进行比较以实现相等。
int hashCode()返回此集合的哈希码值。
boolean isEmpty()如果此集合不包含元素，则返回 true 。
Iterator<E> iterator()返回此集合中元素的迭代器。
boolean remove(Object o)如果存在，则从该集合中删除指定的元素（可选操作）。
boolean removeAll(Collection<?> c)从此集合中删除指定集合中包含的所有元素（可选操作）。
boolean retainAll(Collection<?> c)仅保留该集合中包含在指定集合中的元素（可选操作）。
int size()返回此集合中的元素数（其基数）。
default Spliterator<E> spliterator()在此集合中的元素上创建一个 Spliterator 。
Object[] toArray()返回一个包含此集合中所有元素的数组。
<T> T[] toArray(T[] a)返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

set接口的遍历方式

同Collection的遍历方法一样，因为set接口是Collection接口的子接口。

  1. 可以使用迭代器。
  2. 增强for。
  3. 不能使用索引的方式遍历。

代码：

import java.util.HashSet;
import java.util.Iterator;//set接口的遍历方式
public class SetTraversal {public static void main(String[] args) {//以set接口实现子类 HashSet举例 set接口方法/*1.set接口的实现类（set接口对象），不能存放重复元素，可以添加一个null。2.set接口对象存放的数据是无序的（即添加的顺序和取出的顺序不一致）。3.注意：取出的顺序虽然不是添加的顺序，但是它是固定的。*/HashSet set = new HashSet();set.add("1");set.add("2");set.add("3");set.add("3"); //重复set.add("4");set.add("100");set.add(null);set.add(null); //重复添加nullSystem.out.println(set); //[null, 1, 100, 2, 3, 4]//遍历（两种方式）//1.迭代器System.out.println("=====迭代器遍历=====");Iterator iterator = set.iterator();while (iterator.hasNext()) {Object next =  iterator.next();System.out.println(next);}//2.增强for遍历，本质就是迭代器System.out.println("=====增强for遍历=====");for (Object object : set) {System.out.println(object);}//set接口对象，不能通过索引来获取，无法使用普通for循环遍历}
}

Set实现类-HashSet

基本介绍

  1. HashSet实现了Set接口。

  2. HashSet 实际上是HashMap（源码如下）

    public HashSet() {map = new HashMap<>();
}

  3. 可以存放null值，但是只能有一个null。

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

  5. 不能有重复元素/对象。

代码：

import java.util.HashSet;//Set实现类–HashSet
public class HashSetDemo {public static void main(String[] args) {//1.HashSet实际上是HashMapHashSet hashSet = new HashSet();/* 默认构造器源码public HashSet() {map = new HashMap<>();}*///2.可以存放null值，但只能有一个nullhashSet.add(null);hashSet.add(null);System.out.println(hashSet); //[null]hashSet = new HashSet();//在执行add方法后，会返回一个boolean值。如果添加成功，返回true，否则返回false。//可以通过remove指定删除哪个对象System.out.println(hashSet.add("Tom")); //trueSystem.out.println(hashSet.add("Mike")); //trueSystem.out.println(hashSet.add("John")); //trueSystem.out.println(hashSet.add("Tom")); //falseSystem.out.println(hashSet.add("Jerry")); //truehashSet.remove("Tom");System.out.println(hashSet); //[Mike, John, Jerry]hashSet = new HashSet();//不能添加相同的元素/数据hashSet.add("Lucy"); //truehashSet.add("Lucy"); //falsehashSet.add(new Cat("Tom")); //truehashSet.add(new Cat("Tom")); //trueSystem.out.println(hashSet); //[Cat{name='Tom'}, Cat{name='Tom'}, Lucy]//经典面试题System.out.println(hashSet.add(new String("Helen"))); //trueSystem.out.println(hashSet.add(new String("Helen"))); //falseSystem.out.println(hashSet); //[Cat{name='Tom'}, Cat{name='Tom'}, Lucy, Helen]}
}class Cat{public String name;public Cat(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Cat{" +"name='" + name + "'" +"}";}
}

HashSet底层机制

HashSet 底层是HashMap，HashMap底层是（数组+链表+红黑树）

相较数组存储效率高

HashMap

代码实现：

//HashSet底层机制
public class HashSetMap {public static void main(String[] args) {//模拟一个HashSetMap的底层（HashMap的底层结构）//1.创建一个数组，数组的类型是Node[]//2.有些人，直接把Node[]数组称为表Node[] table = new Node[16];//3.创建节点Node john = new Node("John", null);table[2] = john;Node jane = new Node("Jane", null);john.next = jane; //将jane节点挂载到john后Node fred = new Node("Fred", null);jane.next = fred; //将fred节点挂载到jane后Node lucy = new Node("Lucy", null);table[3] = lucy;System.out.println(table);}
}class Node {//结点，存储数据，可以指向下一个结点，从而形成链表Object item;    //存放数据Node next;  //指向下一个节点public Node(Object item, Node next) {this.item = item;this.next = next;}
}

存储结构：

Node存储结构

源码分析

HashSet的add方法

  1. HashSet底层是HashMap；
  2. 添加一个元素时，先得到hash值（会转成索引值）（不是hashcode，是hashcode经过相关运算得到hash值）；
  3. 找到存储数据表table，看这个索引位置是否已经存放的有元素；
  4. 如果没有，直接加入；
  5. 如果有，调用equals() 比较， 如果相同，就放弃添加，如果不相同，则添加到最后；
  6. 在 java8 中，如果一条链表的元素个数大于等于TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPCAITY（默认64），就会进行树化（红黑树）。

代码：

import java.util.HashSet;//HashSet的add方法源码分析
public class HashSetAdd {public static void main(String[] args) {HashSet hashSet = new HashSet();hashSet.add("java");hashSet.add("php");hashSet.add("java");System.out.println("haseSet="+hashSet);/*1. 执行Hashset()public HashSet() {map = new HashMap<>();}2. 执行hashSet.add()public boolean add(E e) { //e="java"return map.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();}3. 执行put方法public V put(K key, V value) {//key = "java" , value = PRESENT (静态)return putVal(hash(key), key, value, false, true);}4. hash(key)方法，得到key对应的一个“hash值”，但不是hashcode！static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//>>>无符号右移16位}5. 执行putVal 核心!final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;   //定义了辅助变量//table 就是HashMap 的一个数组，类型是Node[]//if语句标识如果当前table是null或者大小为0//第一次扩容，空间大小为16if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;//resize():扩容，第一次生成Node[16],数组扩展的阈值为0.75*16=12//(1)根据key，得到hash去计算该key应该存放到table表的哪个索引位置//并把这个位置的对象，赋给p//(2)判断这个p是否为空//(2.1)如果p为null//如果p为null，标识还没有存放元素，就创建一个Node(key=”java“，value=PRESENT)//就放在该位置tab[i] = newNode(hash, key, value, null);if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {//开发技巧：在需要辅助变量或者局部变量的时候再创建//2.2如果p不为nullNode<K,V> e; K k;//2.2.1 假如数组位置的元素与key（相同）//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样//并且满足 （准备加入的key和p指向的Node结点的key相同） 或（key动态绑定的equals()方法为真）if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//2.2.2 判断p是不是红黑树结点// 调用putTreeVal方法添加else if (p instanceof TreeNode)e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {//2.2.3 假如是链表// 顺次比较链表的每一个元素是否相同(和2.2.1比较方法相同)，都不相同加在最后一个位置，相同就break// 注意在把元素添加到链表后，立即判断，该链表是否到达8个结点，就调用treeifyBin对链表进行树化（转成红黑树）// 注意，在转成红黑树时，要进行判断，判断条件：tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY（默认64）//上述条件成立，先table扩容，否则不成立才转成红黑树for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {//比较到最后一个位置p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}//3 判断是否存在if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;//size 就是我们每加入一个结点Node(k,v,h,next),size++,不论是加在数组还是链表if (++size > threshold)resize();//扩容afterNodeInsertion(evict);//空方法，给HashMap子类去实现return null;}*/}
}

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），就会进行树化（红黑树），否则仍然采用数组扩容机制。

注意：

  • 每添加一个元素（包括在table表，与表中链表）即添加一个节点，会执行一次 ++size，当size > threshold 时就会执行扩容。
  • table表扩容并不是表的16个大小被添加完才执行，当所有元素的个数大于临界值时就会执行扩容。

代码实践

题目描述：

定义一个Employee类，该类包括：private成员属性name和age。

  1. 创建3个Employee对象放入 HashSet中；
  2. 当name和age的值相同时，认为是相同员工，不能添加到HashSet集合中。

思路：不同对象的哈希值一般会不一样，导致在添加对象时可能会在table数组的不同位置添加，因此想要比较对象的属性值，就要重写hashCode方法，使具有相同属性的对象具有一样的hash值，这样才能在插入时比较对象的值；但不同的对象也可能具有相同的hash值，所以要重写equals方法来比较对象属性值。

关键：重写hashCode()与equals()方法

快捷键：Alt+Insert => equals() and hashCode() => 选择相应的参数

代码：

package com.mlt.collection.set;import java.util.HashSet;
import java.util.Objects;//HashSet代码实践
public class HashSetExercise {public static void main(String[] args) {HashSet hashSet = new HashSet();hashSet.add(new Employee("Jack", 18));hashSet.add(new Employee("John", 20));hashSet.add(new Employee("Jack", 18));System.out.println(hashSet); //[Employee{name='Jack', age=18}, Employee{name='John', age=20}]}
}class Employee
{String name;int age;public Employee(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;}@Overridepublic String toString() {return "Employee{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic 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);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}

Set实现类-LinkedHashSet

基本介绍

  1. LinkedHashSet是HashSet的子类。
  2. LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组 + 双向链表。
  3. LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存得。
  4. LinkedHashSet 不允许添加重复元素。

说明：

  1. 在LinkedHashSet中维护了一个hash表和双向链表（LinkedHashSet有head和tail）。
  2. 每一个节点有before和after属性，这样可以形成双向链表。
  3. 在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加【原则和hashset一样】）。
  4. 这样遍历LinkedHashSet也能确保插入顺序和遍历顺序一致。

源码分析

import java.util.LinkedHashSet;//Set实现类–LinkedHashSet
public class LinkedHashSetDemo {public static void main(String[] args) {LinkedHashSet set = new LinkedHashSet();set.add(new String("AA"));set.add(456);set.add(456);set.add(new Customer("刘", 1001));set.add(123);set.add("Kobe");for (int i = 0; i < 100; i++) {set.add(new Customer("Kobe", 24));}//也会树化 parent、left、rightSystem.out.println(set);//1. LinkedHashSet 加入顺序和遍历顺序一致//2. LinkedHashSet 底层是一个LinkedHashMap(是hashMap的子类)//3. LinkedHashSet 底层结构(数组table+双向列表)//4. 添加第一次时，直接将数组table扩容到16，存放的结点类型 LinkedHashMap$Entry//5. 数组是HashMap$Node[] , 存放的元素/数据是 LinkedHashMap$Entry 类型/*//继承关系是在内部类完成 ， 都是静态内部类static class Entry<K,V> extends HashMap.Node<K,V> {Entry<K,V> before, after;Entry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);}}*/}
}class Customer
{String name;int no;public Customer(String name, int no) {this.name = name;this.no = no;}@Overridepublic String toString() {return "Customer{" +"name='" + name + "'" +", no=" + no +"}";}@Overridepublic int hashCode() {return 1;}
}

Set实现类-TreeSet

基本介绍

  • 不允许添加重复元素，不允许添加null
  • 无序（没有按照输入顺序进行输出）
  • 遍历结果有顺序
  • 底层为排序二叉树（红黑树），且采用中序遍历得到结果 （左节点，根节点，右节点）

源码分析

import java.util.Comparator;
import java.util.TreeSet;//Set实现类–TreeSet
public class TreeSetDemo {public static void main(String[] args) {//TreeSet treeSet = new TreeSet();//使用匿名内部类实现Comparator接口，并重写compare方法，指定排序方法TreeSet treeSet = new TreeSet(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {return ((String)o1).length() - ((String)o2).length();}});//添加数据treeSet.add("jack");treeSet.add("tom");treeSet.add("sp");treeSet.add("abc");//tom和abc长度相等，key相等，添加失败System.out.println(treeSet);//[sp, tom, jack]//1.当我们使用无参构造器时，创建TreeSet时,底层默认创建TreeMap/*public TreeSet() {this(new TreeMap<E,Object>());}*///TreeMap 如果使用默认构造函数，要求key是实现了Comparable接口的，并且使用key的compareTo方法比较，//也就是说仍然按照key排序，如果key没有实现Comparable方法就会报错/*String类实现了Comparable接口，重写了compareTo方法：按升序排序,首字母先比较，相等再用第二个字母，以此类推public final class String implements java.io.Serializable, Comparable<String>, CharSequence {}*///2.上面的的代码实现了添加元素按照字符串长度来排序//3./*public V put(K key, V value) {Entry<K,V> t = root;if (t == null) {compare(key, key); // type (and possibly null) checkroot = new Entry<>(key, value, null);size = 1;modCount++;return null;}int cmp;Entry<K,V> parent;// split comparator and comparable pathsComparator<? super K> cpr = comparator;//传入的比较器if (cpr != null) {do {parent = t;cmp = cpr.compare(key, t.key);//动态绑定到我们的comparatorif (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;elsereturn t.setValue(value);//如果比较器比较结果相同，更改value，不更改key//TreeSet的value是类,private static final Object PRESENT = new Object();} while (t != null);}else {//如果使用默认构造函数，即没有比较器对象//要求key是实现了Comparable接口的，并且使用key的compareTo方法比较，if (key == null)//key不能为空throw new NullPointerException();@SuppressWarnings("unchecked")Comparable<? super K> k = (Comparable<? super K>) key;//要求key是实现了Comparable接口的do {parent = t;cmp = k.compareTo(t.key);//使用key的compareTo方法比较if (cmp < 0)t = t.left;else if (cmp > 0)t = t.right;elsereturn t.setValue(value);} while (t != null);}Entry<K,V> e = new Entry<>(key, value, parent);if (cmp < 0)parent.left = e;elseparent.right = e;fixAfterInsertion(e);//加入后红黑树旋转size++;modCount++;return null;}*/treeSet = new TreeSet();treeSet.add(new C(1));treeSet.add(new C(2));treeSet.add(new C(1));System.out.println(treeSet);}}class C implements Comparable<C>{int num;public C(int num) {this.num = num;}public int compareTo(C c) {return this.num - c.num;}@Overridepublic String toString() {return "C{" +"num=" + num +'}';}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.ryyt.cn/news/70445.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈，一经查实，立即删除！

相关文章

js页面加载完成触发

js页面加载完成触发

阅读更多...
罗技鼠标永久宏定义设置

罗技鼠标永久宏定义设置

背景 写程序用到最多的组合按键就是ctrl+c, ctrl+v, 而这些能不能在鼠标上实现，这样就能解放左手了(机智如我) 硬件 需要一款支持宏定义的鼠标，而罗技系列正好拥有(未收广告费），目前尝试在g102, g304, gpwer代上都可运行 思路 使用ghub软件定义宏后加载到鼠标的板载内存上遇…
阅读更多...
前端【js对象合集】

前端【js对象合集】

阅读更多...
SIGIR2024| RAREMed: 不放弃任何一个患者——提高对罕见病患者的药物推荐准确性

SIGIR2024| RAREMed: 不放弃任何一个患者——提高对罕见病患者的药物推荐准确性

在本文中，我们针对药物推荐模型对罕见病患者推荐精度低的问题，提出了一种新的基于预训练-微调的药物推荐模型框架**RAREMed**，并提出了两个针对性的预训练任务，来提高模型对患者病情，尤其是罕见病患者病情的表示学习能力，帮助药物推荐模型提高对罕见病患者的推荐准确度，…
阅读更多...
电阻功率

电阻功率

电阻功率 电阻的额定功率主要由封装决定，但也不是绝对的，还跟电阻的工艺（薄膜还是厚膜），品牌，阻值大小等有一定关系。 如果上网查功率与封装的关系的话，会有一些网友给出功率与封装表格，那并不一定总是正确的，使用时需要谨慎。 下面列一些厂家的电阻与额定功率的关系表…
阅读更多...
OP设置SSH-绑定GitHub账户

OP设置SSH-绑定GitHub账户

OP设置SSH-绑定GitHub账户 https://github.com/dragonpilot-community/dragonpilot_wiki/blob/master/cn/how_to_setup_github_ssh.md 从0.83开始，安装好OP后会删掉原来通用的ssh密钥信息，无法进行ssh/sftp登录。若需要登录，需要在OP里面绑定GitHub账户里头的ssh公钥。 一、…
阅读更多...
DLJD_Docker学习_01

DLJD_Docker学习_01

第1章 Docker 概述 1.1 课程引入 开发/运维互掐 1.1.1 开发与测试和运维间的矛盾，主要是由于环境的不同而引发的。如果能将开发人员使用的环境交给测试与运维使用，这些问题就都能解决。 1.1.2 DevOps DevOps 是一种思想，是一种管理模式，是一种执行规范与标准。它主要是用于…
阅读更多...
Redis工具可视化工具Redis Desktop Manager（附安装包）

Redis工具可视化工具Redis Desktop Manager（附安装包）

前言 redis工具，我相信每个开发都需要，如果每次查都去client执行指令，我怕查完之后，老大就要发版咯。我之前一直用的Redis可视化工具RedisDesktopManager，总觉得差点意思，直到同事推荐了个新的，突然2眼发光！！ 先上链接： Redis可视化工具 RedisDesktopManager（旧版）…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站 尧图建网站 广利置业