ArrayList原理学习（二）
ArrayList构造方法
无参构造
public ArrayList() {
// 调用无参构造方法时，申明了一个空的数组，此时该数组没有容量
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
有参构造
-
指定容量的有参构造方法
public ArrayList(int initialCapacity) { // 校验参数是否大于0，大于0时创建指定大小数组，等于0时创建默认值为10的数组长度 if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { // 小于0时抛出异常 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } } -
指定元素的有参构造方法
public ArrayList(Collection<? extends E> c) { // 将指定元素集合转换成数组，并赋值给elementData // 在调用toArray()方法时，可能返回的不是Object数组 // 此处是子类实现Collection方法，子类重写父类方法的时候， // 在不修改返回值类型的前提下，子类返回了什么类型，具体 // 得到的是子类的返回值类型，而不会上转成父类的返回值类型 elementData = c.toArray(); // 判断集合中的数组长度是否为0 if ((size = elementData.length) != 0) { // 判断当前集合里面的数组类型是否为Object数组，当不相等时，将原数组copy到 // object类型的数组中 if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // 当数组长度为0时创建一个默认数组 this.elementData = EMPTY_ELEMENTDATA; } }
最小化存储数组方法
public void trimToSize() {
// 当前数组修改次数加一
modCount++;
// 判断数组中元素个数是否小于数组容量
if (size < elementData.length) {
// 当小于数组容量时，判断元素个数是否等于0，如果等于0则给原数组赋值一个空数组
// 当元素个数不为0时，将原数组copy到长度为元素个数的新数组
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
ArrayList获取长度和判空方法
-
长度方法
public int size() { return size; } -
判空方法
public boolean isEmpty() { return size == 0; }
ArrayList添加元素方法
-
添加单个元素
public boolean add(E e) { // 校验添加该元素时数组容纳是否需要扩容 ensureCapacityInternal(size + 1); // 添加元素并元素个数加一 elementData[size++] = e; return true; } // 指定位置添加元素 public void add(int index, E element) { // 校验当前位置是否存在元素总数量内，即大于0小于size，否则抛出异常 rangeCheckForAdd(index); // 校验添加该元素时数组容纳是否需要扩容 ensureCapacityInternal(size + 1); // 将指定位置即后面元素全部向后移动一位 System.arraycopy(elementData, index, elementData, index + 1, size - index); // 修改指定位置元素值 elementData[index] = element; // 元素总个数加一 size++; } -
添加多个元素
public boolean addAll(Collection<? extends E> c) { // 将指定元素集合转换成数组 Object[] a = c.toArray(); // 获取到a数组中的元素个数 int numNew = a.length; // 校验当前元素总结加上待添加元素个数后的总数是否超过数组容量 // 超过时进行扩容 ensureCapacityInternal(size + numNew); // 将待添加元素数组copy到原数组后 System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } // 想指定位置后添加一组元素 public boolean addAll(int index, Collection<? extends E> c) { // 校验当前位置是否存在元素总数量内，即大于0小于size，否则抛出异常 rangeCheckForAdd(index); // 将指定元素集合转换成数组 Object[] a = c.toArray(); // 获取到a数组中的元素个数 int numNew = a.length; // 校验当前元素总结加上待添加元素个数后的总数是否超过数组容量 // 超过时进行扩容 ensureCapacityInternal(size + numNew); // 获取到当前位置即后面元素的总数 int numMoved = size - index; // 当后面元素个数不为0时将后面元素copy到原数组index+numNew位置及之后 if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); // 将待添加的元素添加的指定位置 System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; }
ArrayList取出元素及修改元素方法
// -----------取出元素方法
public E get(int index) {
// 校验当前索引是否大于元素个数
rangeCheck(index);
// 取出当前索引位置元素
return elementData(index);
}
// 取出当前索引位置元素，并强制转型
E elementData(int index) {
return (E) elementData[index];
}
// 校验当前索引是否大于元素个数当大于元素个数时抛出异常
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// -----------修改元素方法
public E set(int index, E element) {
// 校验当前索引是否大于元素个数当大于元素个数时抛出异常
rangeCheck(index);
// 取出当前索引对应元素值
E oldValue = elementData(index);
// 修改当前索引对应元素值
elementData[index] = element;
// 返回就当元素
return oldValue;
}
ArrayList删除元素及清空元素方法
删除元素方法
-
指定索引删除元素
public E remove(int index) { // 校验索引是否合法 rangeCheck(index); // 集合修改次数加一 modCount++; // 取出待删除索引位置元素用于返回 E oldValue = elementData(index); // 获取当前索引后存在多少元素的个数 int numMoved = size - index - 1; if (numMoved > 0) // 通过copy方法将该索引后所有元素向前移动一位 System.arraycopy(elementData, index+1, elementData, index, numMoved); // 将当前总元素数的最后一位置为null，便于垃圾回收 elementData[--size] = null; // 返回删除的元素值 return oldValue; } -
指定元素删除元素
public boolean remove(Object o) { // 判断待删除元素是否为null if (o == null) { // 通过循环找出第一个元素为null的索引 for (int index = 0; index < size; index++) if (elementData[index] == null) { // 删除该元素 fastRemove(index); return true; } } else { // 通过循环找出等于要删除元素的原数组中元素对应的索引 for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { // 删除该元素 fastRemove(index); return true; } } // 没有找到该元素时返回false return false; } // 删除指定索引的元素 private void fastRemove(int index) { // 集合修改次数加一 modCount++; // 获取当前索引后存在多少元素的个数 int numMoved = size - index - 1; if (numMoved > 0) // 通过copy方法将该索引后所有元素向前移动一位 System.arraycopy(elementData, index+1, elementData, index, numMoved); // 将当前总元素数的最后一位置为null，便于垃圾回收 elementData[--size] = null; }
清空所有元素方法
public void clear() {
// 集合修改次数加一
modCount++;
// 通过循环将数组中所有元素置空，方便垃圾回收
for (int i = 0; i < size; i++)
elementData[i] = null;
// 将元素总数设置为0
size = 0;
}
ArrayList获取指定元素的当前索引位置
获取第一次出现当前元素的索引位置方法
public int indexOf(Object o) {
// 判断待查询元素是否为null
if (o == null) {
// 通过循环当出现第一个符合条件的元素时，停止循环，返回当前索引位置
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
// 通过循环当出现第一个符合条件的元素时，停止循环，返回当前索引位置
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
// 当不存在当前元素时返回-1
return -1;
}
获取最后一次出现当前元素的索引位置方法
public int lastIndexOf(Object o) {
// 判断待查询元素是否为null
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;
}
// 当不存在当前元素时返回-1
return -1;
}
ArrayList判断是否存在某一元素方法
public boolean contains(Object o) {
// 通过indexOf获取待查询元素的索引，当数组中存在该元素时索引必定大于等于0，等于-1
// 数组中存在该元素时返回true，否则返回false
return indexOf(o) >= 0;
}
ArrayList转数组
public Object[] toArray() {
// 复制当前集合并返回新数组
return Arrays.copyOf(elementData, size);
}
// 将集合元素填充到指定数组
public <T> T[] toArray(T[] a) {
// 判断参数数组的长度是否小于ArrayList元素的个数
// 如果小于当前ArrayList元素个数，则将ArrayList里面的集合copy指定
// 类型的数组并返回该数组。
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 将ArrayList里面的数组元素copy到a数组中
System.arraycopy(elementData, 0, a, 0, size);
// 当a数组的长度大于ArrayList里面的数组时，将a的size位置元素置空
if (a.length > size)
a[size] = null;
// 返回a数组
return a;
}
ArrayList内的扩容方法方法
// 对原集合进行扩容
public void ensureCapacity(int minCapacity) {
// 通过三元比较远远数组是否为null，当为null时指定minExpand为默认容量10否则指定为0
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0 : DEFAULT_CAPACITY;
// 待扩容容量是否大于minExpand，当大于时进行扩容
if (minCapacity > minExpand) {
// 开始对原数组进行扩容
ensureExplicitCapacity(minCapacity);
}
}
private void ensureCapacityInternal(int minCapacity) {
// minCapacity数组的最小长度 判断elementData数组是否为null数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 取出最下长度与默认长度10直接的最大值为数组容量
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
// 数组修改次数加一
modCount++;
// 判断待扩容的容量是否大于原数组的容量，大于时进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// 得到当前数组容量数值
int oldCapacity = elementData.length;
// 取得当前数组容量的1.5倍容量数值
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 当前容量1.5倍数值大于待扩容的容量值时，将原容量的1.5倍容量数值
// 给准备扩容容量字段newCapacity 否则将待扩容容量值给newCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 判断新的容量值是否大于阈值，当大于时将Int值的最大去找赋予newCapacity
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 通过copy对原数组进行扩容，并将新数组赋值给elementData
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;
}
697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
