Java 8 BiFunction, BiConsumer and BiPredicate Tutorial

//Employee.java
public class Employee {
  private final String name;
  private final double salary;

  public Employee(String name, double salary) {
    this.name = name;
    this.salary = salary;
  }

  public String getName() { return name; }
  public double getSalary() { return salary; }

  @Override
  public String toString() { return name + " (" + salary + ")"; }
}

//BiInterfaces.java
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;

public class BiInterfaces {

  public static void main(String[] args) {
    // 1. BiFunction<T, U, R>: two inputs, one result
    BiFunction<Employee, Double, Double> raised =
        (e, percent) -> e.getSalary() * (1 + percent / 100);
    Employee tom = new Employee("Tom Jones", 5000);
    System.out.println("1. Tom after a 4% raise: " + raised.apply(tom, 4.0));

    // 2. andThen(Function): pass the BiFunction's result to a Function
    Function<Double, String> asText = amount -> String.format("%.2f a month", amount);
    System.out.println("2. " + raised.andThen(asText).apply(tom, 4.0));

    // 3. A constructor reference as a BiFunction
    BiFunction<String, Double, Employee> hire = Employee::new;
    Employee nancy = hire.apply("Nancy Smith", 5800.0);
    System.out.println("3. hired: " + nancy);

    // 4. BiConsumer<T, U>: two inputs, no result - Map.forEach takes one
    Map<String, Integer> leaveLeft = new TreeMap<>();
    leaveLeft.put("Tom Jones", 12);
    leaveLeft.put("Harry Major", 3);
    BiConsumer<String, Integer> show =
        (name, days) -> System.out.print(name + ": " + days + "  ");
    BiConsumer<String, Integer> warn = (name, days) -> {
      if (days < 5) System.out.print("(low!)  ");
    };
    System.out.print("4. ");
    leaveLeft.forEach(show.andThen(warn));
    System.out.println();

    // 5. BiPredicate<T, U>: a test on two inputs
    BiPredicate<Employee, Double> earnsAtLeast = (e, amount) -> e.getSalary() >= amount;
    BiPredicate<Employee, Double> underDouble = (e, amount) -> e.getSalary() <= amount * 2;
    BiPredicate<Employee, Double> inBand = earnsAtLeast.and(underDouble);
    System.out.println("5. Nancy at least 5000? " + earnsAtLeast.test(nancy, 5000.0)
        + ", in band 3000-6000? " + inBand.test(nancy, 3000.0)
        + ", not at least 6000? " + earnsAtLeast.negate().test(nancy, 6000.0));

    // 6. Method references that match BiPredicate and BiFunction
    BiPredicate<String, String> startsWith = String::startsWith;
    BiFunction<Integer, Integer, Integer> larger = Math::max;
    System.out.println("6. \"Harry Major\" starts with \"Har\"? "
        + startsWith.test("Harry Major", "Har")
        + ", larger of 7 and 12: " + larger.apply(7, 12));

    // 7. Passing a BiFunction into a method
    List<Employee> team = Arrays.asList(tom, nancy, new Employee("Harry Major", 4100));
    double bonuses = payAll(team, 10.0, (e, pct) -> e.getSalary() * pct / 100);
    System.out.println("7. total bonuses at 10%: " + bonuses);
  }

  // Applies any two-argument rule to every employee
  static double payAll(List<Employee> team, double rate,
                       BiFunction<Employee, Double, Double> rule) {
    double total = 0;
    for (Employee e : team) {
      total += rule.apply(e, rate);
    }
    return total;
  }
}

@FunctionalInterface
interface TriFunction<A, B, C, R> {
  R apply(A a, B b, C c);
}

TriFunction<Double, Double, Integer, Double> compound =
    (amount, rate, years) -> amount * Math.pow(1 + rate, years);