详解Java集合类之HashSet篇

目录

• 1.Set接口方法
• 2.HashSet
• 3.HashSet的扩容机制 - 初次添加数据
• 4.HashSet的扩容机制 - 继续添加数据
• 5.HashSet的扩容机制 - 添加重复元素

1.Set接口方法

Set接口对象存放的数据是没有重复，且数据是无序存放的（添加顺序和存放顺序不一致，但是这个存放的顺序是固定的，不会随机变化）

代码示例：

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

/**
 * Set接口方法
 */
public class SetTest {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Set set = new HashSet();
        // 添加
        set.add("dahe");
        set.add("wangwei");
        set.add(521);
        set.add(521);
        set.add(null);
        System.out.println(set);
        // 遍历Set
        // 迭代器
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println(obj);
        }
        // 增强for
        for (Object o : set) {
            System.out.println(o);
        }
    }
}

2.HashSet

HashSet的底层其实，是HashMap：维护的是一个数组 + 单向链表

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

HashSet不保证存放元素的顺序和取出的顺序一致，这取决于hash后，再确定索引的结果

代码示例：

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

/**
 * HashSet
 */
public class HashSetText {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Set hashSet = new HashSet();
        // 添加
        hashSet.add("dahe");
        // 添加成功，返回true，失败返回false
        System.out.println(hashSet.add("qian"));
        System.out.println(hashSet.add("qian"));
        System.out.println(hashSet);
        // 添加对象，以下是不同的对象
        hashSet.add(new DDD("aaa"));
        hashSet.add(new DDD("aaa"));
        System.out.println(hashSet);
        // 经典面试题，以下的两个只能添加一个
        hashSet.add(new String("hsp"));
        hashSet.add(new String("hsp"));
        System.out.println(hashSet);
    }
}

class DDD {
    private String name;

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

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

3.HashSet的扩容机制 - 初次添加数据

针对如下的代码对java的扩容机制进行分析：

hashSet.add("dahe");
System.out.println(hashSet.add("qian"));
System.out.println(hashSet.add("qian"));

执行add操作：（传入待添加的值e和PRESENT，这里的PRESENT只起到一个占位的效果）

private static final Object PRESENT = new Object();

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

继续步入：

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

在进入putVal方法之前，我们先来看一下这个hash的算法：

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

如果待添加的数据为null，则返回0值，否则返回hash算法的结果（此算法可以极大的防止冲突的发生）

执行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;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 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;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

不要慌，我们来一步一步进行分析：

先来看一下这个东西：

Node<K,V>[] tab;

这个是存放Map Node节点的数组，如果你精通数据结构邻接表，对这个数组应该很熟悉，tab里面的存储结构是这样的：（下图仅作示例）

当这个节点数组为空或者大小为0的时候，会触发这个操作：（tab先进行resize操作，随后返回给n一个处理后数组的大小）

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

那这个resize操作到底是什么呢？我们步入来看看它的真面目：

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

由于初始化tab为null，经过一番操作，会执行如下的代码，这里给计算了新数组的空间大小：

newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

DEFAULT_INITIAL_CAPACITY的定义，默认表的大小为16：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

下面这里是JDK设计者的聪明所在，tab数组并非用到空之后扩容，而是内部有一个临界的值newThr，所用的空间达到临界的值会触发扩容机制 （容量*2），起到一个缓冲的效果，这样做主要是为了防止阻塞

注意：这里的空间指的是全部节点的数量，而非tab元素的个数

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

一切准备就绪，开始扩容（这里初始化扩容的tab容量为16）：

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;

我们再回到putVal方法，看一下接下来会发生什么有趣的事情

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

根据key得到hash，去计算该key应该存放到table表的那个索引位置，并把这个位置对象赋值给p，如果p为null的话，表示该索引位置还没有存放过任何的数据，就在tab[i]位置创建一个Node，创建完新Node之后，它在tab数组中的存储结构就变成了这样：

继续向下走，修改次数 + 1，并且还要判断一次tab元素数量是否大于了临界值，如果大于了临界值，进行扩容操作：

++modCount;
if (++size > threshold)
    resize();

最后，返回null，代表一切操作成功！

至此，初次添加数据的操作就已经完成了！

4.HashSet的扩容机制 - 继续添加数据

初次添加数据的结构其实很简单，更加困难的是第二次添加数据的操作

我们继续步入，再次追到putVal方法：

和初次添加不同的是，不会再进入下面的语句，而是向下执行：

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

直接判断计算得出的tab索引位置有没有数据，没有的话（实验的值没有）继续新建节点：

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

添加完数据后，tab里面的结构就变成了这样：

5.HashSet的扩容机制 - 添加重复元素

此时存在两个key是相等的，那么下面的语句必然不会为空，因为key相等，那么他们hash过后的值也会相等：

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

继续步入，走到else里面，我们来看一下if语句里面的内容：

if (p.hash == hash &&
    ((k = p.key) == key || (key != null && key.equals(k))))
    e = p;

如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样

并且满足准备：（比较地址和值）

• 加入的key和p指向的Node节点的key是同一个对象
• 不是同一个对象，但是通过equals比较过后相同

这时就不能加入，执行：e = p;

再来看看else if语句：

判断p是不是一颗红黑树，如果是的话就按照红黑树的方式进行比较：

else if (p instanceof TreeNode)
    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

再看看else语句：

for (int binCount = 0; ; ++binCount) {
    if ((e = p.next) == null) {
        p.next = newNode(hash, key, value, null);
        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            treeifyBin(tab, hash);
        break;
    }
    if (e.hash == hash &&
        ((k = e.key) == key || (key != null && key.equals(k))))
        break;
    p = e;
}

当前索引位置已经是一个链表。会依次和该链表的每一个节点进行比较，有重复的直接break掉，没有重复的进行挂载

注意：在添加新节点之后，需要进行一次链表长度判断，看下当前链表中是否已经有8个节点了，如果已经存在了8个节点，会通过treeifyBin方法尝试进化链表为红黑树

有趣的是，在进化红黑树的代码中，存在下面这两行：

if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
    resize();

这里面的MIN_TREEIFY_CAPACITY定义如下：

static final int MIN_TREEIFY_CAPACITY = 64;

也就是说，如果tab长度小于64，不会马上进行树化，会先进行tab扩容操作！

到此这篇关于详解Java集合类之HashSet篇的文章就介绍到这了,更多相关Java集合类HashSet内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！