ArrayList是我们使用得最多的一个集合类之一
一般用来做包装DTO到view层来显示数据.
ArrayList继承了AbstractList类,实现了List,RandomAccess,Cloneable接口
- public class ArrayList<E> extends AbstractList<E>
- implements List<E>, RandomAccess, Cloneable, java.io.Serializable
内部结构是一个Object类型的数组
- private transient Object[] elementData;
ArrayList的大小,也就是元素个数
- private int size;
下面是几个构造函数:
1.自定义初始化容量的构造函数:
- public ArrayList(int initialCapacity) {
- super();
- if (initialCapacity < 0)//初始化容量不能小于0,抛出IllegalArgumentException异常
- throw new IllegalArgumentException("Illegal Capacity: "+
- initialCapacity);
- this.elementData = new Object[initialCapacity];//根据参数初始化一个数组,底层是个object数组
- }
2.默认构造函数:
调用上面的构造函数,默认初始化内部数组大小为10
- public ArrayList() {
- this(10);//默认初始容量是10
- }
3.collection转换的构造函数:
- public ArrayList(Collection<? extends E> c) {
- elementData = c.toArray();//调用toArray()方法把collection转换成数组
- size = elementData.length;//把数组的长度赋值给ArrayList的size属性
- // c.toArray might (incorrectly) not return Object[] (see 6260652)
- if (elementData.getClass() != Object[].class)
- elementData = Arrays.copyOf(elementData, size, Object[].class);
- }
返回ArrayList的大小:
- public int size() {
- return size;
- }
判断是否为空:
- public boolean isEmpty() {
- return size == 0;//就是看当前size是否为0
- }
找出一个元素第一次出现的下标:
- public int indexOf(Object o) {
- //由于数组的下标是从0开始的,所以判断是否存在只要大于0就可以了
- if (o == null) {
- for (int i = 0; i < size; i++)//注意这里是size属性而不是elementData的length
- if (elementData[i]==null)
- return i;
- } else {
- for (int i = 0; i < size; i++)
- if (o.equals(elementData[i]))//equals方法来判断
- return i;
- }
- return -1;//没有的话返回-1
- }
判断是否包含一个元素:
- public boolean contains(Object o) {
- return indexOf(o) >= 0;//不存在是-1
- }
元素最后一次出现的下标:
- public int lastIndexOf(Object o) {
- if (o == null) {
- for (int i = size-1; i >= 0; i--)//注意这里的i是等于数组长度减1,从数组的最后一位开始
- 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空间为元素多少的真实大小:
注意size一般和内部结构的数组长度是不一样的,通过上面的构造函数我们知道内部数组初始化容量是10,
而size是在add()方法后才加一,这个方法是保证列表的大小和内部数组的大小一致
- public void trimToSize() {
- modCount++;
- int oldCapacity = elementData.length;
- if (size < oldCapacity) {
- elementData = Arrays.copyOf(elementData, size);
- }
- }
如有必要,增加此 ArrayList 实例的容量,以确保它至少能够容纳最小容量参数所指定的元素数
因为每次重新分配空间都是比较消耗时间的,所以如果能预计list可能的大小
的话可以通过自己的控制ArrayList的大小来提高效率
- public void ensureCapacity(int minCapacity) {//注意是public类型,也就是说可以我门自己来重新分配空间
- modCount++;
- int oldCapacity = elementData.length;//老的容量
- if (minCapacity > oldCapacity) {
- Object oldData[] = elementData;//把当前数组临时保存起来
- int newCapacity = (oldCapacity * 3)/2 + 1;//加1是为了保证oldCapacity为1或者0的情况下
- if (newCapacity < minCapacity)//是按1.5被来增加容量的
- newCapacity = minCapacity;
- // minCapacity is usually close to size, so this is a win:
- elementData = Arrays.copyOf(elementData, newCapacity);
- }
- }
clone一个副本:
- public Object clone() {
- try {
- ArrayList<E> v = (ArrayList<E>) 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();
- }
- }
转换为数组:
- public Object[] toArray() {
- return Arrays.copyOf(elementData, size);//调用Arrays.copyOf()方法
- }
下面是转换为泛型数组:
- public <T> T[] toArray(T[] a) {
- if (a.length < size)
- // Make a new array of a's runtime type, but my contents:
- return (T[]) Arrays.copyOf(elementData, size, a.getClass());
- System.arraycopy(elementData, 0, a, 0, size);
- if (a.length > size)
- a[size] = null;
- return a;
- }
范围检查:臭名昭著的 IndexOutOfBoundsException异常
- private void RangeCheck(int index) {
- (index >= size)//数组越界,这里没有判断小于0的情况
- throw new IndexOutOfBoundsException(
- ndex: "+index+", Size: "+size);
- }
通过下标得到一个元素:
- public E get(int index) {
- RangeCheck(index);//先检查是否越界
- return (E) elementData[index];//返回的是数组中的下标 }
通过下标和一个元素赋值,返回的是原先的值:
- public E set(int index, E element) {
- RangeCheck(index);//先检查是否越界
- E oldValue = (E) elementData[index];//通过临时变量把当前下标的值保存
- elementData[index] = element;//赋值
- return oldValue;//注意返回的是当前下标的原先值
- }
添加一个新的元素到末尾,前面说道新增方法都要先调用ensureCapacity方法:
- public boolean add(E e) {
- ensureCapacity(size + 1); //大小加一 // Increments modCount!!
- elementData[size++] = e;//size默认是0所以是从0开始赋值
- return true;
- }
API文档中的说明是:将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素(如果有)以及所有后续元素(将其索引加 1)。通俗的说法是在指定位置插入元素,指定元素和后面的元素后移
这个方法和set(int index, E element) 不一样,set只是把元素赋值给指定的下标同时返回下标的原先值.
add(int index, E element)的判断越界是通过元素的大小来判断的
所以如果
- ArrayList list=new ArrayList();
- list.add(1, 8);
- //报错,因为size元素大小还是0
- //如果l
- list.add(0,"")//就可以
如果一致add同一下标所有后续元素索引加1
如下:
- ArrayList list=new ArrayList();
- list.add(0, 8);
- list.add(0, 8);
- list.add(0, 8);
- System.out.println(list);
- //结果为[8, 8, 8]
:
- public void add(int index, E element) {
- if (index > size || index < 0)//判断是否越界,注意这里是以元素的个数来判断的
- throw new IndexOutOfBoundsException(
- "Index: "+index+", Size: "+size);
- ensureCapacity(size+1); // Increments modCount!!
- System.arraycopy(elementData, index, elementData, index + 1,
- size - index);
- //源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到
- //目标数组中的 destPos 到 destPos+length-1 位置
- elementData[index] = element;
- size++;//元素加一
- }
删除指定位置的元素,返回被删除的元素,由于ArrayList采用一个对象数组存储元素,所以在删除一个元素时需要把后面的元素前移。删除一个元素时只是把该元素在elementData数组中的引用置为null,具体的对象的销毁由垃圾收集器负责
- public E remove(int index) {
- RangeCheck(index);//判断是否越界
- modCount++;
- E oldValue = (E) elementData[index];
- int numMoved = size - index - 1;//新的数组长度
- if (numMoved > 0)
- System.arraycopy(elementData, index+1, elementData, index,
- numMoved);
- elementData[--size] = null; // Let gc do its work
- return oldValue;//返回删除前的数据
- }
内部删除方法,跳过越界检查,不返回删除元素的值:ArrayList内部调用的删除方法
- /*
- * 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; // Let gc do its work
- }
删除指定元素:
- 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;
- }
清空列表:
- public void clear() {
- modCount++;
- // Let gc do its work
- for (int i = 0; i < size; i++)
- elementData[i] = null;
- size = 0;//设定元素大小为0
- }
添加集合c中的元素到ArrayList的末尾,添加成功返回true,如果集合c为空,返回false。
- public boolean addAll(Collection<? extends E> c) {
- Object[] a = c.toArray();
- int numNew = a.length;
- ensureCapacity(size + numNew); // Increments modCount
- System.arraycopy(a, 0, elementData, size, numNew);//添加到列表的末尾
- size += numNew;
- return numNew != 0;
- }
在指定位置插入集合中的所有元素,和上面一个方法基本差不多,指定位置元素和以后的都要后移
-
- protected void removeRange(int fromIndex, int toIndex) {
- modCount++;
- int numMoved = size - toIndex;
- System.arraycopy(elementData, toIndex, elementData, fromIndex,
- numMoved);
- // Let gc do its work
- int newSize = size - (toIndex-fromIndex);
- while (size != newSize)
- elementData[--size] = null;
- }
结合API文档和网上搜索来的ArrayList的特效来总结下:
API文档是如此介绍ArrayList的:
接口的大小可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。(此类大致上等同于 Vector 类,除了此类是不同步的。)
Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差。
List允许有相同的元素
ArrayList的方法都没有同步,所以在多线程中是不安全的,必须自己同步
toArray()方法返回的是和原列表相同的对象,也就是说:
arrayList.toArray()[0]==arrayList.get(0)返回的是true(假定arrayList不空)。clone()方法是一个浅拷贝。
API文档:
在添加大量元素前,应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量
可以通过自己调用ensureCapacity()提高效率创建同步线程的ArrayList
List list = Collections.synchronizedList(new ArrayList(...));
ArrayList提供了4种添加方法:
- list.add(e);
- list.add(index, element);
- list.addAll(c);
- list.addAll(index, c);
每次添加都调用ensureCapacity()方法,扩大容量是每次是1.5倍
- list.set(index, element);
- list.add(index, element);
set是用指定的元素替代此列表中指定位置上的元素
add是将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素
对于新增和删除操作add和remove,ArrayList要移动数据。所以性能不是很好
而访问数据是直接根据数组下标来获得数据的,所以速度很快
移除ArrayList内重复数据:
- public static void removeDuplicate(List arlList) {
- HashSet h = new HashSet(arlList);
- arlList.clear();
- arlList.addAll(h);
- }
除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个 ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。