Java 8 - 函数式接口的方法

水深无声 2023-10-10 21:11 13阅读 0赞

在Java 8中，函数式接口是指只包含一个抽象方法的接口。Java 8引入了lambda表达式和函数式编程的特性，函数式接口为这种编程风格提供了基础。

以下是一些Java 8中常见的函数式接口及其方法签名、用途和应用场景的示例：

Supplier:

方法签名：T get()
    用途：提供一个无参的方法，返回一个结果。
    应用场景：延迟计算，例如在需要时生成一个随机数。

Consumer:

方法签名：void accept(T t)
    用途：接受一个参数并执行某些操作，没有返回值。
    应用场景：迭代集合并对每个元素执行某些操作，如打印集合中的每个元素。

Function<T, R>:

方法签名：R apply(T t)
    用途：接受一个参数并返回一个结果。
    应用场景：数据转换，如将字符串转换为整数。

Predicate:

方法签名：boolean test(T t)
    用途：接受一个参数并返回一个布尔值结果。
    应用场景：条件判断，如筛选集合中符合某个条件的元素。

UnaryOperator:

方法签名：T apply(T t)
    用途：接受一个参数并返回与参数类型相同的结果。
    应用场景：函数式计算，如对集合中的每个元素进行相同的操作。

BinaryOperator:

方法签名：T apply(T t1, T t2)
    用途：接受两个相同类型的参数，并返回一个与参数类型相同的结果。
    应用场景：在函数式计算中，对两个值进行运算并返回结果。

演示如何使用这些函数式接口：

import java.util.Arrays;
    import java.util.List;
    import java.util.Random;
    import java.util.function.*;
    import java.util.stream.Collectors;
    
    public class FunctionalInterfacesExample {
        
        public static void main(String[] args) {
        
            // Supplier<T>
            Supplier<Integer> randomSupplier = () -> new Random().nextInt(100);
            System.out.println("Random number: " + randomSupplier.get());
    
            // Consumer<T>
            List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
            Consumer<String> namePrinter = name -> System.out.println("Hello, " + name);
            names.forEach(namePrinter);
    
            // Function<T, R>
            Function<String, Integer> lengthMapper = s -> s.length();
            System.out.println("Length of 'Hello': " + lengthMapper.apply("Hello"));
    
            // Predicate<T>
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
            Predicate<Integer> evenPredicate = n -> n % 2 == 0;
            List<Integer> evenNumbers = filter(numbers, evenPredicate);
            System.out.println("Even numbers: " + evenNumbers);
    
            // UnaryOperator<T>
            UnaryOperator<Integer> squareOperator = n -> n * n;
            System.out.println("Square of 5: " + squareOperator.apply(5));
    
            // BinaryOperator<T>
            BinaryOperator<Integer> sumOperator = (a, b) -> a + b;
            System.out.println("Sum of 3 and 4: " + sumOperator.apply(3, 4));
        }
    
        private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        
            // 筛选符合条件的元素
            return list.stream()
                    .filter(predicate)
                    .collect(Collectors.toList());
        }
    }