2021-06-25

集合源码解读

集合体系图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-baIB2EiL-1624602573916)(E:\Typora\QQ截图20210624120203.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nWk0RReo-1624602573917)(E:\Typora\QQ截图20210624120223.png)]

集合主要是两组，单列集合Collection和双列集合Map

集合实现类总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXvTWNQ9-1624602573919)(E:\Typora\QQ截图20210624212653.png)]

Hash Set源码解读

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("set="+hashSet);
    }
}

hashset图片说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0TigK1gB-1624602573921)(E:\Typora\QQ截图20210622090808.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y8UxPKPC-1624602573922)(E:\Typora\QQ截图20210622094249.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f4li0XiJ-1624602573924)(E:\Typora\QQ截图20210622144311.png)]

###构造方法

    public HashSet() {
        map = new HashMap<>();  //底层是一个hashmap
    }

add方法

public boolean add(E e) { //e是添加的元素，例如Java
    return map.put(e, PRESENT)==null;
}

idea快捷键F4：在当前类中查找变量的来源，例如上述代码的PRESENT

private static final Object PRESENT = new Object();
//PRESENT只是一个对象，无法改变（static final），相当于占位符，占据put方法的value

put方法

public V put(K key, V value) { //key="java",value="PRESENT"
    return putVal(hash(key), key, value, false, true);//到了这个代码块不能点step into，会直接进入putVal，先进入hash(key)，应该点击force step into,
}

hash值方法

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    //hashCode方法是object类方法，可以重写该方法，为一个object获得一个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;//定义了辅助变量
    //table是hashmap的属性，是放node节点的数组，类型是Node[]
    if ((tab = table) == null || (n = tab.length) == 0)//如果table为空，resize为他分配默认的16个空间大小
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        //根据hash值得到key应该存放在table表的哪个索引位置，并且把这个位置的对象赋值给p，p是该hash值的第一个元素
        //为空的话，表示没有存放元素，就创建一个node（key,value）
        //如果有相同的hash值了，得到的table索引位置就不为空。 
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;//一个开发技巧：在需要局部变量（辅助变量）的时候，再创建
        if (p.hash == hash &&//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样，并且满足下面两个条件之一：    
            //(1)准备加入的key和p指向的node节点的key是同一个对象
            //(2)p指向的node节点的key的equals()和准备加入的key比较后相同(针对对象比较)，注意equals方法可以重写，自己定义规则。
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)//判断p是不是红黑树，是的话调用putTreeVal进行添加
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {//如果table对应索引位置，已经是一个链表，就使用for循环比较
            //(1)依次和链表的每一个元素比较后，都不相同，则加入链表
            //(2)如果有相同，则break
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {//索引位置只有一个元素，直接放到后面
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        // 把元素添加到链表后，立即判断该链表是否达到8个结点
                        //达到就调用treeifyBin，对当前链表树化
                        //注意，在转成红黑树前，要进行判断，判断条件：
                        //if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                        //             resize();
                        //条件成立，先table扩容至64，条件不成立，才进行红黑树化。                      
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;//相同了直接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)//threshold表示16乘加载因子0.75
        //size就是我们每加入一个结点node,size就会++，不管是加入链表还是table
        resize();
    afterNodeInsertion(evict);//为hashmap子类存在的方法，于该add方法无关
    return null;//返回空代表成功
}

注意

如果我们要求对象的属性相同，则返回相同的hash值，我们应该重写hashcode方法

LinkedHashSet源码解读

public class LinkedHashSetSource {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("AA");
        linkedHashSet.add(456);
        linkedHashSet.add(456);
        linkedHashSet.add(123);
        linkedHashSet.add("HSP");
        System.out.println("linkedHashSet"+linkedHashSet);
    }
}

输出linkedHashSet[AA, 456, 123, HSP]

LinkedHashSet加入顺序和取出顺序一致

构造方法

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

linkedHashSet底层是一个LinkedHashMap（hashmap的子类）

底层结构（数组table和 双向链表）

添加第一次时，直接将数组table扩容到16，数组是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);
    }
}

LinkedHashSet图片说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ofw044sV-1624602573924)(E:\Typora\QQ截图20210623163644.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-49AcV5d5-1624602573925)(E:\Typora\QQ截图20210623165315.png)]

add方法

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

add方法和hashset一样。

HashMap源码解读

public class CollectionFor {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("no1","饶冬章");
        map.put("no2","张无忌");
        map.put("no1","张三丰");
        System.out.println("map="+map);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QgQ02mjB-1624602573926)(E:\Typora\QQ截图20210624151344-1624519915560.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5DeLYKcO-1624602573927)(E:\Typora\QQ截图20210624163438.png)]

key如果重复了，会替换上一次的值

k-v 最后是HashMap$Node node = newNode(hash, key, value, null)

k-v为了方便程序员的遍历，还会创建EntrySet 集合，该集合存放的元素类型 Entry，而一个Entry对象就有k,v EntrySet<Entry<K,V>>

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D1NoshFF-1624602573927)(E:\Typora\QQ截图20210624153348.png)]

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}

entrySet方法返回的类型是Set<Map.Entry<K,V>>，要想得到Map.Entry<K,V>需要向下转型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-380SrYJQ-1624602573928)(E:\Typora\QQ截图20210624171635.png)]

扩容机制

和hashset一样

HashTable解读

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DVh7wdAW-1624602573928)(E:\Typora\QQ截图20210624195441.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-42i3052A-1624602573929)(E:\Typora\QQ截图20210624210753.png)]

put方法

public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry<?,?> tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> entry = (Entry<K,V>)tab[index];
    for(; entry != null ; entry = entry.next) {
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }

    addEntry(hash, key, value, index);
    return null;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RPsUlnAn-1624602573930)(E:\Typora\QQ截图20210624210912-1624542680568.png)]

扩容机制

private void addEntry(int hash, K key, V value, int index) {
    modCount++;

    Entry<?,?> tab[] = table;
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();

        tab = table;
        hash = key.hashCode();
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    @SuppressWarnings("unchecked")
    Entry<K,V> e = (Entry<K,V>) tab[index];
    tab[index] = new Entry<>(hash, key, value, e);
    count++;
}

Treeset源码解读

public class TreeSetSource {
    public static void main(String[] args) {
        //TreeSet treeSet = new TreeSet
        TreeSet treeSet = new TreeSet(new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                //下面调用String的compareTO方法进行字符串大小的比较
                return ((String) o1).compareTo((String) o2);
            }
        });
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("sp");
        treeSet.add("a");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nj0G4mZj-1624602573930)(E:\Typora\QQ截图20210624220350.png)]

public TreeMap(Comparator<? super K> comparator) {
    this.comparator = comparator;
}

public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

构造器把传入的比较器对象赋给了TreeSet的底层的 TreeMap的属性this.comparator

treeSet底层是treeMap

public V put(K key, V value) {
    Entry<K,V> t = root;//该树的根节点
    if (t == null) {
        compare(key, key); // type (and possibly null) check，检测是否为空

        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;//cpr就是我们的匿名内部类（对象）
    if (cpr != null) {
        do {//一直循环直到找到插入位置
            parent = t;
            cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类compare，cmp是在比较规则的情况下之间的差值，比如字符串ascii码之间的差值
            if (cmp < 0)
                t = t.left;//在根节点的左边
            else if (cmp > 0)
                t = t.right;
            else//如果相等，即返回0，这个key就没有加入
                return t.setValue(value);
        } while (t != null);//t为空退出，找到了要插入的位置
    }
    else {//构造器为空，分析和上面一样
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {  
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);//要插入的位置在parent的左边或者右边
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }