Java集合专题2——HashSet和LinkedHashSet

香树

已于 2022-05-09 17:05:29 修改

阅读量767

点赞数 3

分类专栏： java 文章标签： java

于 2022-05-09 17:03:58 首次发布

本文链接：https://blog.csdn.net/m0_45364328/article/details/124661536

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

set接口和常用方法
HashSet
LinkedHashSet
- LinkedHashSet 基本介绍

set接口和常用方法

set接口基本介绍

无序（添加和取出的顺序不一致），没有索引
不允许重复元素，所以最多包含一个null
JDK API中Set接口的常用实现类有

关于无序性，我们测试一下

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("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }
    }
}

在这里插入图片描述

set接口的常用方法

其实set接口也是继承看Collection接口，因此，它也就继承了Collection的方法。

public class HashSet01 {
    public static void main(String[] args) {
        HashSet set = new HashSet();

        //说明
        //1. 在执行add方法后，会返回一个boolean值
        //2. 如果添加成功，返回 true, 否则返回false
        //3. 可以通过 remove 指定删除哪个对象
        System.out.println(set.add("john"));//T
        System.out.println(set.add("lucy"));//T
        System.out.println(set.add("john"));//F
        System.out.println(set.add("jack"));//T
        System.out.println(set.add("Rose"));//T


        set.remove("john");
        System.out.println("set=" + set);//3个

        //
        set  = new HashSet();
        System.out.println("set=" + set);//0
        //4 Hashset 不能添加相同的元素/数据?
        set.add("lucy");//添加成功
        set.add("lucy");//加入不了
        set.add(new Dog("tom"));//OK
        set.add(new Dog("tom"));//Ok
        System.out.println("set=" + set);

        //在加深一下. 非常经典的面试题.
        //看源码，做分析， 先给小伙伴留一个坑，以后讲完源码，你就了然
        //去看他的源码，即 add 到底发生了什么?=> 底层机制.
        set.add(new String("hsp"));//ok
        set.add(new String("hsp"));//加入不了.
        System.out.println("set=" + set);


    }
}
class Dog { //定义了Dog类
    private String name;

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

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

set.add(new String(“hsp”));//ok
set.add(new String(“hsp”));//加入不了.
我们后面分析源码，你就知道为什么加入不了，解释放在文章最后面

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("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }

        //遍历
        //方式1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj=" + obj);

        }

        set.remove(null);

        //方式2: 增强for
        System.out.println("=====增强for====");

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

        //set 接口对象，不能通过索引来获取


    }
}

set接口的遍历方式

迭代器
增强for
注意：不能使用普通for,因为set没有size()方法

public class SetMethod {
    public static void main(String[] args) {
//        以set接口的实现子类 HashSet举例 set接口方法
//        1. set接口的实现类（Set接口对象），不能存放重复的元素，可以添加一个null
//        2. set接口对象存放的数据是无序的（即添加的顺序和取出的顺序不一致）
//        3. 注意：取出的顺序虽然不是添加的顺序，但是它是固定的。
        Set 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);
        System.out.println(set);
//        遍历
//        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 o : set) {
            System.out.println(o);
        }
//        set接口对象，不能通过索引来获取，无法使用 普通for循环遍历
    }
}

HashSet

Hash基本介绍

HashSet 实现了Set接口

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

HashSet 实际上是HashMap

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

可以存放null值，但是只能有一个null
HashSet不保证元素是有序的，取决于hash值，再确定索引的结果
不能有重复元素/对象，前面set接口也说了。

HashSet 底层机制

HashSet 底层是HashMap，HashMap底层是数组+链表+红黑树。（1.8才引入红黑树）

模拟下数组＋链表结构怎么存储数据

在这里插入图片描述

package com.hspedu.set_;

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

        //1. 创建一个数组，数组的类型是 Node[]
        //2. 有些人，直接把 Node[] 数组称为 表
        Node[] table = new Node[16];

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

在这里插入图片描述

HashSet add（）源码分析

先说结论

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


@SuppressWarnings({"all"})
public class HashSetSource {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet();
        hashSet.add("java");//到此位置，第1次add分析完毕.
        hashSet.add("php");//到此位置，第2次add分析完毕
        hashSet.add("java");
        System.out.println("set=" + hashSet);

    }
}

  private transient HashMap<E,Object> map;
  HashSet hashSet = new HashSet();
  public HashSet() {
        map = new HashMap<>();
    }

这也就解释了为什么说hashset的底层就是hashmap

第一次add添加”java“：
在这里插入图片描述
进入add()

private static final Object PRESENT = new Object();
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
PRESENT:其实就是一个 new Object()，一个空对象，它起到占位符的作用

进入put（），先看putVal中的hash(key)
在这里插入图片描述

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

其实这个hash(key)就是一个用来计算我们传进来的“java”的hash值的算法，你现在只需要知道它是通过使用高16位异或低16位计算Hash值即可，我们在文章最后，进行解释。

得到hash值后，传入putVal（）：


    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

在这里插入图片描述

进入resize()

继续走，最终会执行

 newCap = DEFAULT_INITIAL_CAPACITY;//16
 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12

在这里插入图片描述

再执行
在这里插入图片描述

 if ((p = tab[i = (n - 1) & hash]) == null)

