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参数传进来,恰好就完成相似但非完全相同的代码用同一个函数处理。