函数式接口的基础理解

• 函数式接口是Java 8引入的一个关键特性，为Java语言带来了函数式编程的风格。在函数式编程中，函数被视为一等公民，这意味着函数可以作为参数传递给其他函数，也可以作为返回值，或者赋值给变量。

函数式接口的核心概念

• 函数式接口是指只有一个抽象方法的接口，但可以包含多个默认方法和静态方法。这些接口通常用@FunctionalInterface注解来标识，可以提供编译时检查，确保接口符合函数式接口的定义。

函数式接口的特点

• Lambda表达式：函数式接口可以与Lambda表达式无缝配合，Lambda表达式提供了一种简洁的方式来实现函数式接口。
• 高阶函数：函数式接口允许将函数作为参数传递或将函数作为返回值
• 不变性：函数式接口通常与不可变数据一起使用，有助于减少程序中的副作用和并发问题。

函数式接口的定义：一个函数式接口必须满足以下条件：

• 接口中只有一个抽象方法（可以有多个默认方法和静态方法）。
• 使用@FunctionalInterface注解

函数式接口的实例：Lambda表达式

• Lambda表达式是实现函数式接口的简洁方式。它是一个匿名函数，可以捕获周围上下文的变量，使得代码更加简洁。

Lambda表达式的语法

Lambda表达式的一般形式为：

(parameters) -> expression

或者

(parameters) -> { statements; }

• parameters：参数列表，可以省略类型，如果只有一个参数且其类型可推导，甚至可以省略括号。
• ->：Lambda操作符，用来分隔参数列表和Lambda体。
• expression：当Lambda体只有一个表达式时，可以直接写表达式，而不需要大括号和return语句。
• statements：当Lambda体包含多条语句时，必须使用大括号包围，并且需要显式使用return语句。

常用函数式接口示例

• Supplier<T> - 供应型接口，用于生成类型的实例。

Supplier<String> supplier = () -> "Hello, World!"; 
String result = supplier.get();

• Consumer<T> - 消费型接口，用于处理类型的实例。

Consumer<String> consumer = (s) -> System.out.println(s); 
consumer.accept("Hello, Functional Interfaces!");

• Function<T, R> - 函数型接口，用于将类型T的实例转换为类型R的实例。

Function<String, Integer> toLength = (s) -> s.length(); 
int length = toLength.apply("Hello");

• Predicate<T> - 断言型接口，用于判断类型T的实例是否满足某些条件。

Predicate<String> isEmpty = (s) -> s.isEmpty(); 
boolean result = isEmpty.test("");

• BinaryOperator<T> - 二元操作符接口，用于对两个类型T的实例进行操作。

BinaryOperator<Integer> sum = (a, b) -> a + b; 
int result = sum.apply(1, 2);

函数式编程的实践及高级特性，例子有重复不妨碍学习额

• 作为方法参数：

public void doSomething(Consumer<String> action) { 
  action.accept("Parameter passed to the Consumer");
} 
doSomething(s -> System.out.println(s.toUpperCase()));

• 作为方法返回值：

public Function<String, Integer> createLengthFunction() 
{
  return String::length; 
} 
Function<String, Integer> lengthFunction = createLengthFunction();
int length = lengthFunction.apply("Hello");

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream() .filter(name -> name.length() > 4)
  .map(String::toUpperCase)
  .forEach(System.out::println); 
// Prints each name in uppercase that has more than 4 characters

• 方法引用：可以直接引用已有方法或构造函数。

Function<String, Integer> lengthFunc = String::length;

• 构造函数引用：

Supplier<MyObject> constructor = MyObject::new; 
MyObject obj = constructor.get();

• 组合和链式调用：

Function<String, Integer> toLength = String::length; 
Function<String, Integer> toUpperCase = String::toUpperCase; 
Function<String, Integer> toLengthAfterUpper = toLength.andThen(toUpperCase);

• 使用@FunctionalInterface注解：

