This result is expected since b ... "ab3"): Java sorts Strings lexicographically. ... Sign up to request clarification or add additional context in comments. ... It is important to know that "ab7" would still be smaller than "ac2" even though the last integer suggests ab7 should be greater than ac2 because the compareTo() lexicographically works as follows:- ... More on stackoverflow.com

However what determines ascending or descending order then? a.compareTo(b) versus b.compareTo(a). That's all there's to it really. The compare function is used by the sorting algorithm to decide which of the two is 'bigger'. If you reverse the comparison you also reverse the order. Another option is to simply reverse a list sorted in ascending order to get it in descending order :) Okay we get -1, or 1, or 0 but what determines if it should descend or ascend? The 'larger' of the two will always be put after the smaller of the two. If you want to reverse the order, you need to basically just swap the output. Simple example: var list = List.of(1, 4, 8, 2, 10, 6); var ascending = list.stream().sorted((a, b) -> Integer.compare(a, b)).toList(); System.out.println(ascending); var descending = list.stream().sorted((a, b) -> Integer.compare(b, a)).toList(); System.out.println(descending); See how the only difference is the order in which I pass the integers to Integer.compare? That's really all there's to it. How the actual sorting works; I suggest following a tutorial yourself where you implement a few sorting algorithms yourself. That will also make it very clear how the output of a comparison is used for sorting. More on reddit.com

You're getting answers all over the place here, but I don't really feel that they addressed what you are actually asking. The compareTo() function is part of the Comparable interface. Interfaces are like contracts. They are not classes but instead are promises that the class implementing them supports some functionality (the compareTo() method in our case). So lets take a look at the actual Comparable interface: int compareTo(T o) Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.) The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0. Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z. This is the contract of the Comparable interface and I've highlighted the part that concerns us. So in our case, String is an Object implementing the Comparable interface and thus it has already defined the compareTo function. It so happens that using compareTo to sort Strings will return them in canonical (i.e. alphabetical order) but the way a given object is sorted (or compared) is entirely up to the programmer writing that class. The comment below mine has the source actually used for java.lang.String's compareTo() if you are curious. I would also suggest trying to create your own simple class that implements the Comparable interface. For instance, you could try writing a myInteger class which implements Comparable and in your compareTo() function you would write a snippet of code that compares your int with another int. Note: in practice, all of the primitive wrapper classes (e.g. Integer, Double, etc.) already implement Comparable. T And finally, I just have to say that the real magic of implementing the Comparable interface is that you can give it to other methods that will automatically sort your object according to how you have defined compareTo. So to take Strings for an example: if you have an unsorted collection of Strings, you can pass it as an argument to Collections.sort() and it will return a sorted collection. If you take the time to write out that myInteger class, you can also pass a collection of myInteger's to Collections.sort() and it will automatically sort them. More on reddit.com

The Java String compareTo() method is used for comparing two strings lexicographically. Each character of both the strings is converted into a Unicode value for comparison. If both the strings are equal then this method returns 0 else it returns positive or negative value. The result is positive if the first string is lexicographically greater than the second string else the result would be negative. More on reddit.com