java8四个函数式接口：Function, Predicate, Consumer, Supplier使用

目录

1、前言

2.  四大函数式接口

1. Function,>

2. Predicate 

3. Consumer

4. Supplier

1、前言

Java 8引入了一种新的接口特性，叫做函数式接口。这种接口只能有一个抽象方法，通常用注解@FunctionalInterface标识。函数式接口可以被隐式地转换为lambda表达式。

以下是一个简单的函数式接口示例，该接口定义了一个名为process的抽象方法：

@FunctionalInterface
public interface Processor<T> {
    void process(T t);
}

使用：

public class ProcessorExample {
    public static void process(Processor<String> processor, String input) {
        processor.process(input);
    }
 
    public static void main(String[] args) {
        process((String s) -> System.out.println("Processing: " + s), "Hello");
    }
}

在这个例子中，process方法接受一个Processor<String>函数式接口的实现，并使用该实现来处理传入的字符串。在main方法中，我们使用了一个lambda表达式来实现Processor接口。

2. 四大函数式接口

Java中四个核心的函数式接口是：Function, Predicate, Consumer, 和 Supplier。下面是对每个接口的详细解释以及实用的例子。

1. Function<T, R>

Function 接口表示一个接受一个类型为 T 的参数并产生一个类型为 R 的结果的函数。它有一个抽象方法 apply(T t)。
实用例子： 假设我们有一个字符串列表，我们想要将所有的字符串转换为大写并返回一个新的列表。

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class FunctionExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("john", "jane", "doe");
        
        // 使用Function接口将所有名字转换为大写
        List<String> upperCaseNames = names.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());
        
        System.out.println(upperCaseNames); // 输出: [JOHN, JANE, DOE]
    }
}

2. Predicate<T> 

Predicate 接口表示一个接受一个类型为 T 的参数并返回一个布尔值的函数。它有一个抽象方法 test(T t)。
实用例子： 假设我们有一个整数列表，我们想要筛选出所有偶数。

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class PredicateExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        
        // 使用Predicate接口过滤出偶数
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());
        
        System.out.println(evenNumbers); // 输出: [2, 4, 6]
    }
}

3. Consumer<T>

Consumer 接口表示一个接受一个类型为 T 的参数但不返回任何结果的函数。它有一个抽象方法 accept(T t)。
实用例子： 假设我们想要打印一个列表中的所有元素。

import java.util.*;
import java.util.function.*;

public class ConsumerExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("john", "jane", "doe");
        
        // 使用Consumer接口打印列表中的所有元素
        names.forEach(System.out::println);
    }
}

4. Supplier<T>

Supplier 接口表示一个不接受任何参数但返回一个类型为 T 的结果的函数。它有一个抽象方法 get()。
实用例子： 假设我们需要一个随机数生成器，每次调用都返回一个新的随机数。

import java.util.*;
import java.util.function.*;

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Double> randomGenerator = () -> Math.random();
        
        // 使用Supplier接口生成三个随机数
        for (int i = 0; i < 3; i++) {
            System.out.println(randomGenerator.get());
        }
    }
}

这些例子展示了如何在实际场景中使用这些函数式接口。通过Lambda表达式，我们可以轻松地实现函数式编程模式，如映射、过滤、消费和供应。