这个就很有意思，首先hash是之前经过计算的”java“的hash，n是table的大小，现在是16，（n-1）&hash的值一定在0到15之间，因此tab[i = (n - 1) & hash])就是区hash对应的数组的位置的值
以后每次添加数据的时候都会进行判断

因为，第一次添加，所以table什么值也没有
在这里插入图片描述
继续执行

在这里插入图片描述
这样第一个元素就添加完毕

第二次add添加”php“

”php“成功插入

在这里插入图片描述
第三次插入，如果再插入”java“

在这里插入图片描述
下面·是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
                //就是第一次扩容，到16个空间.
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;

                //(1)根据key，得到hash 去计算该key应该存放到table表的哪个索引位置
                //并把这个位置的对象，赋给 p
                //(2)判断p 是否为null
                //(2.1) 如果p 为null, 表示还没有存放元素, 就创建一个Node (key="java",value=PRESENT)
                //(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)

                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
                    Node<K,V> e; K k; //
                    //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                    //并且满足 下面两个条件之一:
                    //(1) 准备加入的key 和 p 指向的Node 结点的 key 是同一个对象
                    //(2)  p 指向的Node 结点的 key 的equals() 和准备加入的key比较后相同
                    //就不能加入
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    //再判断 p 是不是一颗红黑树,
                    //如果是一颗红黑树，就调用 putTreeVal , 来进行添加
                    else if (p instanceof TreeNode)
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {//如果table对应索引位置，已经是一个链表, 就使用for循环比较
                          //(1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
                          //    注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点
                          //    , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
                          //    注意，在转成红黑树时，要进行判断, 判断条件
                          //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                          //            resize();
                          //    如果上面条件成立，先table扩容.
                          //    只有上面条件不成立时，才进行转成红黑树
                          //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break

                        for (int binCount = 0; ; ++binCount) {
                            if ((e = p.next) == null) {
                                p.next = newNode(hash, key, value, null);
                                if (binCount >= TREEIFY_THRESHOLD(8) - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V 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);
                return null;
            }

在这里插入图片描述

HashSet扩容机制（hashmap扩容机制）

测试：

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

在这里插入图片描述

package com.hspedu.set_;

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

/**
 * @author 韩顺平
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class HashSetIncrement {
    public static void main(String[] args) {
        
        /*
        在Java8中, 如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是 8 )，
        并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),
        否则仍然采用数组扩容机制

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

    }
}

class B {
    private int n;

    public B(int n) {
        this.n = n;
    }
    @Override
    public int hashCode() {
        return 200;
    }
}

class A {
    private int n;

    public A(int n) {
        this.n = n;
    }
    @Override
    public int hashCode() {
        return 100;
    }
}

第一个元素放在table中索引为4的位置
在这里插入图片描述
放了8个元素后，都放在了table中索引为4的位置，此时未扩容

添加第9个元素后，table第一次扩容。注意注意注意，此时未达到临界值12，现在只有9个元素，那个链表长度超过8个了

放第10个元素时，链表长度变为10，table数组再次扩容，为64，
在这里插入图片描述
而且链表不放在table索引为4的位置了

再放第11个元素时，链表进行树化了。

此时再往链表放数据时，没有再扩容，直到map中元素超过阈值48，才进行2倍扩容

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

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

注意：
1、每添加一个元素（包括在table表，与表中链表）即添加一个节点，会执行一次 ++size，当size > threshold 时就会执行扩容。
2、当链表的长度达到8，如果再往链表中添加节点，即使没有达到table的扩容阈值（极端的话，如果所有节点都在同一个链表中，此时链表只有9个节点，未达到12），也会2倍扩容；再次往链表中添加节点的话，会再次扩容为64，之后再添加节点链表才会树化。

hashmap扩容这块，一定要自己搞一遍，看看源码，集合的源码还是很简单的，扩容机制这块很多人帖子或者视频说有些不对，上面都是我一步一步演示的，所以参考价值还是很高的

LinkedHashSet

LinkedHashSet 基本介绍

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

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

测试代码

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("HSP");

        System.out.println("set=" + 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 {
    private String name;
    private int no;

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

构造器

在这里插入图片描述

这个tableSizeFor：如果cap不是一个2的幂次方数值，则得到大于cap的第一个2的幂次方数。请参考博客

Set set = new LinkedHashSet(12);假如我们传进去的是12 二进制为1100，经过上述算法后，1100变为1111，为15

刚创建LinkedHashSet 时

在这里插入图片描述

放了第一个元素后
在这里插入图片描述
其实它的add（）方法就是HashSet的

所以扩容机制和hashset是一样的，只不过它是数组+双向链表

香树

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java集合专题2——HashSet和LinkedHashSet

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录set接口和常用方法set接口基本介绍set接口的常用方法set接口的遍历方式HashSetHash基本介绍HashSet 底层机制模拟下数组＋链表结构怎么存储数据HashSet add（）源码分析HashSet扩容机制（hashmap扩容机制）LinkedHashSetLinkedHashSet 基本介绍set接口和常用方法set接口基本介绍无序（添加和取出的顺序不一致），没有索引不允许重复元素，所以最多包含一.
复制链接

扫一扫