src/share/classes/java/util/TimSort.java

*** 237,247 ****
       *
       * @param a the array in which a range is to be sorted
       * @param lo the index of the first element in the range to be sorted
       * @param hi the index after the last element in the range to be sorted
       * @param start the index of the first element in the range that is
!      *        not already known to be sorted (@code lo <= start <= hi}
       * @param c comparator to used for the sort
       */
      @SuppressWarnings("fallthrough")
      private static <T> void binarySort(T[] a, int lo, int hi, int start,
                                         Comparator<? super T> c) {
--- 237,247 ----
       *
       * @param a the array in which a range is to be sorted
       * @param lo the index of the first element in the range to be sorted
       * @param hi the index after the last element in the range to be sorted
       * @param start the index of the first element in the range that is
!      *        not already known to be sorted ({@code lo <= start <= hi})
       * @param c comparator to used for the sort
       */
      @SuppressWarnings("fallthrough")
      private static <T> void binarySort(T[] a, int lo, int hi, int start,
                                         Comparator<? super T> c) {
*** 276,286 ****
               * first slot after them -- that's why this sort is stable.
               * Slide elements over to make room to make room for pivot.
               */
              int n = start - left;  // The number of elements to move
              // Switch is just an optimization for arraycopy in default case
!             switch(n) {
                  case 2:  a[left + 2] = a[left + 1];
                  case 1:  a[left + 1] = a[left];
                           break;
                  default: System.arraycopy(a, left, a, left + 1, n);
              }
--- 276,286 ----
               * first slot after them -- that's why this sort is stable.
               * Slide elements over to make room to make room for pivot.
               */
              int n = start - left;  // The number of elements to move
              // Switch is just an optimization for arraycopy in default case
!             switch (n) {
                  case 2:  a[left + 2] = a[left + 1];
                  case 1:  a[left + 1] = a[left];
                           break;
                  default: System.arraycopy(a, left, a, left + 1, n);
              }
*** 306,316 ****
       * reverse a descending sequence without violating stability.
       *
       * @param a the array in which a run is to be counted and possibly reversed
       * @param lo index of the first element in the run
       * @param hi index after the last element that may be contained in the run.
!               It is required that @code{lo < hi}.
       * @param c the comparator to used for the sort
       * @return  the length of the run beginning at the specified position in
       *          the specified array
       */
      private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
--- 306,316 ----
       * reverse a descending sequence without violating stability.
       *
       * @param a the array in which a run is to be counted and possibly reversed
       * @param lo index of the first element in the run
       * @param hi index after the last element that may be contained in the run.
!               It is required that {@code lo < hi}.
       * @param c the comparator to used for the sort
       * @return  the length of the run beginning at the specified position in
       *          the specified array
       */
      private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
*** 320,330 ****
          if (runHi == hi)
              return 1;
  
          // Find end of run, and reverse range if descending
          if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
!             while(runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                  runHi++;
              reverseRange(a, lo, runHi);
          } else {                              // Ascending
              while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                  runHi++;
--- 320,330 ----
          if (runHi == hi)
              return 1;
  
          // Find end of run, and reverse range if descending
          if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
!             while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                  runHi++;
              reverseRange(a, lo, runHi);
          } else {                              // Ascending
              while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                  runHi++;