java中functional interface的分类和使用详解

//ExecutorService using class
 ExecutorService executorService = Executors.newSingleThreadExecutor();
 executorService.submit(new Runnable() {
  @Override
  public void run() {
  log.info("new runnable");
  }
 });

//ExecutorService using lambda
 executorService.submit(()->log.info("new runnable"));

@FunctionalInterface
public interface Runnable

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

@FunctionalInterface
public interface Function<T, R> {

 /**
 * Applies this function to the given argument.
 *
 * @param t the function argument
 * @return the function result
 */
 R apply(T t)；

Map<String, Integer> nameMap = new HashMap<>();
 Integer value = nameMap.computeIfAbsent("name", s -> s.length());

Integer value1 = nameMap.computeIfAbsent("name", String::length);

@FunctionalInterface
public interface IntFunction<R> {

 /**
 * Applies this function to the given argument.
 *
 * @param value the function argument
 * @return the function result
 */
 R apply(int value);
}

@FunctionalInterface
public interface ToDoubleFunction<T> {

 /**
 * Applies this function to the given argument.
 *
 * @param value the function argument
 * @return the function result
 */
 double applyAsDouble(T value);
}

@FunctionalInterface
public interface LongToIntFunction {

 /**
 * Applies this function to the given argument.
 *
 * @param value the function argument
 * @return the function result
 */
 int applyAsInt(long value);
}

@FunctionalInterface
public interface BiFunction<T, U, R> {

 /**
 * Applies this function to the given arguments.
 *
 * @param t the first function argument
 * @param u the second function argument
 * @return the function result
 */
 R apply(T t, U u);

//BiFunction
 Map<String, Integer> salaries = new HashMap<>();
 salaries.put("alice", 100);
 salaries.put("jack", 200);
 salaries.put("mark", 300);

 salaries.replaceAll((name, oldValue) ->
  name.equals("alice") ? oldValue : oldValue + 200);

@FunctionalInterface
public interface Supplier<T> {

 /**
 * Gets a result.
 *
 * @return a result
 */
 T get();
}

@FunctionalInterface
public interface Consumer<T> {

 /**
 * Performs this operation on the given argument.
 *
 * @param t the input argument
 */
 void accept(T t);

//Consumer
nameMap.forEach((name, age) -> System.out.println(name + " is " + age + " years old"));

@FunctionalInterface
public interface Predicate<T> {

 /**
 * Evaluates this predicate on the given argument.
 *
 * @param t the input argument
 * @return {@code true} if the input argument matches the predicate,
 * otherwise {@code false}
 */
 boolean test(T t);

//Predicate
 List<String> names = Arrays.asList("A", "B", "C", "D", "E");
 List<String> namesWithA = names.stream()
  .filter(name -> name.startsWith("A"))
  .collect(Collectors.toList());

@FunctionalInterface
public interface IntUnaryOperator {

 /**
 * Applies this operator to the given operand.
 *
 * @param operand the operand
 * @return the operator result
 */
 int applyAsInt(int operand);

//Operator
 List<Integer> values = Arrays.asList(1, 2, 3, 4, 5);
 int sum = values.stream()
  .reduce(0, (i1, i2) -> i1 + i2);