//Collections.sort(List<T>)
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    Object[] a = list.toArray();
    Arrays.sort(a);
    ListIterator<T> i = list.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set((T)a[j]);
    }
}

//Arrays.sort(Object[])
public static void sort(Object[] a) {
    Object[] aux = (Object[])a.clone();
    mergeSort(aux, a, 0, a.length, 0);
}

//Collections.sort(List<T>)
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    Object[] a = list.toArray();
    Arrays.sort(a);
    ListIterator<T> i = list.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set((T)a[j]);
    }
}

//Arrays.sort(Object[])
public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a);
}

/--
 - Old merge sort implementation can be selected (for
 - compatibility with broken comparators) using a system property.
 - Cannot be a static boolean in the enclosing class due to
 - circular dependencies. To be removed in a future release.
 -/
static final class LegacyMergeSort {
    private static final boolean userRequested =
        java.security.AccessController.doPrivileged(
            new sun.security.action.GetBooleanAction(
                "java.util.Arrays.useLegacyMergeSort")).booleanValue();
}

//Arrays.sort(int\[\]), Arrays.sort(char\[\]), Arrays.sort(long\[\]), Arrays(byte\[\])
public static void sort(int[] a) {
    sort1(a, 0, a.length);
}
...

//Arrays.sort(float\[\]), Arrays.sort(double\[\])
public static void sort(double[] a) {
    sort2(a, 0, a.length);
}
...

//Arrays.sort(double\[\]), Arrays.sort(int\[\]), Arrays.sort(char\[\]), Arrays.sort(long\[\]), Arrays.sort(float\[\]), Arrays.sort(byte\[\])
public static void sort(double[] a) {
    DualPivotQuicksort.sort(a);
}
...

//길이가 6이 넘는 List가 들어왔을 때 쪼개지는 가장 큰 단위는 6입니다.
//6이하의 정렬은 Insertion sort를 사용합니다.
private static final int INSERTIONSORT_THRESHOLD = 7;

void mergeSort(Object[] src, Object[]dest, ...) {
     if(길이 < INSERTIONSORT_THRESHOLD) {
          Insertion sort(dest);
          return;
     }

     반으로 분할하기;
     mergeSort(앞부분);
     mergeSort(뒷부분);

     if(정렬이 되어있는 경우) {
          dest에 복사하기;
          return;
     }

     for(dest 전체 순회) {
          비교후 정렬;
     }
}

유효성 검사
//Binary Insertion sort
if( 정렬할 길이 < MIN_MERGE ) { // MIN_MERGE의 기본값 = 32
     return Binary Insertion Sort로 정렬 // 기존의 Insertion sort에 삽입할 위치를 탐색하는 알고리즘으로 Binary search를 사용한다.
}
//Tim sort
ComparableTimSort 객체 생성
do{
     run 생성
     if( run의 길이 < minRun ) { //minRun의 크기는 정렬할 길이에 따라 변경
           Binary Insertion Sort를 사용하여 run의 길이를 강제로 늘림
     }
     ComparableTimSort.push() // run의 정보를 stack에 푸쉬
     ComparableTimSort.mergeCollapse() // run단위로 병합과 정렬
}while(List의 끝까지 순회하였다)
ComparableTimSort.mergeForceCoolapse() // 1개의 run으로 병합

Static static void Arrays.sort(int[] a) {
  DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}

1. 배열의 크기가 특정 숫자보다 작을경우 insertion 정렬을 수행한다.  
(적정 배열사이즈와 insertion 정렬을 수행하는 이유는 조사중)

2. 두 pivot 요소 p1, p2를 배열에서 고른다.  
예를들어 배열을 첫 요소를 p1, 배열의 마지막 요소를 p2로 지정한다.

3. p1은 p2보다 반드시 작아야하며 커질경우 서로 swap된다.  
그리고 다음과 같은 part들로 구성한다.  
    part1: left+1 에서 L-1 까지 p1보다 작은 값을 가지는 요소를 가진다.
    part2: L에서 K-1까지 p1보다 크거나 같고 p2보다 작거나 같은 요소를 가진다.
    part3: G+1에서 right-1 까지 p2보다 큰 값을 가지는 요소를 가진다.
    part4: K부터 G까지 나머지 요소들을 가진다.

4. part4의 a[K]의 다음 요소가 p1, p2와 비교하여 이에 대응되는 part1, part2, part3 로 이동된다.

5. 포인터 L, K, G가 바뀐다.

6. 4,5번 과정이 K <= G 일 동안 반복된다.

7. 피봇 p1이 part1의 마지막 요소와 swap된다.  
피봇 p2는 part3의 첫번째 요소와 swap된다.

The steps 1 - 7 are repeated recursively for every part I, part II, and part III.  
8. 이 1~7과정들이 각 part1, part2, part3에서 재귀적으로 일어난다.