JavaSE-15.1.3【HashSet集合的特点和保证元素唯一性的原理、常见数据结构之哈希表】

 

 

 

 

package day6.lesson1;

import java.util.HashSet;

/*
1.3 HashSet集合的特点

    底层数据结构是哈希表
    对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
    没有带索引的方法，所以不能使用普通for循环遍历(但可以使用迭代器和增强for进行遍历)
    由于是Set集合，所以是不包含重复元素的集合

1.4 HashSet集合保证元素唯一性的原理

    图示

    1.根据对象的哈希值计算存储位置
        如果当前位置没有元素则直接存入
        如果当前位置有元素存在，则进入第二步
    2.当前元素的元素和已经存在的元素比较哈希值
        如果哈希值不同，则将当前元素进行存储
        如果哈希值相同，则进入第三步
    3.通过equals()方法比较两个元素的内容
        如果内容不相同，则将当前元素进行存储
        如果内容相同，则不存储当前元素

    总结：HashSet集合存储元素时要保证元素唯一性需要重写hashCode() & equals()

1.5 常见数据结构之哈希表

    JDK8之前，哈希表采用数组+链表实现，即一个元素为链表的数组
    JDK8以后，在长度较长时，底层实现了优化 。。。

    哈希表图示，证明如何保证元素唯一性
 */
public class HashSetDemo3 {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();
        hs.add("hello");
        hs.add("world");
        hs.add("world");
        hs.add("java");
        hs.add("java");
        System.out.println(hs); //[world, java, hello]
        for (String str: hs){
            System.out.println(str);
        }
        /*
        world
        java
        hello
         */

        /*
        //add()溯源
        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);
        }
        static final int hash(Object key) {
            int h;
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }
        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;
        }
         */
    }
}