|
|
Java集合框架学习---深入探究ArrayList源码(一)，继续学习ArrayList源码。
//当ArrayList不处于默认状态时，才可拓展为大小小于DEFAULT_CAPACITY容量的数组
// 否则只有指定大小超过DEFAULT_CAPACITY时才进行扩展；
//这个方法是public，区别于ensureCapacityInternal，这个方法是在外部使用的；
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table ? 0
// larger than default for default empty table. It's already
// supposed to be at default size. : DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
} |
这个函数的作用主要是在当ArrayList的容量不足以容纳当前元素时给它设置新的容量。即在有必要的时候增加ArrayList的容量以确保其能够容纳最小容量参数所指定的元素数量。其实在ArrayList类中还有几个私有方法与ensureCapaCity方法相互调用与配合才实现了ensureCapaCity对外发布的功能：
//ArrayList内部使用此方法来拓展容量
//但是假如说处于默认状态，拓展大小仍不能小于DEFAULT_CAPACITY
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//如果不处于默认状态，则调用ensureExplicitCapacity进行拓展
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/*将容量变为指定大小，如果溢出就会抛出OutOfMemoryError错误
*但是通过使用grow方法可以打破MAX_VALUE的限制
*/
private void grow(int minCapacity) {
// 用oldCapacity保存原有的容量大小
int oldCapacity = elementData.length;
//将新的容量设置为原来容量的3/2，可以减少由于小幅度扩展带来的开销
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果newCapacity没有达到指定大小，则将其设定为指定大小
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
/*如果newCapacity比MAX_ARRAY_SIZE(Integer.MAX_VALUE(2147483647)-8)
*还大，则调用hugeCapacity方法给newCapacity重新赋值
*/
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 否则就直接将该ArrayList实例拓展
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;
} |
- contains函数
public boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e))的元素 e时，则返回 true。
public boolean contains(Object o) {
return indexOf(o) >= 0;
} |
其实在contains内部是通过调用了indexOf函数来实现功能：
public int indexOf(Object o) {
//如果传入的对象为空，则尝试在数组中找到一个为空的元素
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;
} |
- indexOf函数
public int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1(代码见contains函数部分)。 - lastIndexOf函数
public int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。更确切地讲，返回满足(o==null ? get(i)==null : o.equals(get(i)))
的最高索引 i，如果不存在此类索引，则返回 -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;
} |
- clone函数
public Object clone()
返回此ArrayList实例的浅表副本，即对此ArrayList实例进行浅层复制
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
} |
- toArray函数
ArrayList中有两个toArray函数
1.public Object[] toArray()：
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。由于该方法是分配一个新的数组，即此列表不维护对返回数组的任何引用，因而它将是安全的，调用者可以自由的修改返回的数组。需要注意的是，它通过调用Arrays中的copyOf函数来实现功能的。
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
//Arrays中的copyOf函数
@SuppressWarnings("unchecked")
/*
*复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度
*对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 null。
*当且仅当指定长度大于原数组的长度时，这些索引存在。所得数组和原数组属于完全相同的类。
*/
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
//被上面的 public static <T> T[] copyOf方法调用
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
//如果该数组存储的是Object类型的元素，就New一个Object类型的数组，否则就使用newInstance产生一个对应类型的数组
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
//Array中的public static Object newInstance(Class<?> componentType, int length)函数
public static Object newInstance(Class<?> componentType, int length)
throws NegativeArraySizeException {
return newArray(componentType, length);
}
// |
2.public <T> T[] toArray(T[] a)：
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳列表，则将该列表返回此处。否则，将分配一个具有指定数组的运行时类型和此列表大小的新数组。如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），那么会将数组中紧接 collection 尾部的元素设置为 null（仅 在调用者知道列表中不包含任何 null 元素时才能用此方法确定列表长度）。
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
//size为该ArrayList的size
if (a.length < size)
// 必须创建一个与参数类型相同的数组
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;//用来帮助调用者确定集合长度（只有在明确知道集合中没有null元素时才有用）
return a;
} |
- elementData方法(缺省方法)
E elementData(int index):
位置访问操作，返回列表中下标为index的元素的值
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
} |
- get方法
public E get(int index):
返回此列表中指定位置上的元素(调用了上面的elementData方法).
public E get(int index) {
rangeCheck(index);
return elementData(index);
} |
可以看到，get方法内部也调用了一个rangeCheck，我们来看看这个方法:
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
} |
这个rangeCheck方法主要是用来进行越界判断的：如果传入的index比列表的size大，那么就抛出一个IndexOutOfBoundsException错误。
好奇......如果index<0的话是怎么进行数组越界判断的呢？？我还没找到原因，先挖个坑,等找到了方法再填坑。
- set方法
public E set(int index, E element):
用指定的元素替代此列表中指定位置上的元素(返回值为被替代的元素的值)。
public E set(int index, E element) {
//进行越界判断，看看index是否大于size
rangeCheck(index);
//取出被替代的值
E oldValue = elementData(index);
//将指定元素替代此列表中指定位置上的元素
elementData[index] = element;
//返回指定位置上被替代的元素
return oldValue;
} |
- add方法
1.public boolean add(E e):
将指定的元素添加到此列表的尾部(添加成功则返回true).
public boolean add(E e) {
ensureCapacityInternal(size + 1); // modCount加一
elementData[size++] = e;
return true;
} |
其实在往列表尾部添加元素的时候要保证列表还有空间存放元素，ensureCapacityInternal函数就是用来完成此
工作的，关于ensureCapacityInternal具体的内部实现参见上方 ensureCapacity函数部分。
2.public void add(int index, E element)：
将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。
public void add(int index, E element) {
//判断是否越界
rangeCheckForAdd(index);
//由于对列表结构进行了修改，所以必须增加modCount，关于ensureCapacityInternal参见上方ensureCapacity函数部分。
ensureCapacityInternal(size + 1);
//将从Index的元素都往后移一个位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//在指定的index位置插入需要添加的值
elementData[index] = element;
//列表的size加一
size++;
} |
add函数内部还调用了rangeCheckForAdd函数，作用是判断指定的位置是否越界。下面是rangeCheckForAdd函数源码：
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
} |
- remove函数
1.* public E remove(int index)：*
移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1），返回值为被移出的元素。
public E remove(int index) {
//检查下标是否越界
rangeCheck(index);
//由于对列表结构进行了修改，modCount++
modCount++;
//保存被移出的值
E oldValue = elementData(index);
//计算有多少元素需要向左移动
int numMoved = size - index - 1;
if (numMoved > 0)
//将Index后面的元素向左移动
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 将第size个元素赋值为null以触发垃圾回收，并且size减一
elementData[--size] = null;
//返回被移出的值
return oldValue;
} |
2.* public boolean remove(Object o):*
移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i)))的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。
public boolean remove(Object o) {
if (o == 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;
}
}
return false;
} |
其实此方法内部主要还是靠调用fastRemove来完成移出功能的，以下是fastRemove源码(其实具体实现和public E remove(int index)函数差不多，只不过它不会返回被移出的元素的值):
private void fastRemove(int index) {
//由于对列表结构进行了修改，因此modeCount加一
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
} |
- clear函数
public void clear() :
移除此列表中的所有元素。此调用返回后，列表将为空。
public void clear() {
modCount++;
// 移出所有元素并触发垃圾回收
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
} |
- addAll函数
1.public boolean addAll(Collection<? extends E> c)：
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
} |
2.public boolean addAll(int index, Collection<? extends E> c)：
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。向右移动当前位于该位置的元素（如果有）以及所有后续元素（增加其索引）。新元素将按照指定 collection 的迭代器所返回的元素顺序出现在列表中。
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
} |
----------------------------
原文链接: http://www.jianshu.com/p/5e421b9514fc
程序猿的技术大观园：www.javathinker.net
[这个贴子最后由 flybird 在 2021-09-22 16:10:42 重新编辑]
|
|
Java技术网站 → 『 Java开发技术 』 → 『 Java编程技术专题 』 → Java集合框架学习---深入探究ArrayList源码
消息
查看
搜索
好友
邮件
复制
引用
IP: 已设置保密
