Java 8 Lambda Expressions - What About Multiple Methods in Nested Class

Java 8 Lambda Expressions - what about multiple methods in nested class

You can use multi-method interfaces with lambdas by using helper interfaces. This works with such listener interfaces where the implementations of unwanted methods are trivial (i.e. we can just do what MouseAdapter offers too):

// note the absence of mouseClicked…
interface ClickedListener extends MouseListener
{
    @Override
    public default void mouseEntered(MouseEvent e) {}

    @Override
    public default void mouseExited(MouseEvent e) {}

    @Override
    public default void mousePressed(MouseEvent e) {}

    @Override
    public default void mouseReleased(MouseEvent e) {}
}

You need to define such a helper interface only once.

Now you can add a listener for click-events on a Component c like this:

c.addMouseListener((ClickedListener)(e)->System.out.println("Clicked !"));

How to write lambda expression for two or more anonymous functions in java?

You can't. A lambda expression can only be used for a "functional" interface - one that has only one non-default method.

For the "why" you'd have to ask the language designers, but my take on it is that lambda expressions are a shorthand for single blocks of code, whereas a group of related blocks treated as a unit would be better represented as a proper class. For cases like your example in the question, the real answer would be to modify the API so that instead of using a single A interface with two methods it uses two separate functional interfaces for the two functions APrinter and ADisplayer, which could then be implemented by separate lambdas.

Lambda expression in JAVA for Nested Conditions

Use a Stream:

List<String> spelling = numbers.stream()
                               .map(map1::get)
                               .filter(Objects::nonNull)
                               .collect(Collectors.toList());
System.out.println (spelling);

Note that instead of checking if a key is in the map with containsKey, I just used get, and then filtered out the nulls.

Output:

[One, Two, Three]

Are Java 8 lambdas compiled as inner classes, methods or something else?

The expression itself, assuming you pass an actual lambda expression and not a method reference, is compiled as a separate, synthetic method. In addition to any formal arguments to the expected functional interface (e.g., a single String in the case of Consumer<String>), it will include arguments for any captured values.

At the code location where a lambda expression or method reference appears, an invokedynamic instruction is emitted. The first time this instruction is hit, a call is made into a bootstrap method on LambdaMetafactory. This bootstrap method will fix up an actual implementation of the target functional interface which delegates to the target method, and this is what gets returned. The target method is either the synthetic method representing the lambda body or whichever named method was provided using the :: operator. While a class that implements the functional interface is being created, the process is deferred; it does not happen at compile time.

Finally, the runtime patches the invokedynamic site with the bootstrap result¹, which is effectively a constructor call to the generated delegate with any captured values passed in, including (possibly) an invocation target². This alleviates the performance hit by removing the bootstrapping process for subsequent calls.

---

¹ See java.lang.invoke end of chapter "timing of linkage", courtesy of @Holger.

² In the case of a lambda which no captures, the invokedynamic instruction will usually resolve to a shared delegate instance that can be reused during subsequent calls, though this is an implementation detail.

why lambda expression doesn't write `.class` but inner class do

This is because lambdas are invoked dynamically.

Refer to this: http://wiki.jvmlangsummit.com/images/1/1e/2011_Goetz_Lambda.pdf

How Java know which method should be override when use lambda expression

Thilo is right.

Nevertheless, the term

Single-Method-Interfaces

is not the more appropriate because a functional interface may have multiple methods : potentially multiple default methods but one and single abstract method.

For example it is a valid functional interface :

@FunctionalInterface
public interface MyInterface {

    Integer getResult();
    default boolean isNoResult(){
       return getResult()==null;
    }
}

An expression lambda can be used only in the context of a functional interface.
A functional interface is a Java interface specifying one and single abstract method.
In your example, Comparator and Runnable have only one abstract method.
More details here : https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html

How jvm know, this lambda should override the right method? In above
examples, they are run() and compare().

If you use a lambda expression with a no functional interface, the compilation wil be in error : the compiler will indeed complain about it with the explicit message :

The target type of this expression must be a functional interface

So, even if it is not mandatory, if you create a interface in the aim being a functional interface, it is a good practice to declare it with the annotation @FunctionalInterface to enforce the compiler to check it is a valid functional interface : one and single abstract method. In this way, you would know right now when your interface is a functional interface valid or not.

That's why JDK classes in Java 8 does it.

---

Related Topics