public static void main (String[] args) {

     Stream.of("d2", "a2", "b1", "b3", "c")

         .sorted((s1, s2) -> {

             System.out.printf("sort: %s; %s\n", s1, s2);

             return s1.compareTo(s2);

         })

         .forEach(System.out::println);

 }

sort: a2; d2

sort: b1; a2

sort: b1; d2

sort: b1; a2

sort: b3; b1

sort: b3; d2

sort: c; b3

sort: c; d2

a2

b1

b3

c

d2

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/ReferencePipeline.java

　　

public final Stream<P_OUT> sorted(Comparator<? super P_OUT> comparator) {

    return SortedOps.makeRef(this, comparator);

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/SortedOps.java

static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream,

                            Comparator<? super T> comparator) {

    return new OfRef<>(upstream, comparator);

}

OfRef(AbstractPipeline<?, T, ?> upstream, Comparator<? super T> comparator) {

    super(upstream, StreamShape.REFERENCE,

          StreamOpFlag.IS_ORDERED | StreamOpFlag.NOT_SORTED);

    this.isNaturalSort = false;

    this.comparator = Objects.requireNonNull(comparator);

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/ReferencePipeline.java

public void forEach(Consumer<? super P_OUT> action) {

    evaluate(ForEachOps.makeRef(action, false));

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/AbstractPipeline.java

final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {

    assert getOutputShape() == terminalOp.inputShape();

    if (linkedOrConsumed)

        throw new IllegalStateException(MSG_STREAM_LINKED);

    linkedOrConsumed = true;

    return isParallel()

           ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))

           : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/ForEachOps.java

public <S> Void evaluateSequential(PipelineHelper<T> helper,

                                   Spliterator<S> spliterator) {

    return helper.wrapAndCopyInto(this, spliterator).get();

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/AbstractPipeline.java

final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator) {

    copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);

    return sink;

}

final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {

    Objects.requireNonNull(sink);

    for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {

        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);

    }

    return (Sink<P_IN>) sink;

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/SortedOps.java

public Sink<T> opWrapSink(int flags, Sink<T> sink) {

    Objects.requireNonNull(sink);

    // If the input is already naturally sorted and this operation

    // also naturally sorted then this is a no-op

    if (StreamOpFlag.SORTED.isKnown(flags) && isNaturalSort)

        return sink;

    else if (StreamOpFlag.SIZED.isKnown(flags))

        return new SizedRefSortingSink<>(sink, comparator);

    else

        return new RefSortingSink<>(sink, comparator);

}

SizedRefSortingSink(Sink<? super T> sink, Comparator<? super T> comparator) {

    super(sink, comparator);

}

AbstractRefSortingSink(Sink<? super T> downstream, Comparator<? super T> comparator) {
    super(downstream);
    this.comparator = comparator;
}

 /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/Sink.java

public ChainedReference(Sink<? super E_OUT> downstream) {
    this.downstream = Objects.requireNonNull(downstream);
}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/AbstractPipeline.java

final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
    Objects.requireNonNull(wrappedSink);

    if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
        wrappedSink.begin(spliterator.getExactSizeIfKnown());
        spliterator.forEachRemaining(wrappedSink);
        wrappedSink.end();
    }
    else {
        copyIntoWithCancel(wrappedSink, spliterator);
    }
}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/stream/SortedOps.java

public void end() {

    Arrays.sort(array, 0, offset, comparator);

    downstream.begin(offset);

    if (!cancellationWasRequested) {

        for (int i = 0; i < offset; i++)

            downstream.accept(array[i]);

    }

    else {

        for (int i = 0; i < offset && !downstream.cancellationRequested(); i++)

            downstream.accept(array[i]);

    }

    downstream.end();

    array = null;

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/Arrays.java

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);

    }

}

/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/src.zip!/java/util/TimSort.java

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,

                     T[] work, int workBase, int workLen) {

    assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

    int nRemaining  = hi - lo;

    if (nRemaining < 2)

        return;  // Arrays of size 0 and 1 are always sorted

    // If array is small, do a "mini-TimSort" with no merges

    if (nRemaining < MIN_MERGE) {

        int initRunLen = countRunAndMakeAscending(a, lo, hi, c);

        binarySort(a, lo, hi, lo + initRunLen, c);

        return;

    }

    /**

     * March over the array once, left to right, finding natural runs,

     * extending short natural runs to minRun elements, and merging runs

     * to maintain stack invariant.

     */

    TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);

    int minRun = minRunLength(nRemaining);

    do {

        // Identify next run

        int runLen = countRunAndMakeAscending(a, lo, hi, c);

        // If run is short, extend to min(minRun, nRemaining)

        if (runLen < minRun) {

            int force = nRemaining <= minRun ? nRemaining : minRun;

            binarySort(a, lo, lo + force, lo + runLen, c);

            runLen = force;

        }

        // Push run onto pending-run stack, and maybe merge

        ts.pushRun(lo, runLen);

        ts.mergeCollapse();

        // Advance to find next run

        lo += runLen;

        nRemaining -= runLen;

    } while (nRemaining != 0);

    // Merge all remaining runs to complete sort

    assert lo == hi;

    ts.mergeForceCollapse();

    assert ts.stackSize == 1;

}