Java Supplier和Consumer接口

Supplier

在Java中，Supplier接口是一个重要的函数式接口，它属于java.util.function包，Supplier通常用于延迟计算或生成值的场景。Supplier接口是一个泛型接口，其get()方法不接受任何参数但返回一个泛型类型T的值。 这个接口被注解为@FunctionalInterface，表明它是一个函数式接口，可以用于Lambda表达式。

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

示例代码：

import java.util.Random;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        // 创建一个Supplier接口的实例，通过Lambda表达式实现get()方法来生成随机数
        Supplier<Integer> randomSupplier = () -> {
            Random random = new Random();
            return random.nextInt(100); // 生成0到99的随机数
        };

        int randomNumber = randomSupplier.get();
        System.out.println("随机数：" + randomNumber);
    }
}

Supplier接口的一个强大之处在于它支持惰性计算。这意味着生成值的计算只会在需要时才执行。例如以下示例，其中我们使用Supplier来延迟计算字符串的长度：

String text = "Hello, World!";
Supplier<Integer> lengthSupplier = () -> text.length();

// 假设有一些其他耗时操作

int length = lengthSupplier.get();
System.out.println("字符串长度：" + length);

在某些情况下，可以使用Supplier接口来处理异常情况。例如，如果一个方法可能会抛出异常，可以使用Supplier来封装这个方法，并在调用get()方法时捕获异常：

import java.util.function.Supplier;

public class SupplierWithExceptionHandling {
    public static void main(String[] args) {
        // 创建一个Supplier实例，其中包含可能抛出异常的操作
        Supplier<String> supplier = () -> {
            try {
                // 在这里执行可能会抛出异常的操作
                return "Hello, World!";
            } catch (Exception e) {
                // 处理异常情况
                return "An error occurred: " + e.getMessage();
            }
        };

        // 调用Supplier的get()方法，并处理可能的异常
        try {
            String result = supplier.get();
            System.out.println(result);
        } catch (Exception e) {
            // 如果Supplier内部的try-catch块没有处理异常，这里可以再次捕获并处理
            System.err.println("Error in Supplier: " + e.getMessage());
        }
    }
}

其中的lambda表达式包含了一个try-catch块。当调用supplier.get()时，它会尝试执行可能会抛出异常的操作，并在catch块中处理异常。这样，即使Supplier内部的操作抛出了异常，程序仍然可以继续运行，并且可以根据需要处理异常情况。

Consumer

Consumer接口也是一个函数式接口，它表示一个接受单一输入参数并且不返回任何结果的操作。 你可以把它想象成一个消费者，你给它一个东西，它消费掉这个东西，但不给你任何回报。
Consumer接口在Java 8中定义如下：

@FunctionalInterface
public interface Consumer<T> {

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

}

Consumer接口中定义了一个accept方法，它接受一个泛型类型T的参数，并且没有返回值（void）。此外，它还提供了一个默认方法andThen，允许将多个Consumer串联起来，形成一个操作链。
使用示例，使用 Consumer 接口对集合中的元素进行求和操作：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 使用 AtomicInteger 来保存结果
AtomicInteger sum = new AtomicInteger();

Consumer<Integer> addToSum = num -> sum.addAndGet(num);

numbers.forEach(addToSum);

System.out.println("Sum: " + sum); // 输出 "Sum: 15"

条件执行： 可以使用filter方法来创建一个仅在满足特定条件时才执行操作的Consumer。这对于过滤集合中的元素非常有用：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Consumer<Integer> printEvenNumbers = n -> {
    if (n % 2 == 0) {
        System.out.println(n);
    }
};
numbers.forEach(printEvenNumbers);

异常处理： 可以使用try-catch块来处理Consumer中可能发生的异常。这可以确保即使发生错误，程序也不会崩溃：

Consumer<String> printLength = s -> {
    try {
        System.out.println(s.length());
    } catch (Exception e) {
        System.err.println("Error processing string: " + e.getMessage());
    }
};
printLength.accept("Hello, World!");

总结

1. Consumer 接口为函数式编程提供了重要的支持。通过使用 Consumer 接口，我们可以轻松地定义并执行一个接受一个参数并且不返回结果的操作。Consumer 接口特别适用于遍历集合或执行消费型操作。
2. Supplier接口提供了一种灵活而强大的机制来获取或生成数据，使用Supplier接口可以使代码更加灵活和易于维护，特别是在需要生成值或进行惰性计算的情况里。