Java 函数式编程

(parameters) -> expression

(parameters) -> { statements; }

• 可选的参数 ：不需要声明参数类型，编译器会依靠上下文进行自动推断；
• 可选的参数圆括号 ：当且仅当只有一个参数时，包裹参数的圆括号可以省略；
• 可选的花括号 ：如果主体只有一个表达式，则无需使用花括号；
• 可选的返回关键字 ：如果主体只有一个表达式，则该表达式的值就是整个 Lambda 表达式的返回值，此时不需要使用 return 关键字进行显式的返回。

/**
 * 定义函数式接口
 * @param <T> 参数类型
 */
@FunctionalInterface
public interface CustomPredicate<T> {
    boolean test(T t);
}

/**
 * 集合过滤
 * @param list 待过滤的集合
 * @param predicate 函数式接口
 * @param <T> 集合中元素的类型
 * @return 满足条件的元素的集合
 */
public static <T> List<T> filter(List<T> list, CustomPredicate<T> predicate) {
    ArrayList<T> result = new ArrayList<>();
    for (T t : list) {
        // 将满足条件的元素添加到返回集合中
        if (predicate.test(t)) result.add(t);
    }
    return result;
}

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
filter(integers, x -> x % 2 == 0);  // 过滤出所有偶数
List<Employee> employees = Arrays.asList(
    new Employee("张某", 21, true),
    new Employee("李某", 30, true),
    new Employee("王某", 45, false));
filter(employees, employee -> employee.getAge() > 25); // 过滤出所有年龄大于25的员工

new Thread(() -> {
    System.out.println("hello");
});

filter(employees, employee -> employee.isOfficial());

filter(employees, Employee::isOfficial);

Stream<Integer> stream = Stream.of(1, 3, 5, 2, 4);
stream.collect(Collectors.toCollection(ArrayList::new));  //等价于 toCollection(()->new ArrayList<>())

1. Consumer<T> ：消费型接口，消费输入的变量，没有返回值：

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

2. Consumer<T> ：供给型接口，供给变量：

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

3. Function<T, R> ：对输入类型为 T 的变量执行特定的转换操作，并返回类型为 R 的返回值：

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

4. Predicate<T> ：判断类型为 T 的变量是否满足特定的条件，如果满足则返回 true，否则返回 false：

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

• BiFunction<T, U, R> ：是函数型接口 Function<T, R> 的扩展，Function 只能接收一个入参；而 BiFunction 可以用于接收两个不同类型的入参；
• BinaryOperator<T> ：是 BiFunction 的一种特殊化情况，即两个入参和返回值的类型均相同，通常用于二元运算。定义如下：

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
  ....
}

/**
 * 执行归约操作
 */
public static <T> T reduce(List<T> list, T initValue, BinaryOperator<T> binaryOperator) {
    for (T t : list) {
        initValue = binaryOperator.apply(initValue, t);
    }
    return initValue;
}
public static void main(String[] args) {
    List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
    reduce(integers, 0, (a, b) -> a + b); // 求和  输出：15
    reduce(integers, 1, (a, b) -> a * b); // 求积  输出：120
}

Stream<String> stream = Stream.of("a", "b", "c", "d");

String[] strings={"a", "b", "c", "d"};
Stream<String> stream = Arrays.stream(strings);

List<String> strings = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = strings.stream();

public interface Collection<E> extends Iterable<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

try (Stream<String> lines = Files.lines(Paths.get("pom.xml"), StandardCharsets.UTF_8)) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

• Stream.iterate() 接受两个参数：第一个是初始值；第二个参数是一个输入值和输出值相同的函数型接口，主要用于迭代式地产生新的元素，示例如下：

  // 依次输出0到9
  Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::print);
  

• Stream.generate() 接收一个供应型函数作为参数，用于按照该函数产生新的元素：

  // 依次输出随机数
  Stream.generate(Math::random).limit(10).forEach(System.out::print);
  

注：上表中返回类型为 Stream 的操作都是中间操作，代表还可以继续调用其它方法对流进行处理。返回类型为其它的操作都是终止操作，代表处理过程到此为止。

Stream.iterate(0, x -> x + 1)       // 构建流
    .limit(20)                        // 限制元素的个数
    .skip(10)                        // 跳过前10个元素
    .filter(x -> x % 2 == 0)         // 过滤出所有偶数
    .map(x -> "偶数:" + x)            // 对元素执行转换操作
    .forEach(System.out::println);    // 打印出所有元素

