The comparing() method of a Comparator: How does a comparison produce a Comparator?

[Biniman Idugboe]

The comparing() method of a Comparator

Accepts a function that extracts a sort key from a type T, and returns a Comparator<T> that compares by that sort key using the specified Comparator.
The returned comparator is serializable if the specified function and comparator are both serializable.

public static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)
{
	Objects.requireNonNull(keyExtractor);
	Objects.requireNonNull(keyComparator);
	return (Comparator<T> & Serializable)(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1), keyExtractor.apply(c2));
}

I regard the Comparator.comparing() method as a little processing plant where two objects of the same type are compared to know whether they are equal or whether one object is greater than or less than the other.  The processing that is done inside this little plant depends on the input supplied to it, but ultimately, two objects of the same class are compared.
Now, the comparison between c1 and c2 is suppoesed to result in one of three possible outcomes:- c1 is less than c2, or c1 is equal to c2 or c1 is greater than c2.

The Lambda expression (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1), keyExtractor.apply(c2)); performs the comparison and returns an integer value.  Apology for the following newbie questions:
1. At what point does the integer value returned by the Lambda expression become a Compartor?
2. Does an integer value become a Comparator just by prepending (Comparator<T> & Serializable) to it?
3. Inside the body of the comparing() method, which line of code produces the Comparator?

I know that I have completely misunderstood the concept, yes.  That is exactly why I am asking these questions. My desire is to have a clear understanding of the underlying principles.  

[Stephan van Hulst]

Biniman Idugboe wrote:1. At what point does the integer value returned by the Lambda expression become a Compartor?

It doesn't. The lambda expression returns a Comparator. The body of the lambda expression isn't executed until the client calls the compare() method.

2. Does an integer value become a Comparator just by prepending (Comparator<T> & Serializable) to it?

No. The compiler sees that the method is supposed to return a Comparator, so when you use a lambda expression, the compiler knows that it has to return an object that implements the Comparator interface using the body of the lambda expression as the body of the compare() method. The int doesn't get turned into a Comparator, the lambda expression simply returns an object that implements Comparator, and Comparator.compare() returns an int.

3. Inside the body of the comparing() method, which line of code produces the Comparator?

None. The entire lambda expression returns a Comparator. The body of the lambda expression is just the implementation of that Comparator.

You have to think of the -> symbol as an actual operator. For instance, where + can accept two ints and return another int, -> can accept a parameter list and a method body, and return an object that implements some interface.

[Campbell Ritchie]

So, is that the code from src.zip? I am sure they didn't indent it as you did, with those long lines. Since it has the -> operator in, it must be the Java8 version, and that particular method was only introduced in Java8.

How much do you know about λ expressions? Let's get that λ back to an anonymous class. It tells you what sort of object it returns, a Comparator<T>, and we know that Comparator is a FunctionalInterface; it even says so in the documentation. It is easier to see if you

1: Read the Functional Interface link above and this section of the Java® Language Specification (=JLS).

2: Read the Java7 version of the documentation.

You can see there is the equals() method, which it tells you can safely be ignored, and the compare() method. So we know we are going to have to create a class of that name and a method of that name. Let's begin:-

    /**
     * Accepts a function that extracts a sort key from a type {@code T}, and
     * returns a {@code Comparator<T>} that compares by that sort key using
     * the specified {@link Comparator}.
      *
     * <p>The returned comparator is serializable if the specified function
     * and comparator are both serializable.
     *
     * @apiNote
     * For example, to obtain a {@code Comparator} that compares {@code
     * Person} objects by their last name ignoring case differences,
     *
     * <pre>{@code
     *     Comparator<Person> cmp = Comparator.comparing(
     *             Person::getLastName,
     *             String.CASE_INSENSITIVE_ORDER);
     * }</pre>
     *
     * @param  <T> the type of element to be compared
     * @param  <U> the type of the sort key
     * @param  keyExtractor the function used to extract the sort key
     * @param  keyComparator the {@code Comparator} used to compare the sort key
     * @return a comparator that compares by an extracted key using the
     *         specified {@code Comparator}
     * @throws NullPointerException if either argument is null
     * @since 1.8
     */
    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

Let's omit the documentation comments, otherwise no changes yet:-

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

Let's make things simpler: let's forget what the documentation says about

