锐客网

  1. 首页 > it技术 > >

新手初学Java|新手初学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.** @paramc 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 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 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}:*
{@code*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* n2 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 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:*
{@code*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:*
{@code*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*/@Overridedefault Spliterator spliterator() {return Spliterators.spliterator(this, Spliterator.ORDERED); }}


总结 【新手初学Java|新手初学Java List 接口】本篇文章就到这里，希望能帮到你，也希望您能够多多关注脚本之家的更多内容！

    推荐阅读


    上一篇：如何建立一个超图详解

    下一篇：Java实现普通类注入service对象