概述
Resizable-array implementation of the <tt>List</tt> interface. 可变大小的数组(实现了List接口);
Implements all optional list operations, and permits all elements, including null. 实现了List的所有操作,允许所有的元素(包括null);
<p>The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>, <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant time.
size、isEmpty、get、set、iterator、listIterator操作需要 O(1)时间;
The <tt>add</tt> operation runs in <i>amortized constant time</i>, that is, adding n elements requires O(n) time.
add操作 添加n个元素,需要O(n);
<p>An application can increase the capacity of an<tt>ArrayList</tt> instance before adding a large number of elements using the <tt>ensureCapacity</tt> operation.
在添加大数量的元素前,会使用ensureCapacity确保ArrayList容量;
Note that this implementation is not synchronized. ArrayList的实现是非同步的;
If multiple threads access an <tt>ArrayList</tt> instance concurrently, and at least one of the threads modifies the list structurally, it <i>must</i> be synchronized externally.
如果多个线程并发访问ArrayList,必须在外部进行同步;
A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.
结构修改:添加、删除元素、数组重置大小; (多于多线程并发 需要进行同步操作)
If no such object exists, the list should be "wrapped" using the {@link Collections#synchronizedList Collections.synchronizedList} method.
可以使用 Collections.synchronizedList 实现同步;
The iterators returned by this class's {@link #iterator() iterator} and {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
iterator、listIterator 方法是fail-fast;
if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own {@link ListIterator#remove() remove}
or {@linkListIterator#add(Object) add} methods, the iterator will throw a {@link ConcurrentModificationException}.
如果创建了iterator,调用iterator的remove、add将会抛出ConcurrentModificationException(实际用的是子类的java.util.ArrayList.Itr)
链路
add
// java.util.ArrayList.add(E) public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } // java.util.ArrayList.ensureCapacityInternal private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); } // java.util.ArrayList.calculateCapacity private static int calculateCapacity(Object[] elementData, int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; } // java.util.ArrayList.ensureExplicitCapacity private void ensureExplicitCapacity(int minCapacity) { modCount++; // modCount递增 // overflow-conscious code if (minCapacity - elementData.length > 0) // 容量不足,扩容 grow(minCapacity); } // java.util.ArrayList.grow private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量 = 旧容量 + 旧容量/2 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); // 将元素旧数据 copy到 新数组中 }
同步ArrayList(Collections.synchronizedList(new ArrayList<>());)
链路
add(E e)
// java.util.Collections.synchronizedList(java.util.List<T>) public static <T> List<T> synchronizedList(List<T> list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList<>(list) : // ArrayList实现了RandomAccess new SynchronizedList<>(list)); } // java.util.Collections.SynchronizedRandomAccessList.SynchronizedRandomAccessList(java.util.List<E>) SynchronizedRandomAccessList(List<E> list) { super(list); } // java.util.Collections.SynchronizedList.SynchronizedList(java.util.List<E>) SynchronizedList(List<E> list) { super(list); this.list = list; } // java.util.Collections.SynchronizedCollection.add // SynchronizedRandomAccessList继承了SynchronizedList,SynchronizedList继承了SynchronizedCollection,调用的是SynchronizedCollection的add public boolean add(E e) { synchronized (mutex) {return c.add(e);} }
标签:java,ArrayList,list,util,add,minCapacity From: https://www.cnblogs.com/anpeiyong/p/17798046.html