Package Summary Overview Summary

### method:equals(java.lang.Object) [CHANGED]
### equals public boolean equals (Object o) 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 `Objects(e1==null ? e2==null : e1.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 `List` interface. Specified by: `equals` in interface `Collection<E>` Specified by: `equals` in interface `List<E>` Overrides: `equals` in class `AbstractList<E>` Parameters: `o` - the object to be compared for equality with this list Returns: `true` if the specified object is equal to this list See Also: `Object.equals(Object)` `Set.equals(Object)` `List.equals(Object)`hashCode() `HashMap`
### equals public boolean equals (Object o) 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 `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 `List` interface. Specified by: `equals` in interface `Collection<E>` Specified by: `equals` in interface `List<E>` Overrides: `equals` in class `AbstractList<E>` Parameters: `o` - the object to be compared for equality with this list Returns: `true` if the specified object is equal to this list See Also: `Object.equals(Object)` `Set.equals(Object)` `List.equals(Object)` | ### equals public boolean equals (Object o) 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. Specified by: `equals` in interface `Collection<E>` Specified by: `equals` in interface `List<E>` Overrides: `equals` in class `AbstractList<E>` Parameters: `o` - the object to be compared for equality with this list Returns: `true` if the specified object is equal to this list See Also: `Object.hashCode()` `HashMap`

### method:hashCode() [CHANGED]
### hashCode public int hashCode() 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 `Object.hashCode()`. Specified by: `hashCode` in interface `Collection<E>` Specified by: `hashCode` in interface `List<E>` Overrides: `hashCode` in class `AbstractList<E>` Returns: the hash code value for this list See Also: `Object.equals(java.lang.Object)` `List.equals(System.identityHashCode(java.lang.Object)`
### hashCode public int hashCode() 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 `Object.hashCode()`. Specified by: `hashCode` in interface `Collection<E>` Specified by: `hashCode` in interface `List<E>` Overrides: `hashCode` in class `AbstractList<E>` Returns: the hash code value for this list See Also: `Object.equals(Object)` `List.equals(Object)` | ### hashCode public int hashCode() Returns the hash code value for this list. Specified by: `hashCode` in interface `Collection<E>` Specified by: `hashCode` in interface `List<E>` Overrides: `hashCode` in class `AbstractList<E>` Returns: the hash code value for this list See Also: `Object.equals(java.lang.Object)` `System.identityHashCode(java.lang.Object)`

### method:addAll(java.util.Collection) [CHANGED]
### addAll public boolean addAll (Collection<? extends E> 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. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this list, and this list is nonempty.) Specified by: `addAll` in interface `Collection<E>` Specified by: `addAll` in interface `List<E>` Overrides: `addAll` in class `AbstractCollection<E>` Parameters: `c` - collection containing elements to be added to this list Returns: `true` if this list changed as a result of the call Throws: `NullPointerException` - if the specified collection is null See Also: `ListAbstractCollection.add(Object)`
### addAll public boolean addAll (Collection<? extends E> 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. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this list, and this list is nonempty.) Specified by: `addAll` in interface `Collection<E>` Specified by: `addAll` in interface `List<E>` Overrides: `addAll` in class `AbstractCollection<E>` Parameters: `c` - collection containing elements to be added to this list Returns: `true` if this list changed as a result of the call Throws: `NullPointerException` - if the specified collection is null See Also: `List.add(Object)` | ### addAll public boolean addAll (Collection<? extends E> 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. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this list, and this list is nonempty.) Specified by: `addAll` in interface `Collection<E>` Specified by: `addAll` in interface `List<E>` Overrides: `addAll` in class `AbstractCollection<E>` Parameters: `c` - collection containing elements to be added to this list Returns: `true` if this list changed as a result of the call Throws: `NullPointerException` - if the specified collection is null See Also: `AbstractCollection.add(Object)`

### method:subList(int,int) [CHANGED]
### subList public List<E> subList (int fromIndex, int toIndex) 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. 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(Object)` and `lastIndexOf(Object)`, 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.) Specified by: `subList` in interface `List<E>` Overrides: `subList` in class `AbstractList<E>` Parameters: `fromIndex` - low endpoint (inclusive) of the subList `toIndex` - high endpoint (exclusive) of the subList Returns: a view of the specified range within this list Throws: `IndexOutOfBoundsException` - forif an illegalendpoint index value is out of range `(fromIndex < 0 || toIndex > size || fromIndex > toIndex)` `IllegalArgumentException` - if the endpoint indices are out of order `(fromIndex > toIndex)`
### subList public List<E> subList (int fromIndex, int toIndex) 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. 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(Object)` and `lastIndexOf(Object)`, 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.) Specified by: `subList` in interface `List<E>` Overrides: `subList` in class `AbstractList<E>` Parameters: `fromIndex` - low endpoint (inclusive) of the subList `toIndex` - high endpoint (exclusive) of the subList Returns: a view of the specified range within this list Throws: `IndexOutOfBoundsException` - for an illegal endpoint index value (`fromIndex < 0 || toIndex > size || fromIndex > toIndex` ) `IllegalArgumentException` - if the endpoint indices are out of order `(fromIndex > toIndex)` | ### subList public List<E> subList (int fromIndex, int toIndex) 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. 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(Object)` and `lastIndexOf(Object)`, 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.) Specified by: `subList` in interface `List<E>` Overrides: `subList` in class `AbstractList<E>` Parameters: `fromIndex` - low endpoint (inclusive) of the subList `toIndex` - high endpoint (exclusive) of the subList Returns: a view of the specified range within this list Throws: `IndexOutOfBoundsException` - if an endpoint index value is out of range `(fromIndex < 0 || toIndex > size)` `IllegalArgumentException` - if the endpoint indices are out of order `(fromIndex > toIndex)`