Note: It is generally a good idea for comparators to also implement java.io.Serializable . . .

Let's forget about lines 5‑6 which simply prevent nulls being passed.

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

Now, we have a common or garden λ, which I shall turn into an anonymous class. What precedes the -> is the parameters for a method and what follows it is the body of the method, and we know the method signature from here

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
            public int compare(T c1, T c2)
            {
                  return keyComparator.compare(keyExtractor.apply(c1),
                                               keyExtractor.apply(c2));
            }
    }

Now, let's apply a name to the class.

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return new Comparator<T>()
        {
            public int compare(T c1, T c2)
            {
                 return keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
            }
        }
    }

Now, we don't know what keyExtractor and keyComparator are. Maybe you have a Person class with String lastName. Maybe keyExtractor simply gets the lastName field. Maybe then keyComparator is a Comparator<String> which can compare Strings. You now have something similar to this λ:-

Comparator<Person> lastNameComparator =
      (p1, p2) -> p1.getLastName().compareTo(p2.getLastName());

As you know, Strings already implement Comparable<String>, so you can call compareTo on them.

In that case, look on T as meaning Person; your keyExtractor gets a String (=U) out of it and the keyComparator<‍U> compares them.

Comparator<Person> lastNameComparator =
      Comparator.comparing(p -> p.getLastName(),
                          (s1, s2) -> s1.compareTo(s2));

In that example, which does the same thing, the bit with p -> in gets lastName fields, and the bit starting (s1, s2) -> (line 3) compares two Strings with their compareTo method.

[Biniman Idugboe]

It took me time to get back here.  I tried to follow the links.  Quite a lot to take in.  Many of the concepts are just simply elusive.  Now, I know that Lambda expressions enable programmers to treat functionality as a method argument, to treat code as data, to pass an implementation of a functional interface as an argument to a method. Sounds really cool!  But I am still not quite there.

[Stephan van Hulst]

You will, in time :)

[Campbell Ritchie]

Start with something simple. Predict what this code will print:-

System.out.println
(
   IntStream.range(10, 15) // Stream with 10...14 in, not 15
            .map(i -> i * 2) // a lambda
            .boxed() // Convert IntStream to Stream<Integer>
            .collect(Collectors.toList())  // create List
);

Read about the methods: IntStream#range(10, 15) map() boxed() Stream#collect() and Collectors#toList(). Note that the descriptions of the classes have more useful information in. Read about IntUnaryOperator and go to this Java™ Tutorials page about λs and see how you can use a λ to create an IntUnaryOperator instance.

[Biniman Idugboe]

So, the lambda expression is equivalent to something like:

(int i){
    return i * 2;
}

The range of integers is 10, 11, 12, 13, 14.
The anonymous method is invoked on each of the integers and the resulting list will contain 20, 22, 24, 26, 28.
Basically, the anonymous method was passed as an argument to the map() method.

[Biniman Idugboe]

Because the map() takes a type IntUnaryOperator, the lambda expression returns a IntUnaryOperator.  The equivalent anonymous class could be something like:

new IntUnaryOperator(){
int applAsInt(int i){
    return i * 2;
}
}

The functional interface is passed as though it were an argument, to the map() method which applies it to every element in the stream of integer values. Right?

[Biniman Idugboe]

Oops!

new IntUnaryOperator(){
int applyAsInt(int i){
    return i * 2;
}
}

[Campbell Ritchie]

     

[Campbell Ritchie]

Don't say anonymous method, say λ expression (or lambda expression).
Now you have understood a simple example, try writing a slightly more difficult one. What about turning those ints to Strings and joining them to print [20, 22, 24, 26, 28]?

System.out.println
(
   IntStream.range(10, 15) // Stream with 10...14 in, not 15
            .map(i -> i * 2) // a lambda
            .???(???) // Convert IntStream to Stream<String>
            .collect(Collectors.joining(", ", "[", "]"))  // make text
);

Go through the methods for IntStream and see what you can find to map an int to a String.

[Biniman Idugboe]

Quite honestly, I do not understand the details of how these things work.  I am certaining missing the fundamentals.  The documentation is even more difficult to read and understand. What is the best way to approach this seemingly bewildering language?

Anyway, I tried working on the given task for several hours.

.flatMap(i -> Integer.toUnsignedString(i))
Reason: argument mismatch; bad return type in lambda expression
     String cannot be converted to IntStream

