ArrayList
来源:互联网 发布:斗鱼主播都用什么软件 编辑:程序博客网 时间:2024/06/05 15:53
1、基础
ArrayList简介
ArrayList 是一个数组队列,相当于 动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。稍后,我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList。
构造方法
// 默认构造函数ArrayList()// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时,容量会添加上一次容量大小的一半。ArrayList(int capacity)// 创建一个包含collection的ArrayListArrayList(Collection<? extends E> collection)
API
boolean add(E e)将指定的元素追加到此列表的末尾。void add(int index, E element)在此列表中的指定位置插入指定的元素。boolean addAll(Collection<? extends E> c)按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。boolean addAll(int index, Collection<? extends E> c)将指定集合中的所有元素插入到此列表中,从指定的位置开始。void clear()从列表中删除所有元素。Object clone()返回此 ArrayList实例的浅拷贝。boolean contains(Object o)如果此列表包含指定的元素,则返回 true 。void ensureCapacity(int minCapacity)如果需要,增加此 ArrayList实例的容量,以确保它可以至少保存最小容量参数指定的元素数。void forEach(Consumer<? super E> action)对 Iterable的每个元素执行给定的操作,直到所有元素都被处理或动作引发异常。E get(int index)返回此列表中指定位置的元素。int indexOf(Object o)返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。boolean isEmpty()如果此列表不包含元素,则返回 true 。Iterator<E> iterator()以正确的顺序返回该列表中的元素的迭代器。int lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。ListIterator<E> listIterator()返回列表中的列表迭代器(按适当的顺序)。ListIterator<E> listIterator(int index)从列表中的指定位置开始,返回列表中的元素(按正确顺序)的列表迭代器。E remove(int index)删除该列表中指定位置的元素。boolean remove(Object o)从列表中删除指定元素的第一个出现(如果存在)。boolean removeAll(Collection<?> c)从此列表中删除指定集合中包含的所有元素。boolean removeIf(Predicate<? super E> filter)删除满足给定谓词的此集合的所有元素。protected void removeRange(int fromIndex, int toIndex)从这个列表中删除所有索引在 fromIndex (含)和 toIndex之间的元素。void replaceAll(UnaryOperator<E> operator)将该列表的每个元素替换为将该运算符应用于该元素的结果。boolean retainAll(Collection<?> c)仅保留此列表中包含在指定集合中的元素。E set(int index, E element)用指定的元素替换此列表中指定位置的元素。int size()返回此列表中的元素数。void sort(Comparator<? super E> c)使用提供的 Comparator对此列表进行排序以比较元素。Spliterator<E> spliterator()在此列表中的元素上创建late-binding和故障快速 Spliterator 。List<E> subList(int fromIndex, int toIndex)返回此列表中指定的 fromIndex (包括)和 toIndex之间的独占视图。Object[] toArray()以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。<T> T[] toArray(T[] a)以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素); 返回的数组的运行时类型是指定数组的运行时类型。void trimToSize()修改这个 ArrayList实例的容量是列表的当前大小。
2、数据结构
java.lang.Object ↳ java.util.AbstractCollection<E> ↳ java.util.AbstractList<E> ↳ java.util.ArrayList<E>public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
ArrayList包含了两个重要的对象:elementData 和 size。
1 elementData 是”Object[]类型的数组”,它保存了添加到ArrayList中的元素。实际上,elementData是个动态数组,我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity;如果通过不含参数的构造函数ArrayList()来创建ArrayList,则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增长而动态的增长,具体的增长方式,请参考源码分析中的ensureCapacity()函数。
2 size 则是动态数组的实际大小。
3 数组的复制使用Arrays.copyOf,实际调用System.arraycopy进行数组的高效复制
3、源码分析 java 1.8
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{//默认数组容量private static final int DEFAULT_CAPACITY = 10;//实际存储数据的数组transient Object[] elementData; // non-private to simplify nested class access//默认构造函数 public ArrayList() { //private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; this.elementData = 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); } }//创建一个包含collection的ArrayList 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) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } } // 确定ArrarList的容量。 // 若ArrayList的容量不足以容纳当前的全部元素,则扩充容量 public void ensureCapacity(int minCapacity) { int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY; if (minCapacity > minExpand) { 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; //原长度+原长度/2 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //防止超过Integer最大值 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); }//是否包含元素public boolean contains(Object o) { return indexOf(o) >= 0; } //遍历o 如果有,返回下标 没有返回-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++) if (o.equals(elementData[i])) return i; } return -1; } //clone进行的是深复制 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); } } E elementData(int index) { return (E) elementData[index]; } // 获取index位置的元素值 public E get(int index) { rangeCheck(index); return elementData(index); } //设置index位置的值为element public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; } //追加 public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } //移除 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; }}
源码比较简单,主要是grow(int minCapacity)方法的自动增长。
1.8与1.6相比,new ArrayList时,数组长度为0。当添加一个元素时,才将数组的默认长度设为10.
1.8版本为集合增加了lamda表达式。
3.2 快速迭代失败
public ArrayList:Iterator<E> iterator() { return new Itr(); } /** * An optimized version of AbstractList.Itr */ private class Itr implements Iterator<E> { //将modCount赋值给expectedModCount 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; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } final void checkForComodification() { //比较expectedModCount modCount不同 则抛异常 if (modCount != expectedModCount) throw new ConcurrentModificationException(); } }
ArrayList通过iterator()获取迭代器,Itr是ArrayList的内部类,在调用next()时会调用checkForComodification()。
在new Itr();时,Itr的变量expectedModCount会保存modCount的值。当修改数组时会修改modCount的值。如果调用了包含checkForComodification的方法,都会抛出ConcurrentModificationException异常。
即:调用Iterator iter=iterator()方法后,如果调用ArrayList的方法修改了数组,再次调用Iterator的一些包含checkForComodification的方法,会报ConcurrentModificationException异常。
如果想避免,则可以使用Iterator的实现修改数组。或者使用ArrayList的方法修改数组后,再次调用iterator()方法
4、遍历
public static void main(String[] args) { List list = new ArrayList(); for (int i = 0; i < 1000000; i++) list.add(i); forTraverse(list); forIteratorTraverse(list); iteratorTraverse(list); } //普通for循环遍历 public static void forTraverse(List list) { long startTime; long endTime; startTime = System.currentTimeMillis(); for (int i=0; i<list.size(); i++) { list.get(i); } endTime = System.currentTimeMillis(); long interval = endTime - startTime; System.out.println("iteratorThroughRandomAccess:" + interval+" ms"); } //for循环迭代器 public static void forIteratorTraverse(List list) { long startTime; long endTime; startTime = System.currentTimeMillis(); for(Iterator iter = list.iterator(); iter.hasNext(); ) { iter.next(); } endTime = System.currentTimeMillis(); long interval = endTime - startTime; System.out.println("iteratorThroughIterator:" + interval+" ms"); } //foreach public static void iteratorTraverse(List list) { long startTime; long endTime; startTime = System.currentTimeMillis(); for(Object obj:list) ; endTime = System.currentTimeMillis(); long interval = endTime - startTime; System.out.println("iteratorThroughFor2:" + interval+" ms"); }
每次遍历所用时间不固定,根据电脑不同,用时也不同
但是总的来说 遍历所用时间forTraverse < iteratorTraverse < forIteratorTraverse
5、注意事项
5.1 toArray ClassCastException异常
ArrayList转为数组形式有两个方法
//不带泛型public Object[] toArray() { return Arrays.copyOf(elementData, size); } //带泛型 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; }
当使用toArray()将返回值强转为非Object类型对象时,由于ArrayList内部将元素存储为Object类型,Object对象强转为具体类型如Integer对象,因为Object对象没有Integer的类型信息,所以强转会报ClassCastException
使用 T[] toArray(T[] a)时,会有泛型操作,所以如果使用正确,不会出现ClassCastException
5.2 遍历删除
public static void main(String[] args) { List list = new ArrayList(); list.add("1"); list.add("1"); list.add("3"); for (int i = 0; i < list.size(); i++) { if(list.get(i).equals("1")) list.remove("1"); } System.out.println(list.toString()); }
结果会打印[1, 3]
,里面的里面的”1”是第二个”1”.
一开始list为
避免这种错误可以倒序遍历删除。
5.2.2 迭代器遍历删除
迭代器遍历时,用ArrayList的remove会报ConcurrentModificationException。可以使用Iterator提供的remove方法
详见 3.2
参考:
http://www.cnblogs.com/skywang12345/p/3308556.html
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- ArrayList
- C++模板实现单链表
- git 库中有库的问题
- DeepLearning_SparseAutoencoder
- selenium 小结
- 1017
- ArrayList
- hdu 4055 Number String【递推】
- Cookie Choice II ZOJ
- java子父类继承时方法重写与属性覆盖
- Java/Android 设计模式系列(12)--组合模式
- C#-WinForm班级下拉框数据绑定
- Html(快捷键!+Tab)
- java定位选择店铺
- UVA11082MatrixDecompressing