Method References

Background or Issue:

　　It's no sence to invoke an existing method by a lambda expression，so do it with method's name.

 

Introduction with Example

public class MethodReferencesTest {

  // The method transferElements copies elements from one
  // collection to another

  public static <T, SOURCE extends Collection<T>, DEST extends Collection<T>>
    DEST transferElements(
        SOURCE sourceCollection,
        Supplier<DEST> collectionFactory){

    DEST result = collectionFactory.get();
    for (T t : sourceCollection) {
      result.add(t);
    }
    return result;
  }

  public static void main(String[] args) {

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

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

    Person[] rosterAsArray = roster.toArray(new Person[roster.size()]);


    class PersonAgeComparator implements Comparator <Person>{
      @Override
      public int compare(Person o1, Person o2) {
        return o1.getBirthday().compareTo(o2.getBirthday());
      }
    }

    // Without method reference
    Arrays.sort(rosterAsArray, new PersonAgeComparator());

    // With lambda expression
    // Notice that the interface Comparator is a functional interface.
    // Therefore, use a lambda expression instead of defining
    // and then creating a new instance of a class that implements Comparator
    Arrays.sort(rosterAsArray,
        (a, b) -> a.getBirthday().compareTo(b.getBirthday()));

    // Invokes an existing method with lambda expression
    // This method to compare the birth dates of two Person instances
    // already exists as Person.compareByAge. Invoke this method instead
    // in the body of the lambda expression
    Arrays.sort(rosterAsArray,
        (a, b) -> Person.compareByAge(a, b));

    // 1. Reference to a Static Method
    Arrays.sort(rosterAsArray, Person::compareByAge);

    // 2. Reference to an instance method of a particular object
    class ComparisionProvider{
      public int compareByName(Person a, Person b){
        return a.getName().compareTo(b.getName());
      }

      public int compareByAge(Person a, Person b){
        return a.getBirthday().compareTo(b.getBirthday());
      }
    }
    ComparisionProvider myComparisionProvider = new ComparisionProvider();
    Arrays.sort(rosterAsArray, myComparisionProvider::compareByAge);

    // 3. Reference to an instance method
    // of an arbitrary object of a particular type
    String[] stringArray = { "Barbara", "James", "Mary", "John",
        "Patricia", "Robert", "Michael", "Linda" };
    Arrays.sort(stringArray, String::compareToIgnoreCase);

    // the equivalent lambda expression for the method inference
    // String::compareToIgnoreCase
    Arrays.sort(stringArray, (a, b) -> a.compareToIgnoreCase(b));

    // 4. Reference to a Constructor
    // You can reference a constructor in the same way
    // as a static method by using the name new.
    Set<Person> rosterSetLambda =
        transferElements(roster, () -> new HashSet<>());

    // use a constructor reference in place of the lambda expression
    // The Java compiler infers that you want to create a HashSet
    // collection that contains elements of type Person
    Set<Person> rosterSet = transferElements(
        roster, HashSet::new);

    System.out.println("Printing rosterSet: ");
    rosterSet.stream().forEach(p -> p.printPerson());
  }
}