.flatMap(i -> Integer.toString(i))
error: incompatible types: cannot infer type-variable(s) R

.flatMap(i -> toString(i))
error: method toString in class Object cannot be applied to given types;

.forEach(i -> i.toString())
 error: int cannot be dereferenced

By trial and error, I came up with the following two snippets. No need to ask me how the Object::String works. I do not know for now. I only just came upon the syntax in the documentation. My worry?  I hate doing things by trial and error.

import java.util.stream.*;
class PrintRange
{
	public static void main(String[] args)
	{
		System.out.println(
	    IntStream.range(10, 15) // Stream with 10...14 in, not 15
            .map(i -> i * 2) // lambda expression
            .boxed() // Convert IntStream to Stream<Integer>
            .map(Object::toString)  // Convert Integer to String
            .collect(Collectors.toList())  // create a List from the stream.
          );
	}
}
//Output:  [20, 22, 24, 26, 28]

*****************************************************************************************
import java.util.stream.*;
class PrintRange
{
	public static void main(String[] args)
	{
		System.out.println(
	    IntStream.range(10, 15) // Stream with 10...14 in, not 15
            .map(i -> i * 2) // lambda expression
            .boxed() // Convert IntStream to Stream<Integer>
            .map(Object::toString)  // Convert Integer to String
            .collect(Collectors.joining(", ", "[", "]"))  // make text
          );
	}
}
//Output:  [20, 22, 24, 26, 28]

[Campbell Ritchie]

Yes, that will work, but you now have two λs, that in lines 10 and 27 being hidden behind a method reference. You have obviously put lots of work into this Well done.
That method reference is like this λ: i -> i.toString() You could probably have written Integer::toString instead.
I can think of another way to do it:-
String::valueOf, which is like writing i -> String.valueOf(i)

I was thinking of the mapToObj method: .mapToObj(i -> String.valueOf(i)) which can be shortened to .mapToObj(String::valueOf) You can read about the syntax String::valueOf in the Java™ Tutorials. No, it isn't easy first time, but you are doing a lot better than you thought yesterday.

The flatMap method won't help; it is there for converting a stream of arrays to a single stream.

// version 1
System.out.println
(
    IntStream.range(10, 15)
             .map(i -> i * 2)
             .mapToObj(i -> String.valueOf(i))
             .collect(java.util.stream.Collectors.toList())
);

// Version 2
System.out.println
(
   IntStream.range(10, 15)
            .map(i -> i * 2)
            .mapToObj(String::valueOf)
            .collect(java.util.stream.Collectors.toList())
);

// Version 3
System.out.println
(
    IntStream.range(10, 15)
             .mapToObj(i -> String.valueOf(i * 2)) // ;-)
             .collect(java.util.stream.Collectors.toList())
);

We now have four different ways to change the ints to Strings, which goes to show there is often no one single “right” answer.

[Stephan van Hulst]

Then you should reason about it. In Campbell's code snippet, Collectors.joining() transforms a stream of char sequences to a string. So if the output is "[20, 22, 24, 26, 28]", the input must be { "20", "22", "24", "26", "28" }. You have an IntStream, so somehow you must transform { 20, 22, 24, 26, 28 } to { "20", "22", "24", "26", "28" }. Transform! That should immediately ring a bell to use some variant of the map() function. We need to map ints to Strings. However, ints are primitives and Strings are reference types. You can solve this by first calling boxed(), like you did, but IntStream has another method: mapToObj(). mapToObj() requires an IntFunction. IntFunction has one method that takes an int, and returns some reference type of your choice. We want to convert an int to a String, so let's start with a lambda:

.mapToObj(x -> Integer.toString(x))

This works, but there is a shorter way of writing this. We just declared a variable and passed it to a function, but we can just tell the mapToObj() method to use the function directly, without declaring the variables. This is also known as using a method reference:

.mapToObj(Integer::toString)

It takes some practice to get used to this, but it starts by realizing that mapToObj() requires a function that takes an int and returns an object, and that Integer.toString() IS a function that takes an int and returns an object, so you can use it without writing a lambda expression.

[Biniman Idugboe]

Thanks for all the encouragements.

[Campbell Ritchie]

That's a pleasure and well done putting all that effort into working out your solutions.