【JDK源码】从JDK/ArrayList源码学习高质量代码

0x01.避免代码重复，哪怕是一行代码
  构造函数方法调用

// ArrayList带容量大小的构造函数
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        // 新建一个数组
        this.elementData = new Object[initialCapacity];
    }
    // ArrayList无参构造函数。默认容量是10。
    public ArrayList() {
        // this(10)等于ArrayList(10),即在调用带容量大小的构造函数
        this(10);
    }

这是有多大的代码重复强迫症才会将代码写成这样？一般都会把

this(10);

写成

this.elementData = new Object[10];

老外咋一行代码都不愿写重复？好吧，我也学着试试吧！

0x02.代码分块，防止混乱
  ArrayList动态扩容代码

// 确定ArrarList的容量。
    // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 
    public void ensureCapacity(int minCapacity) {
        if (minCapacity > 0)
            ensureCapacityInternal(minCapacity);
    }

    private void ensureCapacityInternal(int minCapacity) {
        //将“修改统计数”+1，该变量主要是用来实现fail-fast机制
        modCount++;
        // overflow-conscious code
        //若当前容量不足以容纳当前元素个数，执行增长容量
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        // overflow-conscious code

        int oldCapacity = elementData.length;
        //(oldCapacity>>1)表示数除以2，缩小为原来的2倍，再取整后加上自身，即完成了公式(oldCapacity*3)/2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果还不够，则直接将minCapacity设置为当前容量 
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新容量大于最大数组界限，则minCapacity设置为当前容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        //抛出异常，然后进行较大者选择，范围控制
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

一个扩容功能分为4个函数来写，出乎我的意料，一般情况下本人写代码也会分函数，但不会像JDK中这样细分的如此厉害，按功能将容量检测/容量增长和范围控制代码分成函数进行封装。毕竟函数里面代码写的太长容易晕！好吧，get了！

0x03.方法设计注重思维！在方法设计完成后，从实现角度考虑后再进行调整编码
  查找元素返回元素下标代码

public boolean contains(Object o) {
        //返回对象的下标，若下标不小于0，即存在合理的下标，表示存在该对象
        return indexOf(o) >= 0;
    }
//往往有很多方法需要用到类似的代码，只是在方法名上需要有一点点变动，则会有方法调用方法的情况，千万别再写重复代码**************************************************************
    //正向查找
    public int indexOf(Object o) {
        //若传入对象为null，并且在数组中也包含null，则返回null的下标
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i] == null)
                    return i;
        }
        //若传入对象不为null，则遍历数组元素，相等则返回下标，否则返回-1
        else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    //反向查找，返回元素的索引值，必然是一找到就返回，所以只要找到就是最尾端的元素，所以是最后的下标值
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size - 1; i >= 0; i--)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = size - 1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

又一例能够解决重复的代码！仔细想想contains方法和indexof方法的实现原理好像确实是大同小异，那如果存在indexof有合法返回值，必定就是list中包含了这个元素。再看indexof方法和lastindexof方法，结构实现基本相同，只是正向与反向检测的区别，打死我也不会想到会进行正向和反向两个方向检查！

0x04.注意细节，千里之堤，毁于蚁穴。
  将e添加到ArrayList的指定位置代码

public void add(int index, E element) {
        //检测范围，防止越界
        rangeCheckForAdd(index);
        //添加元素之前先对容量进行确保
        ensureCapacityInternal(size + 1); // Increments modCount!!
        //从指定位置开始复制size-index个元素，然后将index元素置为element，再将size++——————————————————————————————————————————————————————————————————
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        //这里需要满足两个条件，1.arrayList能动态扩容 2.经过容量确保后的arrayList总是非饱和状态——————————————————————————————————————————————
        size++;
    }

不得不说代码确实漂亮，在增加元素前先检查越界和容量保证，一般情况下，做非实际项目很少有这么严格的代码出现，甚至实际项目，也有很多根本不注重细节的容错代码。

0x05.提高函数复用率

public boolean removeAll(Collection<?> c) {
        return batchRemove(c, false);
    }
    //保留c里面的全部，调用函数batchRemove
    public boolean retainAll(Collection<?> c) {
        return batchRemove(c, true);
    }
    //************************************************************************************精华代码********************************
    //第一想法是双重循环，若能面向对象考虑，则是把内循环放在c里面，变成下面代码中的c.contains函数
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                //使用一个complement标记来判断是否包含元素，若complement为true，则保留包含的；若complement为false，则保留不包含的，就是删除
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            //r不等于size的情况只有一种，就是当c。contains函数出现异常，这样的话，就将r往后的元素全部复制到w后面，挽救后面的数据，而已经筛选过的数据就不用管了，同时将w变成新数组大小
            if (r != size) {
                System.arraycopy(elementData, r, elementData, w, size - r);
                w += size - r;
            }
            //若w与size不等，则将后面的所有单元设置为null，让垃圾回收机制进行回收，其实w是肯定小于size的，除非lis与c并无交集
            if (w != size) {
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }
    //************************************************************************************************************  

提高代码复用率一般情况是较好的对代码进行方法封装，这样多次调用模块化方法。但同时会有另外一种情况，实现两个功能的代码非完全相同，但是逻辑上有百分之八十相同，就像以上代码，从ArrayList中删除Collection中的所有元素和保留Collection中所有元素，一个是保留非Collection元素，一个是保留Collection元素。那么在本质上都是要对ArrayList和Collection都遍历，然后一一对比，只需要在保留前一行，对元素做判断是否保留就可以，而是否保留用一个boolean参数传进来，恰好就完成相似但非完全相同的代码用同一个函数处理。