How do I define a method which takes a lambda as a parameter in Java 8?

Lambdas are purely a call-site construct: the recipient of the lambda does not need to know that a Lambda is involved, instead it accepts an Interface with the appropriate method.

In other words, you define or use a functional interface (i.e. an interface with a single method) that accepts and returns exactly what you want.

For this Java 8 comes with a set of commonly-used interface types in java.util.function (thanks to Maurice Naftalin for the hint about the JavaDoc).

For this specific use case there's java.util.function.IntBinaryOperator with a single int applyAsInt(int left, int right) method, so you could write your method like this:

static int method(IntBinaryOperator op){    return op.applyAsInt(5, 10);}

But you can just as well define your own interface and use it like this:

public interface TwoArgIntOperator {    public int op(int a, int b);}//elsewhere:static int method(TwoArgIntOperator operator) {    return operator.op(5, 10);}

Then call the method with a lambda as parameter:

public static void main(String[] args) {    TwoArgIntOperator addTwoInts = (a, b) -> a + b;    int result = method(addTwoInts);    System.out.println("Result: " + result);}

Using your own interface has the advantage that you can have names that more clearly indicate the intent.

To use Lambda expression you need to either create your own functional interface or use Java functional interface for operation that require two integer and return as value. IntBinaryOperator

Using user defined functional interface

interface TwoArgInterface {    public int operation(int a, int b);}public class MyClass {    public static void main(String javalatte[]) {        // this is lambda expression        TwoArgInterface plusOperation = (a, b) -> a + b;        System.out.println("Sum of 10,34 : " + plusOperation.operation(10, 34));    }}

Using Java functional interface

import java.util.function.IntBinaryOperator;public class MyClass1 {    static void main(String javalatte[]) {        // this is lambda expression        IntBinaryOperator plusOperation = (a, b) -> a + b;        System.out.println("Sum of 10,34 : " + plusOperation.applyAsInt(10, 34));    }}

For functions that do not have more than 2 parameters, you can pass them without defining your own interface. For example,

class Klass {  static List<String> foo(Integer a, String b) { ... }}class MyClass{  static List<String> method(BiFunction<Integer, String, List<String>> fn){    return fn.apply(5, "FooBar");  }}List<String> lStr = MyClass.method((a, b) -> Klass.foo((Integer) a, (String) b));

In BiFunction<Integer, String, List<String>>, Integer and String are its parameters, and List<String> is its return type.

For a function with only one parameter, you can use Function<T, R>, where T is its parameter type, and R is its return value type. Refer to this page for all the interfaces that are already made available by Java.