java数组 简单了解

一、关于集合

1、数组,链表和哈希表（散列表）的存储方式

(1)传统的数组结构存储数据会在内存中开辟连续得空间，结合下标从而使得可以快速访问数据，但是删除和添加数据就很浪费资源



(2)链表不需要开辟连续空间，使用指针来指向数据，因此删除和添加操作比较快，但是查询数据需要遍历全部得元素



(3)而哈希表[散列表]结合两者得长处，合二为一。使得哈希表比较牛掰（初始容量，数组长度默认为16，分为单指针和双指针，双指针每个元素指向前面元素同时指向后面元素）



(4)Hash也称散列。基本原理就是把任意长度的输入，通过Hash算法变成固定长度得输出，这个映射得规则对应的就是Hash算法，而原始数据映射后得二进制串就是Hash值

entry----key----hash----index哈希值就是把各种类型的key算成统一的下标（.hashcode()）

Hash特点
	1、从Hash值不可反向推导出原始数据
	2、输入数据的微小变化也会得到完全不同的hash值，相同的数据的道相同的hash值
	3、哈希算法执行高效，长文本也能快速计算出哈希
	4、Hash算法冲突概率较小

Hash表在jdk1.7中使用数组+链表	jdk1.8中加入了红黑树
由于Hash的原理是将 输入空间的值 映射成 hash空间内，而hash值空间远小于输入的空间。
根据抽屉原理，一定会存在不同的输入被映射成相同的输出。

抽屉原理：9个抽屉放10个苹果，怎么放都会有一个抽屉里有2个及以上的苹果

(5)HashMap的继承体系

二、HashMap

1、底层一些常量与属性和构造方法

常量：
	//缺省大小
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

	//数组的最大长度
	static final int MAXIMUM_CAPACITY = 1 << 30;

	//缺省负载因子大小
	static final float DEFAULT_LOAD_FACTOR = 0.75f;

	//树化阈值（链表长度超过8之后并且数组长度大于64就会升级成一个树了）
	static final int TREEIFY_THRESHOLD = 8;

	//树降级成为链表的阈值（删除树中元素，元素=6降级为链表）
	static final int UNTREEIFY_THRESHOLD = 6;

	//数组长度大于64（并且某个链表长度>8）升级为红黑树
	static final int MIN_TREEIFY_CAPACITY = 64;

属性：
	//Hash表，put时初始化
	transient Node<K,V>[] table;

	//
	transient Set<Map.Entry<K,V>> entrySet;

	//当前Hash表中元素个数
	transient int size;

	//当前Hash表结构修改次数（插入元素或删除元素，替换不会计数）
	transient int modCount;

	//扩容阈值（Hash表中元素超过阈值时触发扩容，超过阈值不扩容影响查找性能。链化严重）
	int threshold;

	//负载因子（计算threshold = capacity数组长度	*loadFactor负载因子）
	final float loadFactor;

构造方法：
	//
	public HashMap(int initialCapacity, float loadFactor) {
		//做了逻辑校验
		if (initialCapacity < 0)
		    throw new IllegalArgumentException("Illegal initial capacity: " +
						       initialCapacity);
		//传入数组长度超过最大长度就设置为最大长度
		if (initialCapacity > MAXIMUM_CAPACITY)
		    initialCapacity = MAXIMUM_CAPACITY;
		//负载因子<=0。。。。||不是数
		if (loadFactor <= 0 || Float.isNaN(loadFactor))
		    throw new IllegalArgumentException("Illegal load factor: " +
						       loadFactor);
		//赋值负载因子
		this.loadFactor = loadFactor;
		//赋值扩容阈值	   位移计算只能是2的次方数导致table的长度只能是2的次方
					传过来init。。为7计算为8，9计算为16
		this.threshold = tableSizeFor(initialCapacity);
	}

	//设置默认负载因子
	public HashMap() {
		this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
	}

2、put源码分析

put方法时会默认（new entry（key，value，null=指针next））

public V put(K key, V value) {
	//table的length不是特变长的情况下，让让key的hash值高于16位也参与路由运算
	return putVal(hash(key), key, value, false, true);
}

//实际用put向散列表插入数据
/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent散列表存在欲插入的key就不插了（有就替换）
     * @param evict
     * @return previous value, or null if none
     */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {

	//tab：引用当前HashMap的散列表
	//p：表示当前散列表的元素
	//n：表示散列表数组的长度
	//i：表示路由寻址 结果

	Node<K,V>[] tab; Node<K,V> p; int n, i;

	//第一次插入数据时才会初始化，只是new出来并不会初始化（好多new出来但并不用）
        //延迟初始化逻辑
	if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

	//寻址找桶位，刚好为null，这时直接将当前key-value转成node塞进去
        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);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        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)
            resize();
        afterNodeInsertion(evict);
        return null;
    }