How does a lambda function become the compare() method of Comparator

Question

I have seen that in Java 8, one can define a comparator like this:

Comparator c = (Computer c1, Computer c2) -> c1.getAge().compareTo(c2.getAge());

which is equivalent to:

Comparator d = new Comparator<Computer> () {
    @Override
    public int compare(Computer c1, Computer c2){
        return c1.getAge().compareTo(c2.getAge());
    }
};

I'd like to understand how this works. In the second example, it is fairly simple: A Comparator object is created with a method compare which performs the comparison by using the compareTo method in the age property of Computer. This method is simply called by us when we do:

Computer comp1 = new Computer(10);
Computer comp2 = new Computer(11);
d.compare(comp1, comp2); // -1

But what's going on in the first example, when using a lambda? It looks to me like we are setting the Comparator to be equal to a method that performs comparison. But this cannot be, because a Comparator object is an object that has a method compare. I've learned that lambdas can be used with functional interfaces (interfaces with only one method). But Comparator is not a functional interface (it has many other methods other than compare!). So how does the Java interpreter know that it is the compare method we are implementing?

which other method is there to implement? You should know this only works with interfaces that provide only one method — Stultuske, Feb 07 '19 at 10:11
https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#comparing-java.util.function.Function- There are plenty of methods here in the Comparator interface. I assumed they can all be implemented? — Sahand, Feb 07 '19 at 10:11
Because [`Comparator`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Comparator.html) *is* a [`FunctionalInterface`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/FunctionalInterface.html) — Federico klez Culloca, Feb 07 '19 at 10:11
ok, it has one abstract method. (being the one to implement) — Stultuske, Feb 07 '19 at 10:13
To me it looks like it has two: `compare` and `equals`. Perhaps you meant that it only has one with the same number of arguments? — Sahand, Feb 07 '19 at 10:25
No. The `Comparator` interface only has exactly one method without implementation. `equals` is not part of `Comparator` as an interface, it comes from the `Object` class and has an implementation. — Zabuzard, Feb 07 '19 at 10:26
Then why are there two methods listed under the "Abstract Methods" tab of the docs (see my link above)? — Sahand, Feb 07 '19 at 10:28
Please refer to the duplicate question [FunctionalInterface Comparator has 2 abstract methods](https://stackoverflow.com/questions/23721759/functionalinterface-comparator-has-2-abstract-methods), thanks. — Zabuzard, Feb 07 '19 at 10:33
Sahand does have a valid point that the Javadoc confusingly lists `equals` as an abstract method even though it's not really. By the way, you can use an even more consise expression: `Comparator c = Comparator.comparingInt(Computer::getAge);`. (Note also that in your code above, you're declaring the comparators as raw types; you should avoid that.) — DodgyCodeException, Feb 07 '19 at 16:53

Zabuzard · Accepted Answer · 2019-02-07T10:22:16.157

Explanation

Comparator is a functional interface (only demands one method). Thus, you can create instances of it by using a lambda expression.

It behaves very similar to other methods of creating instances, such as a regular class which extends or an anonymous class.

The lambda refers to the one method a functional interface demands. Since there is only one method, it is not ambiguous. The lambda names the input arguments and then gives an implementation for the method (it provides a body).

Overview

You have the following options to create instances of interfaces or abstract classes:

Create a class that extends and use new
Use an anonymous class

Supposed we have an interface which only offers one method (it's called functional interface then), we additionally have the following two options to create instances of it:

Use a lambda expression
Use a method reference

As example, we want to create a multiplication instance, using the following interface:

@FunctionalInterface
public interface Operation {
    int op(int a, int b);
}

Create a class that extends and use new:

public class Multiplicator implements Operation {
    @Override
    public int op(int a, int b) {
        return a * b;
    }
}

// Usage
Operation operation = new Multiplicator();
System.out.println(operation.op(5, 2)); // 10

Use an anonymous class:

Operation operation = new Operation() {
    @Override
    public int op(int a, int b) {
        return a * b;
    }
};

// Usage
System.out.println(operation.op(5, 2)); // 10

Use a lambda expression:

Operation operation = (a, b) -> a * b;
System.out.println(operation.op(5, 2)); // 10

Use a method reference:

// Somewhere else in our project, in the `MathUtil` class
public static int multiply(int a, int b) {
    return a * b;
}

// Usage
Operation operation = MathUtil::multiply;
System.out.println(operation.op(5, 2)); // 10

But when I look at the docs, I see two abstract methods: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#comparing-java.util.function.Function- . — Sahand, Feb 07 '19 at 10:26
The `equals` method is part of `Object` and has an implementation. It is only there because they wanted to add important documentation notes to it. The interface still only demands one method without implementation to the outside. — Zabuzard, Feb 07 '19 at 10:28
Okay. How does one best find out which methods are truly abstract when sometimes none-abstract methods are listed under "Abstract Methods" in the interfaces? — Sahand, Feb 07 '19 at 10:30
Please refer to the duplicate question [FunctionalInterface Comparator has 2 abstract methods](https://stackoverflow.com/questions/23721759/functionalinterface-comparator-has-2-abstract-methods), thanks. In particular: *If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.* — Zabuzard, Feb 07 '19 at 10:31

score 3 · Answer 2 · answered Feb 07 '19 at 10:17

Technically, java.util.Comparator is a functional interface, not just because it is annotated to be one, but because it has just one single (abstract) method, compare(T, T).

All other methods have default implementations, hence they are ignored considering the lambda expression.

See also Precise definition of "functional interface" in Java 8

How does a lambda function become the compare() method of Comparator

2 Answers2

Explanation

Overview