List集合一覽圖
1.ArrayList:
底層是數組，線程不安全；
2.LinkedList:
底層是鏈表，線程不安全；
3.Vector
底層數據結構是數組。線程安全；
1.List接口
public interface List<E> extends Collection<E> {
// Query Operations
/**
* Returns the number of elements in this list. If this list contains
* more than {@code Integer.MAX_VALUE} elements, returns
* {@code Integer.MAX_VALUE}.
*
* @return the number of elements in this list
返回此列表中的元素數
*/
int size();
/**
* Returns {@code true} if this list contains no elements.
*
* @return {@code true} if this list contains no elements
如果此列表不包含任何元素，則返回true
*/
boolean isEmpty();
/**
* Returns {@code true} if this list contains the specified element.
* More formally, returns {@code true} if and only if this list contains
* at least one element {@code e} such that
* {@code Objects.equals(o, e)}.
*
* @param o element whose presence in this list is to be tested
* @return {@code true} if this list contains the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this list
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* list does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
此列表是否包含指定的元素,包含返回true
*/
boolean contains(Object o);
/**
* Returns an iterator over the elements in this list in proper sequence.
*
* @return an iterator over the elements in this list in proper sequence
以適當的順序返回對該列表中的元素的迭代器
*/
Iterator<E> iterator();
/**
* Returns an array containing all of the elements in this list in proper
* sequence (from first to last element).
*
* <p>The returned array will be "safe" in that no references to it are
* maintained by this list. (In other words, this method must
* allocate a new array even if this list is backed by an array).
* The caller is thus free to modify the returned array.
*
* <p>This method acts as bridge between array-based and collection-based
* APIs.
*
* @return an array containing all of the elements in this list in proper
* sequence
* @see Arrays#asList(Object[])
返回一個包含此列表中所有元素的數組
*/
Object[] toArray();
/**
* Returns an array containing all of the elements in this list in
* proper sequence (from first to last element); the runtime type of
* the returned array is that of the specified array. If the list fits
* in the specified array, it is returned therein. Otherwise, a new
* array is allocated with the runtime type of the specified array and
* the size of this list.
*
* <p>If the list fits in the specified array with room to spare (i.e.,
* the array has more elements than the list), the element in the array
* immediately following the end of the list is set to {@code null}.
* (This is useful in determining the length of the list <i>only</i> if
* the caller knows that the list does not contain any null elements.)
*
* <p>Like the {@link #toArray()} method, this method acts as bridge between
* array-based and collection-based APIs. Further, this method allows
* precise control over the runtime type of the output array, and may,
* under certain circumstances, be used to save allocation costs.
*
* <p>Suppose {@code x} is a list known to contain only strings.
* The following code can be used to dump the list into a newly
* allocated array of {@code String}:
*
* <pre>{@code
* String[] y = x.toArray(new String[0]);
* }</pre>
*
* Note that {@code toArray(new Object[0])} is identical in function to
* {@code toArray()}.
*
* @param a the array into which the elements of this list are to
* be stored, if it is big enough; otherwise, a new array of the
* same runtime type is allocated for this purpose.
* @return an array containing the elements of this list
* @throws ArrayStoreException if the runtime type of the specified array
* is not a supertype of the runtime type of every element in
* this list
返回一個數組，該數組按適當順序（從第一個元素到最後一個元素）包含此列表中的所有元素；返
回數組的運行時類型是指定數組的運行時類型。
* @throws NullPointerException if the specified array is null
*/
<T> T[] toArray(T[] a);
// Modification Operations
/**
* Appends the specified element to the end of this list (optional
* operation).
*
* <p>Lists that support this operation may place limitations on what
* elements may be added to this list. In particular, some
* lists will refuse to add null elements, and others will impose
* restrictions on the type of elements that may be added. List
* classes should clearly specify in their documentation any restrictions
* on what elements may be added.
*
* @param e element to be appended to this list
* @return {@code true} (as specified by {@link Collection#add})
* @throws UnsupportedOperationException if the {@code add} operation
* is not supported by this list
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list
* @throws NullPointerException if the specified element is null and this
* list does not permit null elements
* @throws IllegalArgumentException if some property of this element
* prevents it from being added to this list
將指定的元素追加到此列表的末尾
*/
boolean add(E e);
/**
* Removes the first occurrence of the specified element from this list,
* if it is present (optional operation). If this list does not contain
* the element, it is unchanged. More formally, removes the element with
* the lowest index {@code i} such that
* {@code Objects.equals(o, get(i))}
* (if such an element exists). Returns {@code true} if this list
* contained the specified element (or equivalently, if this list changed
* as a result of the call).
*
* @param o element to be removed from this list, if present
* @return {@code true} if this list contained the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this list
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* list does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws UnsupportedOperationException if the {@code remove} operation
* is not supported by this list
如果存在指定元素，則從列表中刪除該元素的第一次出現
*/
boolean remove(Object o);
// Bulk Modification Operations
/**
* Returns {@code true} if this list contains all of the elements of the
* specified collection.
*
* @param c collection to be checked for containment in this list
* @return {@code true} if this list contains all of the elements of the
* specified collection
* @throws ClassCastException if the types of one or more elements
* in the specified collection are incompatible with this
* list
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified collection contains one
* or more null elements and this list does not permit null
* elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #contains(Object)
如果此列表包含指定集合的所有元素，則返回
*/
boolean containsAll(Collection<?> c);
/**
* Appends all of the elements in the specified collection to the end of
* this list, in the order that they are returned by the specified
* collection's iterator (optional operation). The behavior of this
* operation is undefined if the specified collection is modified while
* the operation is in progress. (Note that this will occur if the
* specified collection is this list, and it's nonempty.)
*
* @param c collection containing elements to be added to this list
* @return {@code true} if this list changed as a result of the call
* @throws UnsupportedOperationException if the {@code addAll} operation
* is not supported by this list
* @throws ClassCastException if the class of an element of the specified
* collection prevents it from being added to this list
* @throws NullPointerException if the specified collection contains one
* or more null elements and this list does not permit null
* elements, or if the specified collection is null
* @throws IllegalArgumentException if some property of an element of the
* specified collection prevents it from being added to this list
* @see #add(Object)
將指定集合中的所有元素按指定集合的迭代器返回的順序追加到此列表的末尾
*/
boolean addAll(Collection<? extends E> c);
/**
* Inserts all of the elements in the specified collection into this
* list at the specified position (optional operation). Shifts the
* element currently at that position (if any) and any subsequent
* elements to the right (increases their indices). The new elements
* will appear in this list in the order that they are returned by the
* specified collection's iterator. The behavior of this operation is
* undefined if the specified collection is modified while the
* operation is in progress. (Note that this will occur if the specified
* collection is this list, and it's nonempty.)
*
* @param index index at which to insert the first element from the
* specified collection
* @param c collection containing elements to be added to this list
* @return {@code true} if this list changed as a result of the call
* @throws UnsupportedOperationException if the {@code addAll} operation
* is not supported by this list
* @throws ClassCastException if the class of an element of the specified
* collection prevents it from being added to this list
* @throws NullPointerException if the specified collection contains one
* or more null elements and this list does not permit null
* elements, or if the specified collection is null
* @throws IllegalArgumentException if some property of an element of the
* specified collection prevents it from being added to this list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index > size()})
將指定集合中的所有元素插入此列表中的指定位置
*/
boolean addAll(int index, Collection<? extends E> c);
/**
* Removes from this list all of its elements that are contained in the
* specified collection (optional operation).
*
* @param c collection containing elements to be removed from this list
* @return {@code true} if this list changed as a result of the call
* @throws UnsupportedOperationException if the {@code removeAll} operation
* is not supported by this list
* @throws ClassCastException if the class of an element of this list
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this list contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
從此列表中刪除指定集合中包含的所有其元素
*/
boolean removeAll(Collection<?> c);
/**
* Retains only the elements in this list that are contained in the
* specified collection (optional operation). In other words, removes
* from this list all of its elements that are not contained in the
* specified collection.
*
* @param c collection containing elements to be retained in this list
* @return {@code true} if this list changed as a result of the call
* @throws UnsupportedOperationException if the {@code retainAll} operation
* is not supported by this list
* @throws ClassCastException if the class of an element of this list
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this list contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
僅保留此列表中指定集合中包含的元素
*/
boolean retainAll(Collection<?> c);
/**
* Replaces each element of this list with the result of applying the
* operator to that element. Errors or runtime exceptions thrown by
* the operator are relayed to the caller.
*
* @implSpec
* The default implementation is equivalent to, for this {@code list}:
* <pre>{@code
* final ListIterator<E> li = list.listIterator();
* while (li.hasNext()) {
* li.set(operator.apply(li.next()));
* }
* }</pre>
*
* If the list's list-iterator does not support the {@code set} operation
* then an {@code UnsupportedOperationException} will be thrown when
* replacing the first element.
*
* @param operator the operator to apply to each element
* @throws UnsupportedOperationException if this list is unmodifiable.
* Implementations may throw this exception if an element
* cannot be replaced or if, in general, modification is not
* supported
* @throws NullPointerException if the specified operator is null or
* if the operator result is a null value and this list does
* not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @since 1.8
用將該運算符應用於該元素的結果替換此列表中的每個元素
*/
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
/**
* Sorts this list according to the order induced by the specified
* {@link Comparator}. The sort is <i>stable</i>: this method must not
* reorder equal elements.
*
* <p>All elements in this list must be <i>mutually comparable</i> using the
* specified comparator (that is, {@code c.compare(e1, e2)} must not throw
* a {@code ClassCastException} for any elements {@code e1} and {@code e2}
* in the list).
*
* <p>If the specified comparator is {@code null} then all elements in this
* list must implement the {@link Comparable} interface and the elements'
* {@linkplain Comparable natural ordering} should be used.
*
* <p>This list must be modifiable, but need not be resizable.
*
* @implSpec
* The default implementation obtains an array containing all elements in
* this list, sorts the array, and iterates over this list resetting each
* element from the corresponding position in the array. (This avoids the
* n<sup>2</sup> log(n) performance that would result from attempting
* to sort a linked list in place.)
*
* @implNote
* This implementation is a stable, adaptive, iterative mergesort that
* requires far fewer than n lg(n) comparisons when the input array is
* partially sorted, while offering the performance of a traditional
* mergesort when the input array is randomly ordered. If the input array
* is nearly sorted, the implementation requires approximately n
* comparisons. Temporary storage requirements vary from a small constant
* for nearly sorted input arrays to n/2 object references for randomly
* ordered input arrays.
*
* <p>The implementation takes equal advantage of ascending and
* descending order in its input array, and can take advantage of
* ascending and descending order in different parts of the same
* input array. It is well-suited to merging two or more sorted arrays:
* simply concatenate the arrays and sort the resulting array.
*
* <p>The implementation was adapted from Tim Peters's list sort for Python
* (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
* TimSort</a>). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993.
*
* @param c the {@code Comparator} used to compare list elements.
* A {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used
* @throws ClassCastException if the list contains elements that are not
* <i>mutually comparable</i> using the specified comparator
* @throws UnsupportedOperationException if the list's list-iterator does
* not support the {@code set} operation
* @throws IllegalArgumentException
* (<a href="Collection.html#optional-restrictions">optional</a>)
* if the comparator is found to violate the {@link Comparator}
* contract
* @since 1.8
根據指定的順序對列表進行排序
*/
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
/**
* Removes all of the elements from this list (optional operation).
* The list will be empty after this call returns.
*
* @throws UnsupportedOperationException if the {@code clear} operation
* is not supported by this list
從此列表中刪除所有元素
*/
void clear();
// Comparison and hashing
/**
* Compares the specified object with this list for equality. Returns
* {@code true} if and only if the specified object is also a list, both
* lists have the same size, and all corresponding pairs of elements in
* the two lists are <i>equal</i>. (Two elements {@code e1} and
* {@code e2} are <i>equal</i> if {@code Objects.equals(e1, e2)}.)
* In other words, two lists are defined to be
* equal if they contain the same elements in the same order. This
* definition ensures that the equals method works properly across
* different implementations of the {@code List} interface.
*
* @param o the object to be compared for equality with this list
* @return {@code true} if the specified object is equal to this list
比較指定對象與此列表是否相等
*/
boolean equals(Object o);
/**
* Returns the hash code value for this list. The hash code of a list
* is defined to be the result of the following calculation:
* <pre>{@code
* int hashCode = 1;
* for (E e : list)
* hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
* }</pre>
* This ensures that {@code list1.equals(list2)} implies that
* {@code list1.hashCode()==list2.hashCode()} for any two lists,
* {@code list1} and {@code list2}, as required by the general
* contract of {@link Object#hashCode}.
*
* @return the hash code value for this list
* @see Object#equals(Object)
* @see #equals(Object)
返回此列表的哈希碼值
*/
int hashCode();
// Positional Access Operations
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index >= size()})
返回此列表中指定位置的元素
*/
E get(int index);
/**
* Replaces the element at the specified position in this list with the
* specified element (optional operation).
*
* @param index index of the element to replace
* @param element element to be stored at the specified position
* @return the element previously at the specified position
* @throws UnsupportedOperationException if the {@code set} operation
* is not supported by this list
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list
* @throws NullPointerException if the specified element is null and
* this list does not permit null elements
* @throws IllegalArgumentException if some property of the specified
* element prevents it from being added to this list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index >= size()})
用指定的元素替換此列表中指定位置的元素
*/
E set(int index, E element);
/**
* Inserts the specified element at the specified position in this list
* (optional operation). Shifts the element currently at that position
* (if any) and any subsequent elements to the right (adds one to their
* indices).
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws UnsupportedOperationException if the {@code add} operation
* is not supported by this list
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list
* @throws NullPointerException if the specified element is null and
* this list does not permit null elements
* @throws IllegalArgumentException if some property of the specified
* element prevents it from being added to this list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index > size()})
將指定的元素插入此列表中的指定位置
*/
void add(int index, E element);
/**
* Removes the element at the specified position in this list (optional
* operation). Shifts any subsequent elements to the left (subtracts one
* from their indices). Returns the element that was removed from the
* list.
*
* @param index the index of the element to be removed
* @return the element previously at the specified position
* @throws UnsupportedOperationException if the {@code remove} operation
* is not supported by this list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index >= size()})
刪除此列表中指定位置的元素
*/
E remove(int index);
// Search Operations
/**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index {@code i} such that
* {@code Objects.equals(o, get(i))},
* or -1 if there is no such index.
*
* @param o element to search for
* @return the index of the first occurrence of the specified element in
* this list, or -1 if this list does not contain the element
* @throws ClassCastException if the type of the specified element
* is incompatible with this list
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* list does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
返回指定元素在此列表中首次出現的索引；如果此列表不包含該元素，則返回-1。
*/
int indexOf(Object o);
/**
* Returns the index of the last occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the highest index {@code i} such that
* {@code Objects.equals(o, get(i))},
* or -1 if there is no such index.
*
* @param o element to search for
* @return the index of the last occurrence of the specified element in
* this list, or -1 if this list does not contain the element
* @throws ClassCastException if the type of the specified element
* is incompatible with this list
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* list does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
返回指定元素在此列表中最後一次出現的索引；如果此列表不包含該元素，則返回-1。
*/
int lastIndexOf(Object o);
// List Iterators
/**
* Returns a list iterator over the elements in this list (in proper
* sequence).
*
* @return a list iterator over the elements in this list (in proper
* sequence)
返回此列表中的元素的列表迭代器
*/
ListIterator<E> listIterator();
/**
* Returns a list iterator over the elements in this list (in proper
* sequence), starting at the specified position in the list.
* The specified index indicates the first element that would be
* returned by an initial call to {@link ListIterator#next next}.
* An initial call to {@link ListIterator#previous previous} would
* return the element with the specified index minus one.
*
* @param index index of the first element to be returned from the
* list iterator (by a call to {@link ListIterator#next next})
* @return a list iterator over the elements in this list (in proper
* sequence), starting at the specified position in the list
* @throws IndexOutOfBoundsException if the index is out of range
* ({@code index < 0 || index > size()})
從列表中的指定位置開始，以適當的順序返回在此列表中的元素上的列表迭代器
*/
ListIterator<E> listIterator(int index);
// View
/**
* Returns a view of the portion of this list between the specified
* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive. (If
* {@code fromIndex} and {@code toIndex} are equal, the returned list is
* empty.) The returned list is backed by this list, so non-structural
* changes in the returned list are reflected in this list, and vice-versa.
* The returned list supports all of the optional list operations supported
* by this list.<p>
*
* This method eliminates the need for explicit range operations (of
* the sort that commonly exist for arrays). Any operation that expects
* a list can be used as a range operation by passing a subList view
* instead of a whole list. For example, the following idiom
* removes a range of elements from a list:
* <pre>{@code
* list.subList(from, to).clear();
* }</pre>
* Similar idioms may be constructed for {@code indexOf} and
* {@code lastIndexOf}, and all of the algorithms in the
* {@code Collections} class can be applied to a subList.<p>
*
* The semantics of the list returned by this method become undefined if
* the backing list (i.e., this list) is <i>structurally modified</i> in
* any way other than via the returned list. (Structural modifications are
* those that change the size of this list, or otherwise perturb it in such
* a fashion that iterations in progress may yield incorrect results.)
*
* @param fromIndex low endpoint (inclusive) of the subList
* @param toIndex high endpoint (exclusive) of the subList
* @return a view of the specified range within this list
* @throws IndexOutOfBoundsException for an illegal endpoint index value
* ({@code fromIndex < 0 || toIndex > size ||
* fromIndex > toIndex})
返回此列表在指定的fromIndex（包括）和toIndex（不包括）之間的元素
*/
List<E> subList(int fromIndex, int toIndex);
/**
* Creates a {@link Spliterator} over the elements in this list.
*
* <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
* {@link Spliterator#ORDERED}. Implementations should document the
* reporting of additional characteristic values.
*
* @implSpec
* The default implementation creates a
* <em><a href="Spliterator.html#binding">late-binding</a></em>
* spliterator as follows:
* <ul>
* <li>If the list is an instance of {@link RandomAccess} then the default
* implementation creates a spliterator that traverses elements by
* invoking the method {@link List#get}. If such invocation results or
* would result in an {@code IndexOutOfBoundsException} then the
* spliterator will <em>fail-fast</em> and throw a
* {@code ConcurrentModificationException}.
* If the list is also an instance of {@link AbstractList} then the
* spliterator will use the list's {@link AbstractList#modCount modCount}
* field to provide additional <em>fail-fast</em> behavior.
* <li>Otherwise, the default implementation creates a spliterator from the
* list's {@code Iterator}. The spliterator inherits the
* <em>fail-fast</em> of the list's iterator.
* </ul>
*
* @implNote
* The created {@code Spliterator} additionally reports
* {@link Spliterator#SUBSIZED}.
*
* @return a {@code Spliterator} over the elements in this list
* @since 1.8
在此列表中的元素上創建一個Spliterator
*/
@Override
default Spliterator<E> spliterator() {
if (this instanceof RandomAccess) {
return new AbstractList.RandomAccessSpliterator<>(this);
} else {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
}
/**
* Returns an unmodifiable list containing zero elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @return an empty {@code List}
*
* @since 9
返回包含零個元素的不可修改列表
*/
static <E> List<E> of() {
return ImmutableCollections.emptyList();
}
/**
* Returns an unmodifiable list containing one element.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the single element
* @return a {@code List} containing the specified element
* @throws NullPointerException if the element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1) {
return new ImmutableCollections.List12<>(e1);
}
/**
* Returns an unmodifiable list containing two elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2) {
return new ImmutableCollections.List12<>(e1, e2);
}
/**
* Returns an unmodifiable list containing three elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3) {
return new ImmutableCollections.ListN<>(e1, e2, e3);
}
/**
* Returns an unmodifiable list containing four elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
}
/**
* Returns an unmodifiable list containing five elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
}
/**
* Returns an unmodifiable list containing six elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @param e6 the sixth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6);
}
/**
* Returns an unmodifiable list containing seven elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @param e6 the sixth element
* @param e7 the seventh element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7);
}
/**
* Returns an unmodifiable list containing eight elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @param e6 the sixth element
* @param e7 the seventh element
* @param e8 the eighth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8);
}
/**
* Returns an unmodifiable list containing nine elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @param e6 the sixth element
* @param e7 the seventh element
* @param e8 the eighth element
* @param e9 the ninth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9);
}
/**
* Returns an unmodifiable list containing ten elements.
*
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @param <E> the {@code List}'s element type
* @param e1 the first element
* @param e2 the second element
* @param e3 the third element
* @param e4 the fourth element
* @param e5 the fifth element
* @param e6 the sixth element
* @param e7 the seventh element
* @param e8 the eighth element
* @param e9 the ninth element
* @param e10 the tenth element
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null}
*
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9, e10);
}
/**
* Returns an unmodifiable list containing an arbitrary number of elements.
* See <a href="#unmodifiable">Unmodifiable Lists</a> for details.
*
* @apiNote
* This method also accepts a single array as an argument. The element type of
* the resulting list will be the component type of the array, and the size of
* the list will be equal to the length of the array. To create a list with
* a single element that is an array, do the following:
*
* <pre>{@code
* String[] array = ... ;
* List<String[]> list = List.<String[]>of(array);
* }</pre>
*
* This will cause the {@link List#of(Object) List.of(E)} method
* to be invoked instead.
*
* @param <E> the {@code List}'s element type
* @param elements the elements to be contained in the list
* @return a {@code List} containing the specified elements
* @throws NullPointerException if an element is {@code null} or if the array is {@code null}
*
* @since 9
*/
@SafeVarargs
@SuppressWarnings("varargs")
static <E> List<E> of(E... elements) {
switch (elements.length) { // implicit null check of elements
case 0:
return ImmutableCollections.emptyList();
case 1:
return new ImmutableCollections.List12<>(elements[0]);
case 2:
return new ImmutableCollections.List12<>(elements[0], elements[1]);
default:
return new ImmutableCollections.ListN<>(elements);
}
}
/**
* Returns an <a href="#unmodifiable">unmodifiable List</a> containing the elements of
* the given Collection, in its iteration order. The given Collection must not be null,
* and it must not contain any null elements. If the given Collection is subsequently
* modified, the returned List will not reflect such modifications.
*
* @implNote
* If the given Collection is an <a href="#unmodifiable">unmodifiable List</a>,
* calling copyOf will generally not create a copy.
*
* @param <E> the {@code List}'s element type
* @param coll a {@code Collection} from which elements are drawn, must be non-null
* @return a {@code List} containing the elements of the given {@code Collection}
* @throws NullPointerException if coll is null, or if it contains any nulls
* @since 10
以迭代順序返回包含給定Collection元素的不可修改List
*/
static <E> List<E> copyOf(Collection<? extends E> coll) {
return ImmutableCollections.listCopy(coll);
}
}
2.AbstractList
AbstractList 是 抽象類，繼承AbstractCollection 實現List接口的抽象類，AbstractList抽象類與List接口的關係類似於AbstractCollection抽象類與Collection接口的關係。AbstractList與AbstractCollection一樣，也是通過提供一些方法的默認實現，簡化我們編寫List接口的列表類所需付出的努力。
實現列表類的需要記住：
1）要想實現一個不可修改的集合，只需要繼承這個類，並且實現get(int)、size()方法；
2）要想實現一個可以修改的集合，還必須重寫set(int, E)方法，該方法默認拋出一個異常。如果集合是可動態調整大小的，還必須重寫add(int, E)，remove(int)方法
2.1類定義
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
除了實現List接口，AbstractList還繼承了AbstractCollection抽象類。
2.2 方法定義
2.2.1構造函數
protected AbstractList() {
}
提供一個空構造方法，給子類的構造方法調用（通常是隱式調用）
2.2.2 元素的增刪改查
1）
public boolean add(E e) {
add(size(), e);
return true;
}
添加指定元素到列表末端。此方法有可能拋出IndexOutOfBoundsException異常。
方法內部是通過調用add(int, E)方法實現的。
2）
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
添加指定元素到列表的指定位置處。
方法內部默認拋出UnsupportedOperationException。正如前言所講，如果我們要實現一個不可修改的列表類，則當調用添加方法時，則拋出不支持添加操作的異常；如果我們要實現一個可以修改的列表類，則必須重寫此方法。重寫此方法之後，此方法在調用過程中有可能拋出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等異常。
3）
public E remove(int index) {
throw new UnsupportedOperationException();
}
刪除列表中指定位置的元素。
方法內部默認拋出UnsupportedOperationException。原因同上。
4）
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
用指定元素更新列表中指定位置處的元素
方法內部默認拋出UnsupportedOperationException。同上面一樣，如果我們要實現一個不可修改的列表類，那麼無需實現此方法；反之，要重寫此方法。重寫此方法之後，此方法還可能拋出ClassCastException、NullPointerException、IllegalArgumentException、IndexOutOfBoundsException等異常。
5）
public abstract E get(int index);
查找列表指定位置處的元素。此方法有可能拋出IndexOutOfBoundsException異常。
6）
public int indexOf(Object o) {
ListIterator<E> it = listIterator();
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return it.previousIndex();
} else {
while (it.hasNext())
if (o.equals(it.next()))
return it.previousIndex();
}
return -1;
}
查找指定元素在列表中最後一次出現的索引。
通過列表迭代器迭代實現。
2.2.3批量操作
1）
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
boolean modified = false;
for (E e : c) {
add(index++, e);
modified = true;
}
return modified;
}
添加指定集合的所有元素到列表中。
首先通過rangeCheckForAdd()方法判斷插入位置是否合法，合法則添加元素；否則拋出異常。
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size())
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
當index超出範圍，rangeCheckForAdd()方法拋出IndexOutOfBoundsException異常。
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size();
}
拋出異常時，使用outOfBoundsMsg()方法提示異常具體信息。
2）
public void clear() {
removeRange(0, size());
}
清空列表，即，刪除列表所有元素
內部是通過removeRange()方法實現的
protected void removeRange(int fromIndex, int toIndex) {
ListIterator<E> it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();
it.remove();
}
}
2.2.4 相等與哈希
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
判斷列表與指定對象是否相等，這裏判斷的是值相等，而不是同一個對象。
判等邏輯如下：
1）如果兩個引用指向的對象是同一個對象，那麼值肯定相等，返回true；否則，繼續判斷
2）如果指定對象不是列表，如指定對象是set集合，那麼返回false；否則，繼續判斷
3）獲取列表、指定對象的列表迭代器，遍歷每個元素，並判斷相同位置的元素值是否相等，如果有一個不等，則返回false；否則，說明其中一個迭代器的所有元素在另一個迭代器中出現，且出現的位置相同，如果此時不存在其中一個迭代器剩下元素，那直接返回true
2）
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}
得到列表的哈希碼值
方法內部實現是通過遍歷列表的每一個元素，得到每個元素的哈希碼值（若元素爲null，則哈希碼值爲0；若不爲null，則通過hashCode()方法獲取元素的哈希碼值），然後按照hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); 的規則計算列表的哈希碼值，其中初始hashCode=1。當所有元素遍歷完畢，最終的hashCode即爲列表的哈希碼值，返回即可。
2.2.5 迭代器
1）
public Iterator<E> iterator() {
return new Itr();
}
返回一個在列表元素之上的迭代器
此方法是實現了了List接口的iterator()方法，內部是通過創建一個Itr實例並返回來實現的
AbstractList定義的modCount成員變量如下，它主要記錄列表實例創建之後，發生結構性修改的次數。用於判斷列表是否在創建完迭代器之後，發生併發修改的異常。
protected transient int modCount = 0;
Itr是實現Iterator接口的內部類，它的定義依賴於列表的size()、get(int)、remove(int)方法，其具體定義如下：
private class Itr implements Iterator<E> {
/**
* Index of element to be returned by subsequent call to next.
下一次調用next()方法返回元素的索引
*/
int cursor = 0;
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
最近一次調用next()方法返回元素的索引；如果發生一次remove()操作，則被重置爲-1
*/
int lastRet = -1;
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
用於檢測是否發生併發修改
*/
int expectedModCount = modCount;
//判斷迭代器中是否還有元素，如果cursor等於列表size，則表示沒有
public boolean hasNext() {
return cursor != size();
}
//返回下一個元素
public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
//依賴列表的remove()方法，如果列表沒有實現該方法，那麼調用迭代器的這個方法將拋出
UnsupportedOperationException
public void remove() {
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;//調用一次此方法，就將lastRet重置爲-1
expectedModCount = modCount;//迭代過程中，通過迭代器的remove方法刪除列表元素時，不會拋出併發修改異常
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
//判斷在迭代器生成之後，列表是否發生（不是通過迭代器做到的）結構性修改
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
2）
public ListIterator<E> listIterator() {
return listIterator(0);
}
此方法返回了一個在列表元素之上的列表迭代器。
內部通過調用ListIterator(int)方法實現。
3）
public ListIterator<E> listIterator(final int index) {
rangeCheckForAdd(index);
return new ListItr(index);
}
此方法返回一個在列表元素之上的列表迭代器。
先是檢查指定位置是否合法，非法則拋出異常；合法則創建一個ListItr的實例並返回。
ListItr是繼承Itr類，實現ListIterator接口的一個內部類，其定義如下：
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index;
}
//判斷列表迭代器中前面是否還有元素
public boolean hasPrevious() {
return cursor != 0;
}
//返回列表迭代器中前面一個元素（即，當前位置cursor減1的位置處的元素）
public E previous() {
checkForComodification();
try {
int i = cursor - 1;
E previous = get(i);
lastRet = cursor = i;
return previous;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
//判斷列表迭代器中後面是否還有元素
public int nextIndex() {
return cursor;
}
//返回列表迭代器中當前位置的前一個索引
public int previousIndex() {
return cursor-1;
}
//更新最近一次返回的元素（即，lastRet索引指向的元素）
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
//添加指定元素到列表迭代器的當前位置處，同樣也是利用列表的add(E)方法實現
public void add(E e) {
checkForComodification();
try {
int i = cursor;
AbstractList.this.add(i, e);
lastRet = -1;
cursor = i + 1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
3.ArrayList
3.1 類定義
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList繼承AbstractList,實現List,RandomAccess,Cloneable,Serializable接口
3.2 成員變量
//嘗試分配更大的數組可能會導致 OutOfMemoryError：請求的數組大小超過VM限制
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* Default initial capacity.
默認初始容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
用於空實例的共享空數組實例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
用於默認大小的空實例的共享空數組實例。 我們將此與EMPTY_ELEMENTDATA區分開來
以便在添加第一個元素時知道要膨脹多少
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
存儲 ArrayList 元素的數組緩衝區。
ArrayList 的容量是此數組緩衝區的長度。 添加第一個元素時，任何帶有
elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空 ArrayList 都將擴展
爲DEFAULT_CAPCITY
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
* ArrayList的大小
* @serial
*/
private int size;
3.3 構造方法
//構造具有指定初始容量的空列表
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);
}
}
/**
* Constructs an empty list with an initial capacity of ten.
構造一個初始容量爲 10 的空列表
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
按照集合的迭代器返回的順序，構造一個包含指定集合元素的 List
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// defend against c.toArray (incorrectly) not returning Object[]
// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
從構建 ArrayList 數組的構造函數上可以看出，使用無參構造時，使用的 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 作爲引用，而使用 ArrayList 數組的有參構造時，使用的 EMPTY_ELEMENTDATA 作爲應用的
3.4 add方法
3.4.1 add()方法（有4個）
1）boolean add(E)
//默認直接在末尾添加元素
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
分析 ：
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length) //判斷數組長度是否等於集合大小，如果是，擴容，否則，添加到對應數組位置
elementData = grow();
elementData[s] = e;
size = s + 1;
}
grow()方法：arrayList核心的方法，能擴展數組大小的真正祕密
//1.首先調用grow方法
private Object[] grow() {
return grow(size + 1);
}
//2.其次調用grow
private Object[] grow(int minCapacity) {
return elementData = Arrays.copyOf(elementData,
newCapacity(minCapacity));
}
//3.最終調用的是這個方法
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//擴容爲原來的1.5倍
if (newCapacity - minCapacity <= 0) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}
擴容擴大爲1.5倍。然後新建數組，長度爲新的容量，複製舊數據。由於過程中沒有加鎖，ArrayList也不是線程安全的。
（注意代碼是JDK11,於JDK8有所不同）
2）add(int,E)
public void add(int index, E element) {
rangeCheckForAdd(index);//檢查index也就是插入的位置是否合理
modCount++;
final int s;
Object[] elementData;
if ((s = size) == (elementData = this.elementData).length)//判斷是否需要擴容
elementData = grow();//同上，具體看上面分析
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);//用來在插入元素之後，要將index之後的元素都往後移一位
elementData[index] = element;////在目標位置上存放元素
size = s + 1;
}
分析：rangeCheckForAdd(index)
private void rangeCheckForAdd(int index) {
//插入的位置肯定不能大於size 和小於0，如果是，就報這個越界異常
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
System.arraycopy(elementData, index, elementData, index + 1, s - index);就是將elementData在插入位置後的所有元素往後面移一位。（當數據量較大時，操作時間較長）
//native方法，由jvm調用具體的本地方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
3）addAll(Collection<? extends E> c) 與addAll(index,Collection<? extends E> c)
//將所有的元素加到該集合末尾處
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
if (numNew > (elementData = this.elementData).length - (s = size))//判斷是否擴容
elementData = grow(s + numNew);// 同上
System.arraycopy(a, 0, elementData, s, numNew);// 將添加的元素，加到這個集合後面
size = s + numNew;
return true;
}
//將所有元素添加到具體的位置
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew);//同上
int numMoved = s - index;
if (numMoved > 0)
System.arraycopy(elementData, index,
elementData, index + numNew,
numMoved);//同上
System.arraycopy(a, 0, elementData, index, numNew);
size = s + numNew;
return true;
}
這兩個方法和add(E),add(index,E) 方法，處理邏輯是一直的，只不過一個是單個元素，一個是Collection
總結：正常情況下會擴容1.5倍，特殊情況下（新擴展數組大小已經達到了最大值）則只取最大值。
3.4.2 刪除方法
其實這幾個刪除方法都是類似的。我們選擇幾個講，其中fastRemove(int)方法是private的，是提供給remove(Object)這個方法用的。
1）remove(int):通過刪除指定位置上的元素
public E remove(int index) {
Objects.checkIndex(index, size);//檢查index的合理性
final Object[] es = elementData;
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
fastRemove(es, index);//移除執行位置元素
return oldValue;
}
分析fastRemove
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i); //用來移動元素的
es[size = newSize] = null; //newSize上的位置賦值爲null，讓gc(垃圾回收機制)更快的回收它
}
2) remove(Object)：這個方法可以看出來，arrayList是可以存放null值得
//通過元素來刪除該元素，就依次遍歷，如果有這個元素，就將該元素的索引傳給fastRemobe(index)，使
//用這個方法來刪除該元素，
public boolean remove(Object o) {
final Object[] es = elementData;
final int size = this.size;
int i = 0;
found: {
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
} else {
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
fastRemove(es, i);
return true;
}
3）clear()：將elementData中每個元素都賦值爲null，等待垃圾回收將這個給回收掉，所以叫clear
public void clear() {
modCount++;
final Object[] es = elementData;
for (int to = size, i = size = 0; i < to; i++)
es[i] = null;
}
4）removeAll(collection c)：
public boolean removeAll(Collection<?> c) {
return batchRemove(c, false, 0, size);//批量刪除
}
分析：
boolean batchRemove(Collection<?> c, boolean complement,
final int from, final int end) {
Objects.requireNonNull(c);
final Object[] es = elementData;
int r;
// Optimize for initial run of survivors
for (r = from;; r++) {
if (r == end)
return false;
if (c.contains(es[r]) != complement)
break;
}
int w = r++;
try {
for (Object e; r < end; r++)
if (c.contains(e = es[r]) == complement)
es[w++] = e;
} catch (Throwable ex) {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
System.arraycopy(es, r, es, w, end - r);
w += end - r;
throw ex;
} finally {
modCount += end - w;
shiftTailOverGap(es, w, end); //批量刪除
}
return true;
}
private void shiftTailOverGap(Object[] es, int lo, int hi) {
System.arraycopy(es, hi, es, lo, size - hi); //移動多少步
for (int to = size, i = (size -= hi - lo); i < to; i++)
es[i] = null; //值爲null,以便gc清除
}
總結：：remove函數用戶移除指定下標的元素，此時會把指定下標到數組末尾的元素向前移動一個單位，並且會把數組最後一個元素設置爲null， 這樣是爲了方便之後將整個數組不被使用時，會被GC，可以作爲小的技巧使用。
3.4.3 set（）方法
public E set(int index, E element) {
Objects.checkIndex(index, size);//檢索是否合法
E oldValue = elementData(index);//舊值
elementData[index] = element;//新值
return oldValue;
}
3.4.4 indexOf() 方法
public int indexOf(Object o) {
return indexOfRange(o, 0, size);
}
int indexOfRange(Object o, int start, int end) {
Object[] es = elementData;
if (o == null) {//查找的元素爲空
for (int i = start; i < end; i++) { //遍歷數組，找到一個爲空的元素，返回下標
if (es[i] == null) {
return i;
}
}
} else {//查找的元素不爲空
for (int i = start; i < end; i++) {//遍歷數組，找到第一個和指定元素相等的元素，返回下標
if (o.equals(es[i])) {
return i;
}
}
}
return -1;// 沒有找到，返回-1
}
3.4.5 get()方法
public E get(int index) {
//檢驗索引是否合法
Objects.checkIndex(index, size);
return elementData(index);
}
總結：
1）arrayList可以存放null。
2）arrayList本質上就是一個elementData數組。
3）arrayList區別於數組的地方在於能夠自動擴展大小，其中關鍵的方法就是gorw()方法。
4）arrayList中removeAll(collection c)和clear()的區別就是removeAll可以刪除批量指定的元素，而clear是全是刪除集合中的元素。
5）arrayList由於本質是數組，所以它在數據的查詢方面會很快，而在插入刪除這些方面，性能下降很多，有移動很多數據才能達到應有的效果
6）arrayList實現了RandomAccess，所以在遍歷它的時候推薦使用for循環。