Lambda Expressions

Backgroud or Issues:

　　It is unclear and complex to implement a functional interface(only contains one abstract methond)

　    with an anonymous class when you want to pass the function as an argument to a method.

　　Lambda Expression allows you to treat functionality as method argument, or code as data.

Ideal Use Case for Lambda Expressions

　　The following code shows that administrators in an application set some conditions to select members.

　　Person class(member class)

public class Person {

  public enum Sex {
    MALE, FEMALE
  }

  String name;
  LocalDate birthday;
  Sex gender;
  String emailAddress;

  Person(String nameArg, LocalDate birthdayArg,
         Sex genderArg, String emailArg) {
    name = nameArg;
    birthday = birthdayArg;
    gender = genderArg;
    emailAddress = emailArg;
  }

  public int getAge() {
    return birthday
        .until(IsoChronology.INSTANCE.dateNow())
        .getYears();
  }

  public void printPerson() {
    System.out.println(name + ", " + this.getAge());
  }

  public Sex getGender() {
    return gender;
  }

  public String getName() {
    return name;
  }

  public String getEmailAddress() {
    return emailAddress;
  }

  public LocalDate getBirthday() {
    return birthday;
  }

  public static int compareByAge(Person a, Person b) {
    return a.birthday.compareTo(b.birthday);
  }

  public static List<Person> createRoster() {

    List<Person> roster = new ArrayList<>();
    roster.add(
        new Person(
            "Fred",
            IsoChronology.INSTANCE.date(1980, 6, 20),
            Person.Sex.MALE,
            "fred@example.com"));
    roster.add(
        new Person(
            "Jane",
            IsoChronology.INSTANCE.date(1990, 7, 15),
            Person.Sex.FEMALE, "jane@example.com"));
    roster.add(
        new Person(
            "George",
            IsoChronology.INSTANCE.date(1991, 8, 13),
            Person.Sex.MALE, "george@example.com"));
    roster.add(
        new Person(
            "Bob",
            IsoChronology.INSTANCE.date(2000, 9, 12),
            Person.Sex.MALE, "bob@example.com"));

    return roster;
  }
}

 　　RosterTest class(main class)

public class RosterTest {

  // functional interface of only one abstract method,
  // which is so simple that it has no worth in there,
  // you can see better usages in Approach 6 and later
  interface CheckPerson {
    boolean test(Person p);
  }

  // Approach 1: Create Methods that Search for Persons that Match One
  // Characteristic

  public static void printPersonsOlderThan(List<Person> roster, int age) {
    for (Person p : roster) {
      if (p.getAge() >= age) {
        p.printPerson();
      }
    }
  }
  /**
   * review
   * advantage: simplistic
   * disadvantage: the code is brittle, what if you want to print
   * members younger than a certain age ?
   */

  // Approach 2: Create More Generalized Search Methods

  public static void printPersonsWithinAgeRange(
      List<Person> roster, int low, int high) {
    for (Person p : roster) {
      if (low <= p.getAge() && p.getAge() < high) {
        p.printPerson();
      }
    }
  }
  /**
   * review
   * advantage: more generic
   * disadvantage: what if you want to print member of a specified sex,
   * or other specified criteria ?
   * suggest: do not creat another new method with different conditions,
   * you should separate the code in a different class.
   */

  // Approach 3: Specify Search Criteria Code in a Local Class
  // Approach 4: Specify Search Criteria Code in an Anonymous Class
  // Approach 5: Specify Search Criteria Code with a Lambda Expression

