java性能优化读书笔记之三《程序优化===集合优化（Map）》

1. 数据结构

参考博客数据结构
map概述

map的数据结构为key（键）和value（值）键值对的模式。内部原理是基于数组与单向链表的。其操作是对数组和单向链表进行增加、删除、修改、遍历。

HashMap和Hashtable不同之处在于Hashtable允许key或者value为空，再者Hashtable是线程安全的。

2. hashMap结构图（哈希表）

纵向为数组、横向为单向链表

使用场景
1、需要线程安全的，请使用Hashtable。
2、允许key或者value为空请使用Hashtable。
3、追求程序性能的，是使用HahsMap

3. HashMap源码分析

了解源码之前，请先学习一下数据结构中的哈希表以及算列法。
数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组。

HashMap无惨构造方法

  /**     * Constructs an empty <tt>HashMap</tt> with the default initial capacity     * (16) and the default load factor (0.75).     */    public HashMap() {        //loadFactor 负载因子默认为 0.75f        this.loadFactor = DEFAULT_LOAD_FACTOR;        //threshold  临界值 = 默认初始容量 * 负载因子        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        //默认初始容量(16)        table = new Entry[DEFAULT_INITIAL_CAPACITY];        init();    }

从源码获取HashMap的容器容量大小为16， 扩容的临界值为12。

hashMap的put方法

    * Associates the specified value with the specified key in this map.     * If the map previously contained a mapping for the key, the old     * value is replaced.     *     * @param key key with which the specified value is to be associated     * @param value value to be associated with the specified key     * @return the previous value associated with <tt>key</tt>, or     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.     *         (A <tt>null</tt> return can also indicate that the map     *         previously associated <tt>null</tt> with <tt>key</tt>.)     */    public V put(K key, V value) {        //key可以为空        if (key == null)            return putForNullKey(value);        //取得key的hashCode        int hash = hash(key.hashCode());        //取得元素在数组中的位置或者是内存中的位置        int i = indexFor(hash, table.length);        //解决hash冲突，新插入的元素的数组位置如果已经被其他元素占用了，那么就使用单向链表。占用的元素链表下一个指向新插入的元素        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++;        //hash不冲突，新元素则添加到指定的数组位置        addEntry(hash, key, value, i);        return null;    }

根据散列法获取数组的位置

 /**     * Returns index for hash code h.     */    static int indexFor(int h, int length) {        //等同于h%length，但是不等效。h%length需要调用cpu计算。效率更低        return h & (length-1);    }

HashMap数组扩容

/**     * Adds a new entry with the specified key, value and hash code to     * the specified bucket.  It is the responsibility of this     * method to resize the table if appropriate.     *     * Subclass overrides this to alter the behavior of put method.     */    void addEntry(int hash, K key, V value, int bucketIndex) {    Entry<K,V> e = table[bucketIndex];        //在指定的数组下标位置添加新元素        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);        //判断添加元素后的容器容量大于临界值。则需要数组扩容        if (size++ >= threshold)            //扩容的容器容量= 2 * 数组长度            resize(2 * table.length);    }    /**     * Rehashes the contents of this map into a new array with a     * larger capacity.  This method is called automatically when the     * number of keys in this map reaches its threshold.     *     * If current capacity is MAXIMUM_CAPACITY, this method does not     * resize the map, but sets threshold to Integer.MAX_VALUE.     * This has the effect of preventing future calls.     *     * @param newCapacity the new capacity, MUST be a power of two;     *        must be greater than current capacity unless current     *        capacity is MAXIMUM_CAPACITY (in which case value     *        is irrelevant).     */    void resize(int newCapacity) {        Entry[] oldTable = table;        int oldCapacity = oldTable.length;        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }        //扩容后新的数组        Entry[] newTable = new Entry[newCapacity];        //将旧的数据内容copy扩容后新的数组        transfer(newTable);        table = newTable;        //重新计算临界值 = 数组长度 * 负载因子        threshold = (int)(newCapacity * loadFactor);    }

4. map优化点

1、负载因子本身就是在空间和时间之间的折衷。当我使用较小的负载因子时，虽然降低了冲突的可能性，使得单个链表的长度减小了，加快了访问和更新的速度，但是它占用了更多的空间，使得数组中的大部分空间没有得到利用，元素分布比较稀疏，同时由于Map频繁的调整大小，可能会降低性能。但是如果负载因子过大，会使得元素分布比较紧凑，导致产生冲突的可能性加大，从而访问、更新速度较慢。所以我们一般推荐不更改负载因子的值，采用默认值0.75.

HashMap优化代码
暂无，后续添加