/**
* Returns a view of the portion of this List between 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 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
* operating on a subList view instead of a whole List. For example, the following idiom removes a
* range of elements from a List:
*
* <pre>
* list.subList(from, to).clear();
* </pre>
*
* Similar idioms may be constructed for indexOf and lastIndexOf, and all of the algorithms in the
* 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 the 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 if an endpoint index value is out of range {@code (fromIndex
* < 0 || toIndex > size)}
* @throws IllegalArgumentException if the endpoint indices are out of order {@code (fromIndex >
* toIndex)}
*/
public synchronized List<E> subList(int fromIndex, int toIndex) {
return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
}
