code: @SuppressWarnings("unchecked")
      public static <T extends Comparable<? super T>> void sort(List<T> list) {
          // Android-changed: Call sort(list, null) here to be consistent
          // with that method's (Android-changed) behavior.
          // list.sort(null);
          sort(list, null);
      }
docs: Sorts the specified list into ascending order, according to the
  {@linkplain Comparable natural ordering} of its elements.
  All elements in the list must implement the {@link Comparable}
  interface.  Furthermore, all elements in the list must be
  <i>mutually comparable</i> (that is, {@code e1.compareTo(e2)}
  must not throw a {@code ClassCastException} for any elements
  {@code e1} and {@code e2} in the list).
  
  <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
  not be reordered as a result of the sort.
  
  <p>The specified list must be modifiable, but need not be resizable.
  
  @implNote
  This implementation defers to the {@link List#sort(Comparator)}
  method using the specified list and a {@code null} comparator.
  Do not call this method from {@code List.sort()} since that can lead
  to infinite recursion. Apps targeting APIs {@code <= 25} observe
  backwards compatibility behavior where this method was implemented
  on top of {@link List#toArray()}, {@link ListIterator#next()} and
  {@link ListIterator#set(Object)}.
  
  @param  <T> the class of the objects in the list
  @param  list the list to be sorted.
  @throws ClassCastException if the list contains elements that are not
  <i>mutually comparable</i> (for example, strings and integers).
  @throws UnsupportedOperationException if the specified list's
  list-iterator does not support the {@code set} operation.
  @throws IllegalArgumentException (optional) if the implementation
  detects that the natural ordering of the list elements is
  found to violate the {@link Comparable} contract
  @see List#sort(Comparator)