集合Set下HashSet

集合Set下HashSet

Set接口和常用方法

1)无序(添加和取出的顺序不一致)，没有索引
7)不允许重复元素，所以最多包含·个null
3)实现类可查看JDK API中Set帮助文档
HashSet的全面说明
1)HashSet实现了Set接囗
2)HashSet实际上是HashMap，看下源码.(图)
public Hashset(){map = new HashMap<>();
3)可以存放null值，但是只能有一个null
4)HashSet不保证元素是有序的,取决于hash后，再确定索引的结果.(即，不保证存放元素的顺序和取出顺序一致)
5)不能有重复元素/对象.在前面Set 接口使用已经讲过

添加案例

import java.util.Objects;
import java.util.Set;

public class HashSet_ {
    public static void main(String[] args) {
        Set hashset = new HashSet();
        Dog tom = new Dog("tom");
        Dog jack = new Dog("tom");
        hashset.add(tom);
        hashset.add(jack);
        System.out.println(hashset);
    }
}
class Dog {
    private String name;

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return Objects.equals(name, dog.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

HashSet结构

HashSet底层机制说明
分析HashSet底层是HashMap,HashMap底层是(数组+链表+红黑树)HashSetStructure.java 为了让大家真正理解，老韩模拟简单的数组+链表结构

package com.itheima.Set;

public class HashSetStructure {
    public static void main(String[] args) {
        //1.创建一个数组，数组的类型是Node[]
        //2，有些人，直接把Node[]数组称为表
        Node[] table = new Node[16];
        Node jack = new Node("jack", null);
        Node tom = new Node("tom", null);
        Node rose = new Node("rose", null);
        jack.next = tom;
        tom.next = rose;
        table[2] = jack;
        System.out.println("table=" + table);

    }
}
//结点，存储数据，可以指向下一个结点，从而形成链表
class Node {
    Object item;//存放数据
    Node next;//指向下一个结点
    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }
}

1.先获取元素的哈希值(hashcode方法)
2.对哈希值进行运算,得出一个索引值即为要存放在哈希表中的位置号
3.如果该位置上没有其他元素，则直接存放如果该位置上已经有其他元素，则需要进行equals判断，如果相等，则不再添加。如果不相等则以链表的方式添加。

hashSet源码解读

//1、执行 HashSet()
public HashSet(){
	map = new HashMap<>();
}
//2执行 add()
public boolean add(E e) {
   return map.put(e, PRESENT)==null;
}
//3、执行 put()，该方法会执行 hash(key)得到key对应的hash值 算法h= key.hashcode())f(h >>> 16
public V put(K key, V value) {
   return putVal(hash(key), key, value, false, true);
}
//4.执行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    //table 就是 HashMap 的一个数组，类型是 Node[]
    //if 语句表示如果当前table 是null，或者大小=0
    //就是第一次扩容，到16个空间。
   Node<K,V>[] tab; Node<K,V> p; int n, i;定义了辅助变量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //根据key，得到hash 去计算该key应该存放到table表的哪个索引
    //并把这个位置的对象，赋给p
    //(2)判断p 是否为null
    //(2.1)如果p为null，表示还没有存放元素，就创建一个Node(key="java",VaLUe=PRESENT)
    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;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //如果table对应索引位置，已经是一个链表，就使用for循环比较
            //(1)依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
            //注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点
            //就调用 treeifyBin()对当前这个链表进行树化(转成红黑树)
            //注意，在转成红黑树时，要进行判断，判断条件
            //如果上面条件成立，先table扩容。
            //只有上面条件不成立时，才进行转成红黑树
            //(2)依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break
            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;
}

调试代码

package com.itheima.Set;

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

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);
        /**
         * 此段代码可以用来调式扩容因子如何起作用的
         */
        for (int i = 1; i <= 100;
             i++) {
            hashSet.add(i);
        }
        /**
         * 在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，
         * 并且table的大小>=MINTREEIFY_CAPACITY(默认64),就会进行树化(红黑树)否则仍然采用数组扩容机制
         * 用此段代码可以用来跟踪链表--转成红黑树过程
         */
        for (int i = 1; i <= 12; i++) {
            hashSet.add(new A(i));//
            System.out.println("hash" + hashSet);
        }
    }
}

class A {
    private int n = 0;

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

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