code: private static void sort(SavedField[] array, int high) {
          if (high > 10) {
              Arrays.sort(array, 0, high);
          } else {
              for (int i=0; i<high; i++) {
                  for (int j=i; j>0 && (array[j-1]).compareTo(array[j])>0; j--) {
                      SavedField t = array[j];
                      array[j] = array[j-1];
                      array[j-1] = t;
                  }
              }
          }
      }
docs: Sorts elements [0,high). Calling java.util.Arrays isn't always the right
  choice since it always creates an internal copy of the array, even if it
  doesn't need to. If the array slice is small enough, an insertion sort
  is chosen instead, but it doesn't need a copy!
  <p>
  This method has a modified version of that insertion sort, except it
  doesn't create an unnecessary array copy. If high is over 10, then
  java.util.Arrays is called, which will perform a merge sort, which is
  faster than insertion sort on large lists.
  <p>
  The end result is much greater performance when computeMillis is called.
  Since the amount of saved fields is small, the insertion sort is a
  better choice. Additional performance is gained since there is no extra
  array allocation and copying. Also, the insertion sort here does not
  perform any casting operations. The version in java.util.Arrays performs
  casts within the insertion sort loop.