集合框架源码学习之ArrayList
目录：
0-0-1. 前言java
前言：
这篇文章，其实几天前就已经在图书馆写出来了，不过手一抖几个删除键就都没有了，因此一直拖到了如今。这篇文章在分析ArrayList的时候对ArrayList源码中用到的比较好的语法也会做以陈述。但愿经过这篇文章可让你从本质上认识ArrayList，笔者愚笨，如若遇到错误敬请告知。多线程
集合框架知识回顾：
整体知识脉络 框架
ArrayList简介：
ArrayList 的底层是数组队列，至关于动态数组。与Java中的数组相比，它的容量能动态增加。在添加大量元素前，应用程序可使用ensureCapacity 操做来增长 ArrayList 实例的容量。这能够减小递增式再分配的数量。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 在咱们学数据结构的时候就知道了线性表的顺序存储，插入删除元素的时间复杂度为O（n）,求表长以及增长元素，取第 i 元素的时间复杂度为O（1） ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。 ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，咱们便可以经过元素的序号快速获取元素对象，这就是快速随机访问。 ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。 ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能经过序列化去传输。 和Vector不一样，ArrayList中的操做不是线程安全的！因此，建议在单线程中才使用ArrayList，而在多线程中能够选择Vector或者CopyOnWriteArrayList。dom
ArrayList核心源码：
package java.util;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
/** * 默认初始容量大小 */
private static final int DEFAULT_CAPACITY = 10;
/** * 空数组（用于空实例）。 */
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小空实例的共享空数组实例。
//咱们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量须要增长多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/** * 保存ArrayList数据的数组 */
transient Object[] elementData; // non-private to simplify nested class access
/** * ArrayList 所包含的元素个数 */
private int size;
/** * 带初始容量参数的构造函数。（用户本身指定容量） */
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//建立initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//建立空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/** *默认构造函数，其默认初始容量为10 */
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/** * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。 */
public ArrayList(Collection<? extends E> c) {
//
elementData = c.toArray();
//若是指定集合元素个数不为0
if ((size = elementData.length) != 0) {
// c.toArray 可能返回的不是Object类型的数组因此加上下面的语句用于判断，
//这里用到了反射里面的getClass()方法
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 用空数组代替
this.elementData = EMPTY_ELEMENTDATA;
}
}
/** * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可使用此操做来最小化ArrayList实例的存储。 */
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//下面是ArrayList的扩容机制
//ArrayList的扩容机制提升了性能，若是每次只扩充一个，
//那么频繁的插入会致使频繁的拷贝，下降性能，而ArrayList的扩容机制避免了这种状况。
/** * 若有必要，增长此ArrayList实例的容量，以确保它至少能容纳元素的数量 * @param minCapacity 所需的最小容量 */
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);
}
}
//获得最小扩容量
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取默认的容量和传入参数的较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//判断是否须要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//调用grow方法进行扩容，调用此方法表明已经开始扩容了
grow(minCapacity);
}
/** * 要分配的最大数组大小 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/** * ArrayList扩容的核心方法。 */
private void grow(int minCapacity) {
// oldCapacity为旧容量，newCapacity为新容量
int oldCapacity = elementData.length;
//将oldCapacity 右移一位，其效果至关于oldCapacity /2，
//咱们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//而后检查新容量是否大于最小须要容量，若仍是小于最小须要容量，那么就把最小须要容量看成数组的新容量，
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//再检查新容量是否超出了ArrayList所定义的最大容量，
//若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
//若是minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，不然，新容量大小则为 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);
}
//比较minCapacity和 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/** *返回此列表中的元素数。 */
public int size() {
return size;
}
/** * 若是此列表不包含元素，则返回 true 。 */
public boolean isEmpty() {
//注意=和==的区别
return size == 0;
}
/** * 若是此列表包含指定的元素，则返回true 。 */
public boolean contains(Object o) {
//indexOf()方法：返回此列表中指定元素的首次出现的索引，若是此列表不包含此元素，则为-1
return indexOf(o) >= 0;
}
/** *返回此列表中指定元素的首次出现的索引，若是此列表不包含此元素，则为-1 */
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++)
//equals()方法比较
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/** * 返回此列表中指定元素的最后一次出现的索引，若是此列表不包含元素，则返回-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;
}
/** * 返回此ArrayList实例的浅拷贝。 （元素自己不被复制。） */
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
//Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// 这不该该发生，由于咱们是能够克隆的
throw new InternalError(e);
}
}
/** *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中全部元素的数组。 *返回的数组将是“安全的”，由于该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。 *所以，调用者能够自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。 */
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
/** * 以正确的顺序返回一个包含此列表中全部元素的数组（从第一个到最后一个元素）; *返回的数组的运行时类型是指定数组的运行时类型。 若是列表适合指定的数组，则返回其中。 *不然，将为指定数组的运行时类型和此列表的大小分配一个新数组。 *若是列表适用于指定的数组，其他空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。 *（这仅在调用者知道列表不包含任何空元素的状况下才能肯定列表的长度。） */
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
// 新建一个运行时类型的数组，可是ArrayList数组的内容
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
//调用System提供的arraycopy()方法实现数组之间的复制
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
/** * 返回此列表中指定位置的元素。 */
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
/** * 用指定的元素替换此列表中指定位置的元素。 */
public E set(int index, E element) {
//对index进行界限检查
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
//返回原来在这个位置的元素
return oldValue;
}
/** * 将指定的元素追加到此列表的末尾。 */
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
//这里看到ArrayList添加元素的实质就至关于为数组赋值
elementData[size++] = e;
return true;
}
/** * 在此列表中的指定位置插入指定的元素。 *先调用 rangeCheckForAdd 对index进行界限检查；而后调用 ensureCapacityInternal 方法保证capacity足够大； *再将从index开始以后的全部成员后移一个位置；将element插入index位置；最后size加1。 */
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//arraycopy()这个实现数组之间复制的方法必定要看一下，下面就用到了arraycopy()方法实现数组本身复制本身
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
/** * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。 */
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
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
//从列表中删除的元素
return oldValue;
}
/** * 从列表中删除指定元素的第一个出现（若是存在）。 若是列表不包含该元素，则它不会更改。 *返回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;
}
/* * Private remove method that skips bounds checking and does not * return the value removed. */
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 void clear() {
modCount++;
// 把数组中全部的元素的值设为null
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
/** * 按指定集合的Iterator返回的顺序将指定集合中的全部元素追加到此列表的末尾。 */
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;
}
/** * 将指定集合中的全部元素插入到此列表中，从指定的位置开始。 */
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;
}
/** * 今后列表中删除全部索引为fromIndex （含）和toIndex之间的元素。 *将任何后续元素移动到左侧（减小其索引）。 */
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
/** * 检查给定的索引是否在范围内。 */
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/** * add和addAll使用的rangeCheck的一个版本 */
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/** * 返回IndexOutOfBoundsException细节信息 */
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
/** * 今后列表中删除指定集合中包含的全部元素。 */
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
//若是此列表被修改则返回true
return batchRemove(c, false);
}
/** * 仅保留此列表中包含在指定集合中的元素。 *换句话说，今后列表中删除其中不包含在指定集合中的全部元素。 */
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
/** * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。 *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。 *返回的列表迭代器是fail-fast 。 */
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
/** *返回列表中的列表迭代器（按适当的顺序）。 *返回的列表迭代器是fail-fast 。 */
public ListIterator<E> listIterator() {
return new ListItr(0);
}
/** *以正确的顺序返回该列表中的元素的迭代器。 *返回的迭代器是fail-fast 。 */
public Iterator<E> iterator() {
return new Itr();
}
复制代码
ArrayList源码分析：
System.arraycopy()和Arrays.copyOf()方法
经过上面源码咱们发现这两个实现数组复制的方法被普遍使用并且不少地方都特别巧妙。好比下面add(int index, E element)方法就很巧妙的用到了arraycopy()方法让数组本身复制本身实现让index开始以后的全部成员后移一个位置:函数
/** * 在此列表中的指定位置插入指定的元素。 *先调用 rangeCheckForAdd 对index进行界限检查；而后调用 ensureCapacityInternal 方法保证capacity足够大； *再将从index开始以后的全部成员后移一个位置；将element插入index位置；最后size加1。 */
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//arraycopy()方法实现数组本身复制本身
//elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}
复制代码
又如toArray()方法中用到了copyOf()方法
/** *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中全部元素的数组。 *返回的数组将是“安全的”，由于该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。 *所以，调用者能够自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。 */
public Object[] toArray() {
//elementData：要复制的数组；size：要复制的长度
return Arrays.copyOf(elementData, size);
}
复制代码
二者联系与区别：
联系： 看二者源代码能够发现copyOf()内部调用了System.arraycopy()方法 区别： 1，arraycopy()须要目标数组，将原数组拷贝到你本身定义的数组里，并且能够选择拷贝的起点和长度以及放入新数组中的位置 2，copyOf()是系统自动在内部新建一个数组，并返回该数组。
ArrayList核心扩容技术
//下面是ArrayList的扩容机制
//ArrayList的扩容机制提升了性能，若是每次只扩充一个，
//那么频繁的插入会致使频繁的拷贝，下降性能，而ArrayList的扩容机制避免了这种状况。
/** * 若有必要，增长此ArrayList实例的容量，以确保它至少能容纳元素的数量 * @param minCapacity 所需的最小容量 */
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);
}
}
//获得最小扩容量
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取默认的容量和传入参数的较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//判断是否须要扩容,上面两个方法都要调用
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 若是说minCapacity也就是所需的最小容量大于保存ArrayList数据的数组的长度的话，就须要调用grow(minCapacity)方法扩容。
//这个minCapacity到底为多少呢？举个例子在添加元素(add)方法中这个minCapacity的大小就为如今数组的长度加1
if (minCapacity - elementData.length > 0)
//调用grow方法进行扩容，调用此方法表明已经开始扩容了
grow(minCapacity);
}
复制代码
/** * ArrayList扩容的核心方法。 */
private void grow(int minCapacity) {
//elementData为保存ArrayList数据的数组
///elementData.length求数组长度elementData.size是求数组中的元素个数
// oldCapacity为旧容量，newCapacity为新容量
int oldCapacity = elementData.length;
//将oldCapacity 右移一位，其效果至关于oldCapacity /2，
//咱们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//而后检查新容量是否大于最小须要容量，若仍是小于最小须要容量，那么就把最小须要容量看成数组的新容量，
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//再检查新容量是否超出了ArrayList所定义的最大容量，
//若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
//若是minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，不然，新容量大小则为 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);
}
复制代码
扩容机制代码已经作了详细的解释。另外值得注意的是你们很容易忽略的一个运算符：移位运算符 简介：移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。 做用：对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快不少,由于程序仅仅移动一下而已,不去计算,这样提升了效率,节省了资源 好比这里：int newCapacity = oldCapacity + (oldCapacity >> 1); 右移一位至关于除2，右移n位至关于除以2的n次方。这里oldCapacity 明显右移了1位因此至关于oldCapacity /2。
另外须要注意的是：
-
java中的length属性是针对数组说的,好比说你声明了一个数组,想知道这个数组的长度则用到了length这个属性.
-
java中的length()方法是针对字 符串String说的,若是想看这个字符串的长度则用到length()这个方法.
-
.java中的size()方法是针对泛型集合说的,若是想看这个泛型有多少个元素,就调用此方法来查看!
内部类
(1)private class Itr implements Iterator<E> (2)private class ListItr extends Itr implements ListIterator<E> (3)private class SubList extends AbstractList<E> implements RandomAccess (4)static final class ArrayListSpliterator<E> implements Spliterator<E> 复制代码
ArrayList有四个内部类，其中的Itr是实现了Iterator接口，同时重写了里面的hasNext()，next()，remove()等方法；其中的ListItr继承Itr，实现了ListIterator接口，同时重写了hasPrevious()，nextIndex()，previousIndex()，previous()，set(E e)，add(E e)等方法，因此这也能够看出了Iterator和ListIterator的区别:ListIterator在Iterator的基础上增长了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。具体能够参考http://blog.csdn.net/a597926661/article/details/7679765。其中的SubList继承AbstractList，实现了RandmAccess接口，类内部实现了对子序列的增删改查等方法，但它同时也充分利用了内部类的优势，就是共享ArrayList的全局变量，例如检查器变量modCount，数组elementData等，因此SubList进行的增删改查操做都是对ArrayList的数组进行的，并无建立新的数组。(内部类这里参考了这位老兄的博客http://blog.csdn.net/ljcitworld/article/details/52041836)
ArrayList经典Demo：
package list;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] srgs){
ArrayList<Integer> arrayList = new ArrayList<Integer>();
System.out.printf("Before add:arrayList.size() = %d\n",arrayList.size());
arrayList.add(1);
arrayList.add(3);
arrayList.add(5);
arrayList.add(7);
arrayList.add(9);
System.out.printf("After add:arrayList.size() = %d\n",arrayList.size());
System.out.println("Printing elements of arrayList");
// 三种遍历方式打印元素
// 第一种：经过迭代器遍历
System.out.print("经过迭代器遍历:");
Iterator<Integer> it = arrayList.iterator();
while(it.hasNext()){
System.out.print(it.next() + " ");
}
System.out.println();
// 第二种：经过索引值遍历
System.out.print("经过索引值遍历:");
for(int i = 0; i < arrayList.size(); i++){
System.out.print(arrayList.get(i) + " ");
}
System.out.println();
// 第三种：for循环遍历
System.out.print("for循环遍历:");
for(Integer number : arrayList){
System.out.print(number + " ");
}
// toArray用法
// 第一种方式(最经常使用)
Integer[] integer = arrayList.toArray(new Integer[0]);
// 第二种方式(容易理解)
Integer[] integer1 = new Integer[arrayList.size()];
arrayList.toArray(integer1);
// 抛出异常，java不支持向下转型
//Integer[] integer2 = new Integer[arrayList.size()];
//integer2 = arrayList.toArray();
System.out.println();
// 在指定位置添加元素
arrayList.add(2,2);
// 删除指定位置上的元素
arrayList.remove(2);
// 删除指定元素
arrayList.remove((Object)3);
// 判断arrayList是否包含5
System.out.println("ArrayList contains 5 is: " + arrayList.contains(5));
// 清空ArrayList
arrayList.clear();
// 判断ArrayList是否为空
System.out.println("ArrayList is empty: " + arrayList.isEmpty());
}
}
复制代码
欢迎关注个人微信公众号（分享各类Java学习资源，面试题，以及企业级Java实战项目回复关键字免费领取）：
相关文章
- 1. 集合框架源码学习之LinkedList
- 2. 学习JDK1.8集合源码之--ArrayList
- 3. 集合源码学习之路---ArrayList
- 4. Java 集合框架 ArrayList 源码剖析
- 5. Java8集合框架——ArrayList源码分析
- 6. Java 集合框架------ArrayList源码分析
- 7. java集合框架之ArrayList
- 8. 集合框架ArrayList
- 9. Java集合ArrayList和HashMap源码学习
- 10. Java集合框架之List---ArrayList与LinkedList源码分析
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
