What is the breakdown for Java’s lambda syntax?

by

Syntax is:

arguments -> body

where arguments can be either

  • ()

  • a single variable if the type of that variable can be inferred from the context

  • a sequence of variables, with or without types (or since Java 11, with var), in parentheses.
    Examples: (x), (x, y), (int x, int y), (var x, var y) (Java 11+).
    The following are invalid: (int x, y), (x, var y), (var x, int y)

and body can be either an expression or a {...} block with statements. The expression (other than a method or constructor call) is simply returned, i.e. () -> 2 is equivalent to () -> {return 2;}

In case of lambda expressions like () -> f() (the body is a method or constructor call expression):

  • if f() returns void, they are equivalent to () -> { f(); }

  • otherwise, they are equivalent to either () -> { f(); } or () -> { return f(); }). The compiler infers it from the calling context, but usually it will prefer the latter.

Therefore, if you have two methods: void handle(Supplier<T>) and void handle(Runnable), then:

  • handle(() -> { return f(); }) and handle(() -> x) will call the first one,

  • handle(() -> { f(); } will call the second one, and

  • handle(() -> f()):

    • if f() returns void or a type that is not convertible to T, then it will call the second one

    • if f() returns a type that is convertible to T, then it will call the first one

The compiler tries to match the type of the lambda to the context. I don’t know the exact rules, but the answer to:

What would happen if there were two SwingUtilities.invokeLater methods which differ only in parameter list?

is: it depends on what would be those parameter lists. If the other invokeLater had also exactly one parameter and that parameter would be of type that is also an interface with one method of type void*(), well, then it would complain that it cannot figure out which method you mean.

Why are they written as they are? Well, I think it’s because syntax in C# and Scala is almost the same (they use => rather than ->).

More Related Contents:

  1. Java 8 List into Map
  2. Comparator.reversed() does not compile using lambda
  3. Java8 Lambdas vs Anonymous classes
  4. Java 8: Lambda-Streams, Filter by Method with Exception
  5. Lambda ‘special void-compatibility rule’ – statement expression
  6. Instance Method Reference and Lambda Parameters
  7. Java 8 method reference unhandled exception
  8. Modifying local variable from inside lambda
  9. Lambda expression and method overloading doubts
  10. Why doesn’t java.util.Collection implement the new Stream interface?
  11. Java 8 chained method reference?
  12. Java 8 lambda expression and first-class values
  13. How to dynamically do filtering in Java 8?
  14. Why can’t I throw an exception in a Java 8 lambda expression? [duplicate]
  15. Do lambda expressions have any use other than saving lines of code?
  16. What is a Java 8 Lambda Expression Compiled to? [duplicate]
  17. Why does Stream.allMatch() return true for an empty stream?
  18. Java idiom for lambdas with non-SAM interfaces
  19. When are braces optional in Java 8 lambda syntax?
  20. Should Optional.ofNullable() be used for null check?
  21. Implement recursive lambda function using Java 8
  22. Proper usage of Optional.ifPresent()
  23. How to debug stream().map(…) with lambda expressions?
  24. java: Arrays.sort() with lambda expression
  25. Picking elements of a list until condition is met with Java 8 Lambdas
  26. Why does this Java 8 lambda fail to compile?
  27. FunctionalInterface Comparator has 2 abstract methods
  28. Group sequences of values
  29. Stream.peek() method in Java 8 vs Java 9
  30. Java 8 stream map to list of keys sorted by values

Leave a Comment