java.util.Collections#sort(java.util.List<T>)

java.util.ArrayList/java.util.LinkedList

/**
         * java.util.Collections#sort(java.util.List)
         *      public static <T extends Comparable<? super T>> void sort(List<T> list) {
         *         list.sort(null);
         *      }
         *
         * java.util.ArrayList#sort(java.util.Comparator)
         *      public void sort(Comparator<? super E> c) {
         *         final int expectedModCount = modCount;
         *         Arrays.sort((E[]) elementData, 0, size, c);
         *         if (modCount != expectedModCount) {
         *             throw new ConcurrentModificationException();
         *         }
         *         modCount++;
         *     }
         *
         * java.util.Arrays#sort(java.lang.Object[], int, int, java.util.Comparator)
         *      public static <T> void sort(T[] a, int fromIndex, int toIndex,
         *                                 Comparator<? super T> c) {
         *         if (c == null) {
         *             sort(a, fromIndex, toIndex);
         *         } else {
         *             rangeCheck(a.length, fromIndex, toIndex);
         *             if (LegacyMergeSort.userRequested)
         *                 legacyMergeSort(a, fromIndex, toIndex, c);
         *             else
         *                 TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);                  // timSort
         *         }
         *     }
         *
         *      java.util.Arrays#sort(java.lang.Object[], int, int)
         *          public static void sort(Object[] a, int fromIndex, int toIndex) {
         *              rangeCheck(a.length, fromIndex, toIndex);
         *              if (LegacyMergeSort.userRequested)
         *                  legacyMergeSort(a, fromIndex, toIndex);
         *              else
         *                  ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);          // TimSort
         *          }
         *
         *      java.util.TimSort#sort(java.lang.Object[], int, int, java.util.Comparator, java.lang.Object[], int, int)
         */

　　

/**
         * java.util.Collections#sort(java.util.List)
         *      public static <T extends Comparable<? super T>> void sort(List<T> list) {
         *         list.sort(null);
         *     }
         *     
         * java.util.List#sort(java.util.Comparator)
         *      default void sort(Comparator<? super E> c) {
         *         Object[] a = this.toArray();
         *         Arrays.sort(a, (Comparator) c);
         *         ListIterator<E> i = this.listIterator();
         *         for (Object e : a) {
         *             i.next();
         *             i.set((E) e);
         *         }
         *     }
         *     
         * java.util.Arrays#sort(java.lang.Object[], java.util.Comparator)
         *      public static <T> void sort(T[] a, Comparator<? super T> c) {               //timSort
         *         if (c == null) {
         *             sort(a);
         *         } else {
         *             if (LegacyMergeSort.userRequested)
         *                 legacyMergeSort(a, c);
         *             else
         *                 TimSort.sort(a, 0, a.length, c, null, 0, 0);
         *         }
         *     }
         */