函数式接口

Consumer 接口

Consumer 是 Java 8 中的一个函数式接口，用于表示接受一个参数并且不返回结果的操作。它定义了一个名为 accept 的抽象方法，用于执行该操作

当我们说到"Consumer"时，可以将其类比为一种操作或者功能，它接收一个参数，但没有返回值。就像一个消费者一样，它接收商品但不生产任何东西。在编程中，"Consumer"可以用来描述执行一些处理、操作或者转换的过程，而不需要返回结果

接口定义

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

理解代码

/**
 * consumer接口测试
 * 是一个消费的接口，根据传入的值，进行输出
 */
@Test
public void test_Consumer() {
    //① 使用consumer接口实现方法
    Consumer<String> consumer = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    // foreach遍历stream，调用Consumer的对象consumer进行输出
    // stream 流只能使用一次
    Stream<String> stream = Stream.of("a", "b");
    stream.forEach(consumer);

    System.out.println("********************");

    
    // ② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
    // lambda 表达式，一个参数的时候，类型可以省略简写
    stream = Stream.of("aa", "bb");
    Consumer<String> consumer1 = (String s) -> System.out.println(s);
    //lambda表达式返回的就是一个Consumer接口
    stream.forEach(consumer1);
    //更直接的方式
    //stream.forEach((s) -> System.out.println(s));
    
    System.out.println("********************");

    
    //③ 使用方法引用，方法引用也是一个consumer
    stream = Stream.of("aaa", "bbb");
    Consumer consumer2 = System.out::println;
    stream.forEach(consumer);
    //更直接的方式
    //stream.forEach(System.out::println);
}

使用示例

IntConsumer intConsumer = (num) -> System.out.println("received："+num);
intConsumer.accept(20);

// 创建一个 Consumer 实例，打印接受到的字符串
Consumer<String> printString = str -> System.out.println("Received: " + str);
printString.accept("hello");

// 另一个示例，将接受到的字符串转换为大写并打印
Consumer<String> toUpperCase = str -> System.out.println("Uppercase: " + str.toUpperCase());
toUpperCase.accept("hello");

• Consumer是一个接口，并且只要实现一个 accept 方法，就可以作为一个**“消费者”**输出信息
• 其实，lambda 表达式、方法引用的返回值都是 Consumer 类型，所以，他们能够作为 forEach 方法的参数，并且输出一个值

Supplier 接口

Supplier 接口是一个供给型的接口，其实，说白了就是一个容器，可以用来存储数据，然后可以供其他方法使用的这么一个接口，Supplier 接口定义了一个名为 get 的抽象方法，用于获取结果

它不接受任何参数，但返回一个结果。换句话说，它描述了一个能够提供（或供应）某种结果的过程，类似于一个工厂或者提供者

接口定义

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

理解代码

@Test
public void test_Supplier() {
    //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
    Supplier<Integer> supplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
            //返回一个随机值
            return new Random().nextInt();
        }
    };

    System.out.println(supplier.get());

    System.out.println("********************");

    //② 使用lambda表达式，
    supplier = () -> new Random().nextInt();
    System.out.println(supplier.get());
    
    System.out.println("********************");

    //③ 使用方法引用
    Supplier<Double> supplier2 = Math::random;
    System.out.println(supplier2.get());
}

使用示例

// 创建一个 Supplier 实例，用于获取当前时间
Supplier<Long> currentTimeSupplier = () -> System.currentTimeMillis();

// 使用 get 方法获取结果
long currentTime = currentTimeSupplier.get();
System.out.println("Current Time: " + currentTime);

// 另一个示例，创建一个 Supplier 实例，用于生成随机数
Supplier<Integer> randomNumberSupplier = () -> (int) (Math.random() * 100);

// 使用 get 方法获取结果
int randomNumber = randomNumberSupplier.get();
System.out.println("Random Number: " + randomNumber);

• Supplier 接口可以理解为一个容器，用于装数据的
• Supplier 接口有一个 get 方法，可以返回值

Function 接口

Function 是 Java 8 中的一个函数式接口，用于表示一种函数，它接收一个参数，并返回一个结果。它可以用于描述任意一种从一个类型到另一个类型的映射或转换操作

调用函数当作参数使用时，->前是传入类型，后面是返回类型

接口定义

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

理解代码

/**
 * Function测试，function的作用是转换，将一个值转为另外一个值
 */
@Test
public void test_Function() {
    //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
    Function<String, Integer> function = new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return s.length();//获取每个字符串的长度，并且返回
        }
    };

    Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
    Stream<Integer> stream1 = stream.map(function);
    stream1.forEach(System.out::println);

    System.out.println("********************");

}

测试代码

IntFunction<String>的传入参数是Integer，输出参数是String

@Test
public void test(){
    IntFunction<String> fun = (num)->{
        return "Hello"+num;
    };
    String apply = fun.apply(2);
    System.out.println(apply);
}

• Function 接口是一个功能型接口，是一个转换数据的作用
• Function 接口实现 apply 方法来做转换

Predicate 接口

Predicate 接口定义了一个名为 test 的抽象方法，该方法接受一个参数并返回一个 boolean 值，用于判断该参数是否满足某个条件

Predicate 接口是一个谓词型接口，其实，这个就是一个类似于 bool 类型的判断的接口

接口定义

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

理解代码

/**
 * Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用
 */
@Test
public void test_Predicate() {
    //① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
    Predicate<Integer> predicate = new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) {
            if(integer > 5){
                return true;
            }
            return false;
        }
    };

    System.out.println(predicate.test(6));

    System.out.println("********************");

    //② 使用lambda表达式，
    predicate = (t) -> t > 5;
    System.out.println(predicate.test(1));
    System.out.println("********************");

}

测试代码

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 定义一个 Predicate 条件：判断是否大于 5
        Predicate<Integer> greaterThan5 = num -> num > 5;

        // 使用 Predicate 进行过滤
        List<Integer> result = filter(numbers, greaterThan5);

        System.out.println("大于 5 的元素有：" + result);
    }

    // 定义一个通用的过滤方法
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
}

• Predicate 是一个谓词型接口，其实只是起到一个判断作用
• Predicate 通过实现一个 test 方法做判断