数组 优势和劣势

数组

数组拥有非常高效的随机访问能力，只要给出下标，就可以用常量时间找到对应元素。有一种高效查找元素的算法叫作二分查找，就是利用了数组这个优势。

数组的劣势，体现在插入和删除元素方面。由于数组元素连续紧密地存储在内存中，插入、删除元素都会导致大量元素被迫移动，影响效率。

数组所适合的是读操作多、写操作少的场景。

public class MyArray {

    private int[] array;
    private int size;

    public MyArray(int capacity) {
        this.array = new int[capacity];
        size = 0;
    }

    /**
     * 数组插入元素
     * 
     * @param element 插入的元素
     * @param index   插入的位置
     */
    public void insert(int element, int index) throws Exception {
        // 判断访问下标是否超出范围
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出数组实际元素范围！");
        }
        // 如果实际元素达到数组容量上限，数组扩容
        if (size >= array.length) {
            resize();
        }
        // 从右向左循环，逐个元素向右挪一位。
        for (int i = size - 1; i >= index; i--) {
            array[i + 1] = array[i];
        }
        // 腾出的位置放入新元素
        array[index] = element;
        size++;
    }

    /**
     * 数组扩容
     */
    public void resize() {
        int[] arrayNew = new int[array.length * 2];
        // 从旧数组拷贝到新数组
        System.arraycopy(array, 0, arrayNew, 0, array.length);
        array = arrayNew;
    }

    /**
     * 数组删除元素
     * 
     * @param index 删除的位置
     */
    public int delete(int index) throws Exception {
        // 判断访问下标是否超出范围
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("超出数组实际元素范围！");
        }
        int deletedElement = array[index];
        // 从左向右循环，逐个元素向左挪一位。
        for (int i = index; i < size - 1; i++) {
            array[i] = array[i + 1];
        }
        size--;
        return deletedElement;
    }

    /**
     * 输出数组
     */
    public void output() {
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }

    public static void main(String[] args) throws Exception {
        MyArray myArray = new MyArray(4);
        myArray.insert(3, 0);
        myArray.insert(7, 1);
        myArray.insert(9, 2);
        myArray.insert(5, 3);
        myArray.insert(6, 1);
        myArray.insert(8, 5);
        myArray.delete(3);
        myArray.output();
    }
}

loadFactor

loadFactor是参与计算HashMap扩容的一个加载因子；new HashMap（）会默认给loadFactor加载一个值0.75

capacity

capacity并非HashMap的属性，指的是HashMap数组的大小，即table.length

threshold扩容的阈值

threshold是判断HashMap是否扩容的阈值
官方注解上写的是 threshold = capacity * loadFactor

汇总为：table下标i=(table.length- 1) & ((h = key.hashCode()) ^ (h >>> 16))

当我们put的时候，会根据key获取对应的hash值，然后无符号右移16位（>>> 16）,在与原本的hash值进行^计算，然后再与table.length-1进行&计算，最终得出需要放入的位置

比如：key = “165156”，HashMap中table数组的大小为16，套入公式，那么我们就会计算出存放位置的下标为13
通过这种方式计算出的值只能是0–15

核心计算

（16-1）的二级制：0000 0000 0000 1111
&的计算方式是：同为1时为1，否则为0
0000 0000 0000 1111的前12位都为0，那么和任何一个值进行&计算，最终得到的结果前12位只能为0
0000 0000 0000 1111的后4位都是1，那么和任何一个值进行&计算，最终得到的结果还是原来的值
最终的结果就是，把原有值的前12位归0，只保留后4位，最终转成十进制，结果集只能是0-15之间
当前HashMap的table数组长度为16，下标值为0-15