  public static void printPersons(
      List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
      if (tester.test(p)) {
        p.printPerson();
      }
    }
  }

  // Approach 6: Use Standard Functional Interfaces with Lambda Expressions

  public static void printPersonsWithPredicate(
      List<Person> roster, Predicate<Person> tester) {
    for (Person p : roster) {
      if (tester.test(p)) {
        p.printPerson();
      }
    }
  }
  /**
   * review
   * advantage: omit the functional interface through using an
   * existing functional interface Predicate<T> in JDK
   *
   */

  // Approach 7: Use Lambda Expressions Throughout Your Application

  public static void processPersons(
      List<Person> roster,
      Predicate<Person> tester,
      Consumer<Person> block) {
    for (Person p : roster) {
      if (tester.test(p)) {
        block.accept(p);
      }
    }
  }

  // Approach 7, second example

  public static void processPersonsWithFunction(
      List<Person> roster,
      Predicate<Person> tester,
      Function<Person, String> mapper,
      Consumer<String> block) {
    for (Person p : roster) {
      if (tester.test(p)) {
        String data = mapper.apply(p);
        block.accept(data);
      }
    }
  }

  // Approach 8: Use Generics More Extensively

  public static <X, Y> void processElements(
      Iterable<X> source,
      Predicate<X> tester,
      Function<X, Y> mapper,
      Consumer<Y> block) {
    for (X p : source) {
      if (tester.test(p)) {
        Y data = mapper.apply(p);
        block.accept(data);
      }
    }
  }

  public static void main(String... args) {

    List<Person> roster = Person.createRoster();

    for (Person p : roster) {
      p.printPerson();
    }

    // Approach 1: Create Methods that Search for Persons that Match One
    // Characteristic

    System.out.println("Persons older than 20:");
    printPersonsOlderThan(roster, 20);
    System.out.println();

    // Approach 2: Create More Generalized Search Methods

    System.out.println("Persons between the ages of 14 and 30:");
    printPersonsWithinAgeRange(roster, 14, 30);
    System.out.println();

    // Approach 3: Specify Search Criteria Code in a Local Class

    System.out.println("Persons who are eligible for Selective Service:");

    // the declaration of local class is additional than anonymous class
    class CheckPersonEligibleForSelectiveService implements CheckPerson {
      public boolean test(Person p) {
        return p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25;
      }
    }
    /**
     * review
     * advantage: less brittle
     * disadvantage: have additional code-a new interface and a local lass
     * for each search
     * suggest: use an anonymous class, don't need declare a new class for
     * each search
     */

    printPersons(
        roster, new CheckPersonEligibleForSelectiveService());

    System.out.println();

    // Approach 4: Specify Search Criteria Code in an Anonymous Class

    System.out.println("Persons who are eligible for Selective Service " +
        "(anonymous class):");

    printPersons(
        roster,
        // more brittle than local class, don't have declaration of class
        // but bulky because of only one method in the interface
        new CheckPerson() {
          public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
          }
        }
    );
    /**
     * review
     * advantage: reduce the code scale
     * disadvantage: bulky as for there is only one method in the interface
     * suggest: use a lambda expression
     */

    System.out.println();

    // Approach 5: Specify Search Criteria Code with a Lambda Expression

    System.out.println("Persons who are eligible for Selective Service " +
        "(lambda expression):");

    printPersons(
        roster,
        // lambda expression, omit the name of abstract method
        (Person p) -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25
    );
    /**
     * review
     * advantage: more concise
     * disadvantage: not the best practice
     * suggest: use a standard functional interface provided by java.util.function,
     * instead of defining a new interface
     */

    System.out.println();

    // Approach 6: Use Standard Functional Interfaces with Lambda
    // Expressions

    System.out.println("Persons who are eligible for Selective Service " +
        "(with Predicate parameter):");

    printPersonsWithPredicate(
        roster,
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25
    );

    System.out.println();

    // Approach 7: Use Lambda Expressions Throughout Your Application

    System.out.println("Persons who are eligible for Selective Service " +
        "(with Predicate and Consumer parameters):");

    processPersons(
        roster,
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25,
        p -> p.printPerson()
    );

    System.out.println();

    // Approach 7, second example

    System.out.println("Persons who are eligible for Selective Service " +
        "(with Predicate, Function, and Consumer parameters):");

    processPersonsWithFunction(
        roster,
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25,
        p -> p.getEmailAddress(),
        email -> System.out.println(email)
    );

    System.out.println();

    // Approach 8: Use Generics More Extensively

    System.out.println("Persons who are eligible for Selective Service " +
        "(generic version):");

    processElements(
        roster,
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25,
        p -> p.getEmailAddress(),
        email -> System.out.println(email)
    );

    System.out.println();

    // Approach 9: Use Bulk Data Operations That Accept Lambda Expressions
    // as Parameters

    System.out.println("Persons who are eligible for Selective Service " +
        "(with bulk data operations):");

    roster
        // Obtain a source of objects
        .stream()
        // Filter objects that match a Predicate object
        .filter(
            p -> p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25)
        // Map objects to another value as specified by a Function object
        .map(p -> p.getEmailAddress())
        // Perform an action as specified by a Consumer object
        .forEach(email -> System.out.println(email));
  }
}

