铁甲网,变形金刚2免费下载,异世之风流大法师txt
ArrayList是一个的可变数组的实现，实现了所有可选列表操作，并允许包括 null 在内的所有元素。每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。
注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。
ArrayList是一个Object的数组，还有一个size属性来记录当前容器的容量。
transient Object[] elementData; // non-private to simplify nested class access
private int size;
ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为0的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 传入初始容量的构造函数
public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } } // 默认的构造函数 public ArrayList() {
// 默认的是一个空数组实例，等用到的时候再扩容 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
// 传入外部集合的构造函数 public ArrayList(Collection<? extends E> c) {
//持有传入集合的内部数组的引用 elementData = c.toArray();
//更新集合元素个数大小 if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class)
//判断引用的数组类型, 并将引用转换成Object数组引用 elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
ArrayList有四种添加元素的方法：add(E e)，add(int index, E element)，addAll(Collection<? extends E> c)，addAll(int index, Collection<? extends E> c)
// 添加一个元素
public boolean add(E e) {
//添加前先检查是否需要拓展数组, 此时数组长度最小为size+1 ensureCapacityInternal(size + 1); // Increments modCount!!
//将元素添加到数组末尾 elementData[size++] = e; return true; } // 插入一个元素 public void add(int index, E element) {
//插入位置范围检查 rangeCheckForAdd(index); //检查是否需要扩容 ensureCapacityInternal(size + 1); // Increments modCount!!
//挪动插入位置后面的元素 System.arraycopy(elementData, index, elementData, index + 1, size - index);
//在要插入的位置赋上新值 elementData[index] = element;
//将容器的容量+1 size++; }
// 添加一个集合数据 public boolean addAll(Collection<? extends E> c) {
// 把Collection中的数据按照迭代器的排列复制到临时数组a中 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; } // 插入一个集合数据 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)
// 在elementData的index位置开始，往后移动numNew个位置 System.arraycopy(elementData, index, elementData, index + numNew, numMoved); // 将数据插入的index处 System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; }
细读里面上的代码：
System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
这时的index=1 numNew=3,numMoved=4,那么执行上面的代码后：
然后执行
System.arraycopy(a, 0, elementData, index, numNew);
2. ensureCapacityInternal
//集合最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; private void ensureCapacityInternal(int minCapacity) {
// 如果是空数组（默认初始化时的数组） if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 容量不能小于默认容量10 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) {
// 更新容器被修改的次数 modCount++; // overflow-conscious code
//如果最小容量大于数组长度就扩增数组 if (minCapacity - elementData.length > 0) grow(minCapacity); }
//增加数组的长度 private void grow(int minCapacity) { // overflow-conscious code
//获取数组原先的容量 int oldCapacity = elementData.length;
// 新数组容量，在原来的基础上增加1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);
//检查新的容量是否小于最小容量 if (newCapacity - minCapacity < 0) newCapacity = 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; }
每次添加元素前会调用ensureCapacityInternal这个方法进行集合容量检查。在这个方法内部会检查当前集合的内部数组是否还是个空数组，如果是就新建默认大小为10的Object数组。如果不是则证明当前集合已经被初始化过，那么就调用ensureExplicitCapacity方法检查当前数组的容量是否满足这个最小所需容量，不满足的话就调用grow方法进行扩容。
在grow方法内部可以看到，每次扩容都是增加原来数组长度的一半，扩容实际上是新建一个容量更大的数组，将原先数组的元素全部复制到新的数组上，然后再抛弃原先的数组转而使用新的数组。
我要评论 // 删除指定下标的元素
public E remove(int index) {
//index不能大于size
rangeCheck(index);
//更新容器被修改的次数
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
//将index后面的值往前移一位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//清空最后一个元素
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
// 删除对象元素
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;
}
private void fastRemove(int index) {
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
}
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
增(添加)：仅是将这个元素添加到末尾。操作快速。如果有扩容的情况，会涉及数组的复制，操作较慢。
增(插入)：由于需要移动插入位置后面的元素，并且涉及数组的复制，所以操作较慢。
删：由于需要将删除位置后面的元素向前挪动，也会设计数组复制，所以操作较慢。
改：直接对指定位置元素进行修改，不涉及元素挪动和数组复制，操作快速。
查：直接返回指定下标的数组元素，操作快速。
ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。在看下面iterator()方法的源代码时会发现，再通过迭代器操作ArrayList时都会调用checkForComodification方法，如果modCount被修改了会抛出ConcurrentModificationException.
public Iterator<E> iterator() {
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
// 把modCount重新赋值，所以我们可以使用iterator的remove方法来删除ArrayList里的元素，而不会导致ConcurrentModificationException.
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
浅析我对 String、StringBuilder、StringBuffer 的理解
使用IDEA搭建SSM框架的详细教程(spring + springMVC +MyBatis)
Springboot整合freemarker 404问题解决方案
引入mybatis-plus报 Invalid bound statement错误问题的解决方法
网友评论