Set

set集合的特点：无序的，不能有重复的只能有一个null，没有索引！

HashSet

hashset底层其实是hashMap，他实现了Set接口，他的顺序是不一致的取出来的时候是根据hash值去计算的！

底层是一个哈希表的[数组，链表，红黑树]模拟一个数组和链表的代码

public class HashSet_ {
    public static void main(String[] args) {
        Node table [] = new Node[16];
        Node node = new Node("one",null);
        table[0] = node;
        Node node1 =  new Node("one1",null);
        node.next = node1;
        Node node2 =  new Node("one2",null);
        node1.next = node2;
        System.out.println(table[0]);
    }
}
class Node{
    Object item;
    Node next;
    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "item=" + item +
                ", next=" + next +
                '}';
    }
}

HashSet在add方法的时候步骤[hashCode()+equals()] 先的到对象的hashCode的值，然后在根据算法计算出对象的存放的位置。如果这个位置没有值，就加入。如果有值用equals()方法去判断值是否相同，一样就不能加入不一样就添加在后面。

hashSet的扩容：是链表里的next有8个了，Nodetables 达到了64个 ===》变化成为红黑树。这个table非常特殊，如果你到达了8个但是table没有到64他会先扩容自己看够不够。 table初始化是16，但是有一个加载因子 0.75 如果带打了0.75这个点就扩容自己2倍看够不够，到了2倍的0.75之后再看不够在扩容。如果大于等于64的时候就转成为红黑树了

hashSet的源码解读

//一：new一个hashmap
public HashSet() {
        map = new HashMap<>();
    }
//二：调用他的add方法 
//   e 就是传入的对象
public boolean add(E e) {
  //PRESENT == private static final Object PRESENT = new Object();
  //这里的put方法里面的PRESENT就是一个value的站位符
  //
        return map.put(e, PRESENT)==null;
    }
//这里调用的就是map的put方法，add方法是判断是否添加成功
//map.put(e, PRESENT) 返回一个null添加成功，返回一个对象添加失败

public V put(K key, V value) {
  //hash(key)这里是把你的对象，计算一下的到位置在哪里
        return putVal(hash(key), key, value, false, true);
    }
//putVal(对象的位置, 对象, 占位符 false, true);这里面就是核心对象
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是map里面的一个Node<K,V>[]的一个数组
  //如果是对象是空，或者对象的长度是0给他一个size初始化大小
        if ((tab = table) == null || (n = tab.length) == 0)
  //resize扩容之后返回了一个new 的table [新的Node<K,V>[]的一个数组]
  //初始化是16不过到了 0.75 * 12就会扩容
            n = (tab = resize()).length;
  //用table数组的初始化大小按位计算&他的之前计算对象的位置值 得到一个table[索引],
 //判断这个位置是否有对象，没有就添加进去
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
         // 最重要就是hash值和equals相同
         //  如果当前的哈希值和，你传入对象的哈希值一样
            if (p.hash == hash &&
             //   如果当前的key和你传入的key一样 或者（key不等于null并且传入的key的equals的当前key一样）
                ((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;
  //判断是否大于12
        if (++size > threshold)
            resize();
  //空方法给别人去弄的
        afterNodeInsertion(evict);
        return null;
    }

add方法：一没有重复的元素：初始化扩容16 判断hash是否一样，在判断equals比较是否一样主要有一个不一样就返回null 可以添加了二有重复元素：先判断hash是否一样，在判断equals比较是否一样，判断当前元素是红黑树，如果是树调用树话方法单反hash一样，循环判断里面的equals是否一样扩容：初始化16，加载因子0.75 到16 * 0.75 = 12 时候就扩容到达64 链表8个就树化

linkedHashSet

1，hashSet的子类 2，底层其实是hashMap，是一个数组+双向链表的 3，也是通过元素的hashCode值来存储元素的位置的，他可以以双向链表来保证元素的顺序 4，一样不能重复的 5，他是存入正Node里面的Entry对象

Map

map接口的特点： 1，存储的方式是key-value 2，key-value是obj类型的是存储在Node对象里面的 3，key不可以重复，value可以重复如果有重复的则替换掉前面的值 4，可以提供key找到value 5，他在催促Node对象的时候，会把数据被变为一个Entry 然后在把Entry 放到entrySet 集合里面，这样就可以调用entrySet里面的方法，方便了我们遍历 6，重要的方法KeySet获取到所有的key values获取到所有的value entrySet获取到所有的k - v

map 1,key - value方式存储的 2,key和value可以是任何的数据类型，是封装在HashMap$Node这个对象中的 3,map里面的key不可以重复只能有一个null，但是value是可以的。 4,key重复则覆盖上面的元素 5,一个key对应一个value

key——value的存储是放在Node里面的，但是把为了我们方便遍历map集合创建一个EntrySet集合，里面是entry<k,v>对象 EntrySet<entry<k,y>> 实际上里面还是一个Node，只不过是编译类型是entry运行类型是Node 相当于这样 EntrySet<entry<k,y>> = {entry<k,y>,entry<k,y>,...} entry<k,y> = node<k,y> entry对象里面有两个重要方法：get key(); get value();

key里面的数据，放在了set集合里面 value里面的数据，放在collection集合里面放在一个entry里面，然后把这个entry放在了EntrySet集合里面；

alt

Java里面的集合

Set

HashSet

linkedHashSet

Map