java集合——Map

import java.util.*;
import java.util.Map.Entry;
import java.io.*;
import java.util.Map;
public class CopyOfCopyOfCopyOfY{
    public static void main(String[] args){
        Map <String,Integer> map1 = new HashMap<String,Integer>();
        map1.put("yuwen", 1);
        map1.put("yuwen2", 2);
        map1.put("yuwen3", 3);
        map1.put("yuwen4", 4);
        map1.put("yuwen5", 5);
        map1.put("yuwen6", 6);
        map1.put("yuwen7", 7);
        map1.put("yuwen8", 8);
        map1.put("yuwen9", 9);
        map1.put("yuwen10", 10);
        for(Entry<String,Integer> entry:map1.entrySet()){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}

/**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry[] table;

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
    int threshold;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    final float loadFactor;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    transient volatile int modCount;

    /**
     * Applies a supplemental hash function to a given hashCode, which
     * defends against poor quality hash functions.  This is critical
     * because HashMap uses power-of-two length hash tables, that
     * otherwise encounter collisions for hashCodes that do not differ
     * in lower bits. Note: Null keys always map to hash 0, thus index 0.
     */
    static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

　public V put(K key, V value){
　　//对key的hashCode（）做hash
　　return putVal（hash（key），K key, V value,false,true）;
}
　fianl V putVal(int hash,K key,V value,boolean onlyIfAbsent,boolean evict){
　　Node<K,V> tab;Node<k,V> p;int n,i;
　　//tab为空则创建
　　if((tab=table) == null || (n = tab.length)==0){
　　　　n = (tab = resize()).length;
　　//1.计算index，并对null做处理
　　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);
　　　　//4.该链为链表
　　　　else{
　　　　　　for(int binCount = 0;;+binCount){
　　　　　　　　if((e = p.next) == null){
　　　　　　　　　　//把节点放到链表后
　　　　　　　　　　p.next = newNode(hash,key,value,null);
　　　　　　　　　　//判断是否大于阈值，进行链表和红黑树的转换
　　　　　　　　　　if(binCount>=TREEIFY_THRESHOLD-1)
　　　　　　　　　　　　treeifyBin(tab,hash);
　　　　　　　　　　　　break;
　　　　　　　　　　}
　　　　　　　　　　//插入重复节点的话，继续后移链表
　　　　　　　　　　if(e.hash == hash &&
　　　　　　　　　　　　((k = e.key)== key || (key != null &&key.equals(k))))
　　　　　　　　　　　　break;
　　　　　　　　p = e;
　　　　　　　　}
　　　　//写入
　　　　if(e != null){
　　　　　　V oldValue = e.value;
　　　　　　//存在空值映射
　　　　　　if(!onlyIfAbsent || oldValue == null)
　　　　　　　　e.value = value;
　　　　　　afterNodeAccess(e);
　　　　　　return oldValue;
　　　　}　　　　　　
　　}
　　++modCount;
　　//超过laod factor*current capcity,resize
　　if(++size > threshold)
　　　　resize();
　　afterNodeInsertion(evict);
　　return null;

}
}
}
}

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        // 超过最大值就不再扩充了，就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 没超过最大值，就扩充为原来的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize上限
    if (newThr == 0) {

        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}