code: public synchronized List<E> subList(int fromIndex, int toIndex) {
          return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                              this);
      }
docs: 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)}