数据结构之ArrayList
Posted gitzzp
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构之ArrayList相关的知识，希望对你有一定的参考价值。
ArrayList详解
ArrayList概念
ArrayList其实是一个数组，数组是一种线性表数据结构，使用一组连续的内存空间来存储同一种数据类型；特点：
1：增删慢，每次删除元素都要更改数组长度，拷贝和移动元素位置；（为了保证数据的连续性）
2：查询快，可以根据地址+索引的方式快速获取对应位置上的元素；
内存寻址：计算机在分配内存的时候，会给每个内存单元都分配了一个地址，然后通过地址来访问数据；比如new int[5]; 计算机会给数组分配一块连续的内存空间，并且得到这个内存空间的起始位置，比如从0-4；，所以如果要通过地址来访问数据的时候，计算机有一个寻址公式来到得到其地址；
ArrayList类
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
Serializable 标记性接口
不实现这个类的接口将不会使用任何状态序列化或反序列化，可序列化类的所有子类型都是可以序列化的；
而且这个序列化的接口是没有方法或者字段的，仅仅是标识可串行序列化的语义；
那么序列化有什么作用呢？
序列化：将对象得数据写入到文件（写对象）
反序列化：将对象数据从文件中读取出来
不使用就会无法写入数据，写入到文件中；
Cloneable 标记性接口
克隆就是可以创建一份新的完全一样的数据拷贝，如果不实现这个接口，克隆的时候会出问题；CloneNotSupprotedException
源码分析：clone方法其实调用的native层的clone，（super.Clone）的时候，调用的是object对象的clone方法；
拷贝分为以下两种方式：
浅拷贝：基本数据类型可以达到复制，引用数据类型则不可以；引用类型只会拷贝对象的地址，所以当原对象发生改变的时候，拷贝的对象也会发生改变。
使用浅拷贝的时候，该类需要实现Cloneable接口，并且实现clone()方法；
深拷贝：主类的基本数据类型和引用数据类型都可以进行拷贝，但需要注意的是，主类中的所有引用类型数据需要重写clone方法；然后在主类中修改clone方法，clone的时候依次去调用引用类的clone方法。
RandomAccess 标记性接口
该接口主要由List实现，用来表示支持快速随机访问；这个接口的目的是为了让一些通用的算法可以更改行为；比如随机访问列表或者顺序访问列表的时候能够提供更好的性能；
for(int i=0;i=list.size();i++)
list.get(i) // 这种方式就是典型的随机访问列表，因为我们可以根据i来指定我们需要访问具体的某个索引上的值；
随机访问列表的速度要比顺序访问的速度要快
Iterator<String> it = list.iterator();
while (it.hasNext())
it.next();// 这种方式就是典型的顺序访问，因为它的访问顺序是一个接着一个；
AbstractList 抽象类
该类提供了List接口的骨架实现，以最小化实现由“随机存取”数据存储（如阵列）支持的此接口所需的工作量，对于顺序访问数据（例如链表列表），应该使用AbstractSequentialList优先；
要实现一个不可修改的列表，开发者只需要拓展这个类并提供get(int)和size()方法实现；
要实现可修改的列表，开发者必须覆盖set(int,E)方法（否则将抛出UnsupportedOprationException），如果列表可变大小，开发者必须覆盖add(int,E)和remove(int)方法。
根据Collection接口规范中的建议，开发者通常情况下应该提供一个无参以及集合构造函数；
而且程序员不必提供迭代器实现，迭代器和列表迭代器由此类实现；
（以上皆来自JDK官方对于AbstractList定义）
通俗的解释：AbstractList针对List集合做了一些通用的定义，如果你要自定义List，该List的行为与AbstractList中的功能重合，则不必自己实现，然后根据自己的需求去重写AbstractList其他的方法；
ArrayList源码解析
构造函数
public ArrayList() // 无参构造
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
// 当我们调用ArrayList时，会创建一个空数组（Object类型）
public ArrayList(int initialCapacity) // 有参构造
if (initialCapacity > 0)
this.elementData = new Object[initialCapacity]; //创建你传进来大小的数组
else if (initialCapacity == 0)
this.elementData = EMPTY_ELEMENTDATA; // 如果传进来的是0，则默认是个空数组
else
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
public ArrayList(Collection<? extends E> c)
elementData = c.toArray(); // 将集合转成数组 （toArray方法本质上是创建了一个新的数组，新数组的长度一定和集合的size一样）
if ((size = elementData.length) != 0)
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
// 数组的创建和拷贝
elementData = Arrays.copyOf(elementData, size, Object[].class);
else
// replace with empty array. // 将空数组赋值给elementData
this.elementData = EMPTY_ELEMENTDATA;
// 知识点：c.toArray()调用的其实也是Arrays.copyOf方法，而这个方法的底层逻辑都是调用
// System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
// original：源数组 0：源数组起始位置 copy：目标数组，0：目的数组的起始位置；Math.min(original.length, newLength)：要复制的数组元素数量；
// 另外这种方式的拷贝属于浅拷贝；
add(E e)
add方法基本的源码调用阶段如下：
public boolean add(E e)
ensureCapacityInternal(size + 1); // Increments modCount!!
// 扩容之后，将值放在size++的索引上
elementData[size++] = e;
return true;
private void ensureCapacityInternal(int minCapacity)
// 判断elementData是否等于空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// 如果相等，最小的capacity就等于传进来的参数与默认的（10）中最大的数；相当于如果你添加的是第一个数，那么这个时候要需要扩容
// 扩容的时候相当于加10；
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
ensureExplicitCapacity(minCapacity);
private void ensureExplicitCapacity(int minCapacity)
modCount++; //实际修改数组的次数
// 假设第一次调用这个方法，minCapacity会等于系统给的默认值10，你的elementData.length为0，必然走扩容；
// 当你第二次调用的时候，minCapacity等于数组的实际数据长度（比如你添加了2次，那么这个数为2），而elementData.length等于第一次的10，所以不会走扩 // 容数组；
if (minCapacity - elementData.length > 0)
grow(minCapacity); // 扩容数组
private void grow(int minCapacity)
// 将初始化之后的elementData的长度赋值给oldCapacity
int oldCapacity = elementData.length;
// 新数组长度等于老数组长度加上老数组右移1位；这边扩容相当于是原容量的1.5倍；
int newCapacity = oldCapacity + (oldCapacity >> 1); // >> 右移几位可以简单的认为是除以2的几次幂； << 左移可简单认为乘以2的几次幂；
if (newCapacity - minCapacity < 0)//如果新数组的长度减去传进来的长度（10）小于0，就说明这次想要的扩容没意义；
newCapacity = minCapacity;//新数组的长度就等于传进来的（10）；
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);//如果新数组的长度-最大的值还大于0，就给它一个Integer里面最大的值；
// 然后进行拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
add(int index, E element)
public void add(int index, E element)
if (index > size || index < 0) // 判断插入数据的时候是否越界
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
// 跟之前走的方法一样；
ensureCapacityInternal(size + 1);
// original：源数组 0：源数组起始位置 copy：目标数组，0：目的数组的起始位置；Math.min(original.length, newLength)：要复制的数组元素数量；
// 从elementData进行拷贝；从传入的索引开始（比如1）；拷贝到原来的数组；拷贝到位置加1的地方；拷贝的长度为总元素的长度减去传进来的索引位置；
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 将添加进来的元素放到指定的索引上
elementData[index] = element;
size++;
addAll(Collection<? extends E> c)
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;
// 返回是否拷贝成功，如果你传进来的数组长度为0，这里返回的是false；
return numNew != 0;
addAll(int index, Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c)
// 校验索引
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
// 要移动元素的个数 （目标源的长度减去传进来的索引）
int numMoved = size - index;
if (numMoved > 0)
// 使用arrayCopy进行移动
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 真正将数据源（刚传进来的数组）添加到目的
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
E set(int index, E element)
public E set(int index, E element)
if (index >= size) //校验
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
// 取出
E oldValue = (E) elementData[index];
// 替换
elementData[index] = element;
return oldValue;
E get(int index)
public E get(int index)
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
// 直接获取
return (E) elementData[index];
Iterator iterator()
public Iterator<E> iterator()
// 创建一个对象
return new Itr();
private class Itr implements Iterator<E>
protected int limit = ArrayList.this.size;
int cursor; // 游标 指向下一个应该被返回的索引 默认值为0
int lastRet = -1; // 前一个记录 默认值-1
// 将实际修改次数赋值给期望修改次数
int expectedModCount = modCount;
public boolean hasNext()
// 如果当前游标小于limit（list的长度）则说明还有；
return cursor < limit;
public E next()
if (modCount != expectedModCount)//如果实际修改的次数不等于预期修改的次数；错误叫：并发修改异常
throw new ConcurrentModificationException();
// 将游标赋值给i
int i = cursor;
if (i >= limit) //大于则抛出异常
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;//获取arraylist中的elementData数组
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;//游标+1
return (E) elementData[lastRet = i];//从数组中取出元素并返回
list.remove(Object o)
public boolean remove(Object o)
if (o == null) // 判断是否为null，为null就删除
for (int index = 0; index < size; index++)
if (elementData[index] == null)
fastRemove(index);
return true;
else
// 处理不为null的情况
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);
// 将删除的元素置为null，让GC回收 --size 等于size-1
elementData[--size] = null; // clear to let GC do its work
iterator.remove()
public void remove()
if (lastRet < 0)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
try
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
// 迭代器的删除方法主要是
expectedModCount = modCount;
limit--;
catch (IndexOutOfBoundsException ex)
throw new ConcurrentModificationException();
clear()
public void clear()
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
// 全部置为nul，让GC好回收，size直接赋值为0
size = 0;
contains(Object o)
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;
return -1;
isEmpty()
public boolean isEmpty()
return size == 0;
问题：
ArrayList频繁扩容导致性能低下如何优化？
答：原因：主要是因为每次都是1.5倍的扩容，第一次默认是10；所以如果数据够大，扩容的次数就会增加；可以通过创建ArrayList的时候直接指定数组长度；
优化删除方式，数组在删除数据的时候会进行数据的迁移，如果频繁删除，可以前期先使用某种方式记录下来，然后集中在一起进行删除；
System.arraycopy是属于深拷贝还是浅拷贝？
答：浅拷贝
如果拷贝的是一个二维数组，拷贝之后修改新的数组是否会影响之前的数据？（数组中的数据都是基本类型）
答：会影响，因为数组是引用类型，拷贝底层是浅拷贝，所以只会复制引用；
ArrayList是否线程安全？
答：线程不安全，如果多个线程要进行访问，可使用同步关键字；也可以使用Vector来替代List，它内部实现了线程安全；但Vector的速度相对来说比较慢；
以上是关于数据结构之ArrayList的主要内容，如果未能解决你的问题，请参考以下文章