HashMap的版本比较与transient关键字作用

	JDK1.7	JDK 1.8
结构	数组 +链表	数组+链表+红黑树，当数组长度为64，链表长度为阈值（默认为8） 由链表转为红黑树
扩容机制	默认长度大小为16，负载因子为0.75也就是当元素个数为12的时候进行扩容，为0.75的原因，太大会导致查找效率低，太小是数据会很分散	一样
插入与扩容先后	先扩容或插入	先插入后扩容
插入方式	头插法，导致链表循环，条件：当两个线程同时进行扩容，而且是扩容到新的数组上时仍然同一个槽里面	尾插法

hashmap构造方法
先说结论：初始化容量不会按照你设置的大小进行设置容量，而是当进行扩容的时候选一个大于该值的最小2的n次方，假设为5，设置为2^3，假设为9，设置为16，但是时机不同，JDK1.8是在构造方法时就设置，JDK1.7是在进行第一次put操作时候进行的设置
JDK1.8构造函数

 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;
       	//会扩容为大于该值得最小2的n次方，加上为5，就会扩容为8，为9的话就会扩容为16
        this.threshold = tableSizeFor(initialCapacity);
    }

JDK 1.7

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;
        threshold = initialCapacity;
        init();
    }
    
    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    } 

 private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        //会扩容为大于该值得最小2的n次方，加上为5，就会扩容为8，为9的话就会扩容为16
        int capacity = roundUpToPowerOf2(toSize);
	
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

transient作用
被该关键字修饰的关键字不会被序列化，也就是不能进行磁盘持久化或者是不能进行网络传输。
在hashmap中的作用
stackoverflow 查了一下，大概有两个原因。
1.transient 是表明该数据不参与序列化。因为 HashMap 中的存储数据的数组数据成员中，数组还有很多的空间没有被使用，没有被使用到的空间被序列化没有意义。所以需要手动使用 writeObject() 方法，只序列化实际存储元素的数组。
2. 由于不同的虚拟机对于相同 hashCode 产生的 Code 值可能是不一样的，如果你使用默认的序列化，那么反序列化后，元素的位置和之前的是保持一致的，可是由于 hashCode 的值不一样了，那么定位函数 indexOf（）返回的元素下标就会不同，这样不是我们所想要的结果.