新手初学Java List 接口

新手初学Java List 接口

目录源码展示总结

源码展示

package java.util;

import java.util.function.UnaryOperator;

public interface List extends Collection {

/**

* 返回 list 中元素的个数。

*/

int size();

/**

* list 是否为空。

*/

boolean isEmpty();

/**

* list 是否包含某个对象。

*/

boolean contains(Object o);

/**

* 返回一个正确顺序的迭代器。

*/

Iterator iterator();

/**

* 返回一个包含所有元素的有序数组。

*/

Object[] toArray();

/**

* 返回一个包含所有元素的有序泛型数组。

*/

T[] toArray(T[] a);

/**

* 添加一个元素到这个 list 的结尾。

*/

boolean add(E e);

/**

* 删除第一个出现在 list 中的对象。

*/

boolean remove(Object o);

/**

* Returns 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 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

* (optional)

* @throws NullPointerException if the specified collection contains one

* or more null elements and this list does not permit null

* elements

* (optional),

* or if the specified collection is null

*/

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 true if this list changed as a result of the call

* @throws UnsupportedOperationException if the 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 true if this list changed as a result of the call

* @throws UnsupportedOperationException if the 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

* (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 true if this list changed as a result of the call

* @throws UnsupportedOperationException if the 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

* (optional)

* @throws NullPointerException if this list contains a null element and the

* specified collection does not permit null elements

* (optional),

* 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 true if this list changed as a result of the call

* @throws UnsupportedOperationException if the 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

* (optional)

* @throws NullPointerException if this list contains a null element and the

* specified collection does not permit null elements

* (optional),

* 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}:

*

* final ListIterator li = list.listIterator();

* while (li.hasNext()) {

* li.set(operator.apply(li.next()));

* }

* }

*

* 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

* (optional)

* @since 1.8

*/

default void replaceAll(UnaryOperator operator) {

Objects.requireNonNull(operator);

final ListIterator 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}.

*

*

All elements in this list must be mutually comparable 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).

*

*

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.

*

*

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² 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.

*

*

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.

*

*

The implementation was adapted from Tim Peters's list sort for python

* (

* TimSort). 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

* mutually comparable using the specified comparator

* @throws UnsupportedOperationException if the list's list-iterator does

* not support the {@code set} operation

* @throws IllegalArgumentException

* (optional)

* 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 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 clear operation

* is not supported by this list

*/

void clear();

// Comparison and hashing

/**

* Compares the specified object with this list for equality. Returns

* 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 equal. (Two elements e1 and

* e2 are equal if (e1==null ? e2==null :

* e1.equals(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 List interface.

*

* @param o the object to be compared for equality with this list

* @return 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:

*

* int hashCode = 1;

* for (E e : list)

* hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

* }

* This ensures that list1.equals(list2) implies that

* list1.hashCode()==list2.hashCode() for any two lists,

* list1 and 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

* (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 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

* (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 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

* (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 remove operation

* is not supported by this list

* @throws IndexOutOfBoundsException if the index is out of range

* (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 i such that

* (o==null ? get(i)==null : o.equals(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

* (optional)

* @throws NullPointerException if the specified element is null and this

* list does not permit null elements

* (optional)

*/

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 i such that

* (o==null ? get(i)==null : o.equals(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

* (optional)

* @throws NullPointerException if the specified element is null and this

* list does not permit null elements

* (optional)

*/

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 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 listIterator(int index);

// View

/**

* Returns a view of the portion of this list between the specified

* fromIndex, inclusive, and toIndex, exclusive. (If

* fromIndex and 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.

*

* 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:

*

* list.subList(from, to).clear();

* }

* Similar idioms may be constructed for indexOf and

* lastIndexOf, and all of the algorithms in the

* Collections class can be applied to a subList.

*

* The semantics of the list returned by this method become undefined if

* the backing list (i.e., this list) is structurally modified 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

* (fromIndex < 0 || toIndex > size ||

* fromIndex > toIndex)

*/

List subList(int fromIndex, int toIndex);

/**

* Creates a {@link Spliterator} over the elements in this list.

*

*

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

* late-binding spliterator

* from the list's {@code Iterator}. The spliterator inherits the

* fail-fast properties of the list's iterator.

*

* @implNote

* The created {@code Spliterator} additionally reports

* {@link Spliterator#SUBSIZED}.

*

* @return a {@code Spliterator} over the elements in this list

* @since 1.8

*/

@Override

default Spliterator spliterator() {

return Spliterators.spliterator(this, Spliterator.ORDERED);

}

}

总结

本篇文章就到这里，希望能帮到你，也希望您能够多多关注我们的更多内容！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。