Syntax of Lambda Expressions

　　A comma-separated list of formal parameters enclosed in parentheses. 

　　Note：You can omit the data type of the parameters in a lambda expression.

　　In addition, you can omit the parentheses if there is only one parameter.

　　For example

p -> p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25

　　A -> token

　　A body, which consists of a single expression or a statement block.

　　For example

//a body of a single expression
p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25

// a statement block
p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}

// a void method invocation
email -> System.out.println(email)

 Note that you can consider lambda expressions as anonymous methods—methods without a name.

Accessing Local Variables of the Enclosing Scope

　　Lambda expressions have access to local variables of the encolsing scope, but have no shadowing issues, 

　　as they are lexically scoped, they don't inherit any names from a supertype or introduce a new level of scope.

　　For example

import java.util.function.Consumer;

public class LambdaScopeTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            
            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99;
            
            Consumer<Integer> myConsumer = (y) -> 
            {
                System.out.println("x = " + x); // Statement A, 23
                System.out.println("y = " + y); // 23
                System.out.println("this.x = " + this.x); // 1
                System.out.println("LambdaScopeTest.this.x = " +
                    LambdaScopeTest.this.x); // 0
            };

            myConsumer.accept(x);

        }
    }

    public static void main(String... args) {
        LambdaScopeTest st = new LambdaScopeTest();
        LambdaScopeTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

 　　Note that you cann't substitute x in place of y in the following code, otherwise the compile generates a error 

　　"variable x is already defined in method methodInFirstLevel(int)" because

　　the lambda expression does not introduce a new level of scoping.

Consumer<Integer> myConsumer = (x) -> {  
    // ...  
} 

　　 Like local and anonymous classes, a lambda expression can only access local variables

　　and parameters of the enclosing block that are final or effectively final.

　　The following code is error

void methodInFirstLevel(int x) {
    x = 99;
    // ...
}

Target Typing

　　Now recall a lambda expression an two methods 

p -> p.getGender() == Person.Sex.MALE
    && p.getAge() >= 18
    && p.getAge() <= 25

public static void printPersons(List<Person> roster, CheckPerson tester)

public void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester)

　　When jvm invokes the printPersons method, the parameter type is CheckerPerson, so as to the lambda expression.

　　In the same way, When printPersonsWithPredicate invoked, the target type is Predicate<Person>, so as to the lambda expression.

　　The data type that these methods expect is called the target type. 

　　To determine the type of a lambda expression, the Java compiler uses the target type of the context or situation

　　 in which the lambda expression was found. 

Target Types and Method Arguments 

　　Consider the following two functional interfaces

public interface Runnable {
    void run();
}

public interface Callable<V> {
    V call();
}

　　You have overloaded the method invoke as follows

void invoke(Runnable r) {
    r.run();
}

<T> T invoke(Callable<T> c) {
    return c.call();
}

　

　　Which method will be invoked in the following statement?

String s = invoke(() -> "done");

　　The method invoke(Callable<T>) will be invoked because that method returns a value;

　　the method invoke(Runnable) does not. In this case, the type of the lambda expression () -> "done" is Callable<T>.

Serialization

　　strongly discouraged

reference from: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax