hashmap源码阅读

//一些重要的常量
//Node数组的默认长度
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//Node数组的最大长度
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转换为树的阈值，超过这个长度的链表会被转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
//当进行resize操作时，小于这个长度的树会被转换为链表
static final int UNTREEIFY_THRESHOLD = 6;
//链表被转换成树形的最小容量，如果没有达到这个容量只会执行resize进行扩容
static final int MIN_TREEIFY_CAPACITY = 64;

//主要构造函数，其他的构造函数会调用这个构造函数
public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

//map一些重要的方法

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict)
//map的get方法，实际上调用的是getNode方法
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key)
//map的put方法实际上调用的是putVal方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict)
//扩容
final Node<K,V>[] resize() 
//容器由链表变成树结构
final void treeifyBin(Node<K,V>[] tab, int hash)

//红黑树的一些重要的方法
//创建红黑树
final void treeify(Node<K,V>[] tab)
　

final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v)
//左旋
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                      TreeNode<K,V> p)
//右旋
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                       TreeNode<K,V> p)
//平衡插入
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                            TreeNode<K,V> x)

//返回大于 等于cap的最小2的幂次方
static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

猜你喜欢