@FunctionalInterface 
interface MyFunctionalInterface {
  int doSomething(int a, int b); 
}

• 延迟执行：Lambda表达式是延迟执行的，只有在需要时才会计算结果，这有助于提高性能。

MessageBuilder builder = () -> "This message will be built only when needed.";
String message = builder.buildMessage();

• 作为参数和返回值：Lambda表达式可以作为函数式接口的参数和返回值。

// 使用Lambda作为参数 
Comparator<String> comparator = (a, b) -> a.length() - b.length(); 
List<String> list = Arrays.asList("apple", "banana", "cherry"); 
list.sort(comparator); // 返回Lambda作为结果 
Runnable task = () -> System.out.println("Running a task!"); 
new Thread(task).start();

• 函数组合：Function接口提供了andThen和compose方法，允许将多个函数组合在一起。

Function<String, Integer> toLength = String::length; 
Function<Integer, Integer> increment = i -> i + 1; 
Function<String, Integer> toLengthAndIncrement = toLength.andThen(increment);
int result = toLengthAndIncrement.apply("Lambdas");

函数式接口和Lambda表达式的使用可以显著提高代码的可读性和模块化程度。开发中一些常见使用场景

• 事件处理： 在图形用户界面（GUI）编程或Web开发中，事件处理器（如按钮点击、页面加载等）通常会使用函数式接口。通过将事件处理逻辑定义为Lambda表达式，可以轻松地将这些逻辑与事件源解耦，从而使得代码更加简洁和灵活。

button.addActionListener(event -> { 
  // 处理点击事件 
});

• 异步编程： 在进行异步操作，如网络请求或数据库操作时，回调函数通常用于处理异步操作完成后的结果。使用函数式接口可以让这些回调函数更加简洁，并且易于管理。

CompletableFuture.supplyAsync(() -> { 
  // 异步任务 
}).thenAccept(result -> {
  // 处理结果
});

• 集合处理： Java 8的流（Stream）API大量使用函数式接口，如Predicate、Function和Consumer，来处理集合数据。这些接口使得集合过滤、映射和聚合操作变得非常简洁。

list.stream() 
  .filter(item -> item.isActive())
  .map(item -> item.getName()) 
  .forEach(System.out::println);

• 定时任务和计划任务： 在需要执行定时任务的场景中，如调度任务或缓存失效，可以使用函数式接口来定义任务的执行逻辑，从而与调度器解耦。

scheduler.scheduleAtFixedRate(() -> { 
  // 执行定时任务 
}, 0, 1, TimeUnit.SECONDS);

• 命令模式： 命令模式是一种行为设计模式，它将请求封装为一个对象，从而使你可以使用不同的请求对客户进行参数化。在Java中，可以使用函数式接口来表示命令，并通过命令的执行来解耦请求的发送者和接收者。

Consumer<String> command = message -> { 
  // 处理消息 
}; 
executeCommand(command, "Hello, World!");

Function<Integer, Integer> strategyA = x -> x * 2; 
Function<Integer, Integer> strategyB = x -> x + 3; 
// 根据需要选择策略 
Function<Integer, Integer> currentStrategy = strategyA;

• 模板方法模式： 在模板方法模式中，一个抽象类定义了一个算法的骨架，而将一些步骤的实现延迟到子类中。可以使用函数式接口来表示这些可延迟的步骤，从而提供更大的灵活性。

abstract class AbstractClass { 
  public void templateMethod() { 
    step1(); 
    step2(); 
    step3(); 
  } 
  protected void step1() {
    // 默认实现 
  }
  protected void step2() { 
    // 默认实现 
  } 
  protected void step3() 
  { 
    someStep(); 
  } 
  protected void someStep() { 
    // 调用函数式接口的实现 
    this.someStepAction.accept(); 
  } 
  private Consumer<Void> someStepAction = () -> { 
    // 用户定义的逻辑 
  }; 
  }