偶数:10
偶数:12
偶数:14
偶数:16
偶数:18

String[] strings = {"hello", "world"};
Arrays.stream(strings)
    .map(x -> x.split(""))              // 拆分得到: ['h','e','l','l','o'],['w','o','r','l','d']
    .flatMap(x -> Arrays.stream(x))  // 将每个数组进行扁平化处理得到：'h','e','l','l','o','w','o','r','l','d'
    .forEach(System.out::println);

Stream.iterate(0, x -> x + 1).limit(10)
    .reduce(0, (a, b) -> a + b); //进行求和操作

Stream<Integer> stream = Stream.iterate(0, x -> x + 1); //包装类型Integer

Stream.iterate(0, x -> x + 1).limit(10).mapToInt(x -> x).sum();

IntStream intStream = Stream.iterate(0, x -> x + 1).limit(10).mapToInt(x -> x);
Stream<Integer> boxed = intStream.boxed();

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 4, 5, 6); 
stream.collect(Collectors.toSet());  // [1, 2, 3, 4, 5, 6]
stream.collect(Collectors.toList()); // [1, 2, 3, 4, 4, 5, 6]
stream.collect(Collectors.toCollection(ArrayList::new)); // [1, 2, 3, 4, 4, 5, 6]
stream.collect(Collectors.counting()); // 7 等效于 stream.count();
stream.collect(Collectors.summarizingInt(x -> x)); // IntSummaryStatistics{count=7, sum=25, min=1, average=3.571429, max=6}
stream.collect(Collectors.maxBy((Integer::compareTo))); // Optional[6]
stream.collect(Collectors.reducing(1, (a, b) -> a * b)); // 等效于 stream.reduce(1, (a, b) -> a * b);
collect(Collectors.collectingAndThen(Collectors.toSet(), Set::size)); // 先把所有元素收集到Set中，再计算Set的大小

注意：以上每个终止操作只能单独演示，因为对一个流只能执行一次终止操作。并且执行完终止操作后，就不能再对这个流进行任何操作，否则将抛出 java.lang.IllegalStateException: stream has already been operated upon or closed 的异常。

Stream<Employee> stream = Stream.of(new Employee("张某", "男", "A公司", 20),
    new Employee("李某", "女", "A公司", 30),
    new Employee("王某", "男", "B公司", 40),
    new Employee("田某", "女", "B公司", 50));

public class Employee {
  
    private String name;
    private String gender;
    private String company;
    private int age;
  
    @Override
    public String toString() {return "Employee{" + "name='" + name + '\'' + '}';
    }
}

stream.collect(Collectors.groupingBy(Employee::getCompany));
对应的分组结果如下：
{ 
   B公司=[Employee{name='王某'}, Employee{name='田某'}], 
   A公司=[Employee{name='张某'}, Employee{name='李某'}]
}

stream.collect(Collectors.groupingBy(Employee::getCompany, Collectors.counting()));
对应的结果如下：
{
  B公司=2, 
  A公司=2
}  

stream.collect(Collectors.groupingBy(Employee::getCompany, Collectors.groupingBy(Employee::getGender)));
先按照公司分组，再按照性别分组，结果如下：
{ 
   B公司={女=[Employee{name='田某'}], 男=[Employee{name='王某'}]}, 
   A公司={女=[Employee{name='李某'}], 男=[Employee{name='张某'}]}
}

Map<String, List<Employee>> collect = stream.collect(Collectors.groupingBy(employee -> {
    if (employee.getAge() <= 30) {
        return "青年员工";
    } else if (employee.getAge() < 50) {
        return "中年员工";
    } else {
        return "老年员工";
    }
}));
对应的分组结果如下：
{ 
  中年员工=[Employee{name='王某'}], 
  青年员工=[Employee{name='张某'}, Employee{name='李某'}], 
  老年员工=[Employee{name='田某'}]
}  

stream.collect(Collectors.partitioningBy(x -> "A公司".equals(x.getCompany())));
对应的分区结果如下：
{
  false=[Employee{name='王某'}, Employee{name='田某'}], 
  true=[Employee{name='张某'}, Employee{name='李某'}]
}  

stream.parallel();

System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism","12"); 

stream.sequential();