Java 8 函数式编程

Java 8 函数式编程

java.util.function.*
@FunctionalInterface
都是函数接口，没有成员(状态)

高阶函数：参数或返回值为函数

方法引用：类名::方法名
可以 类名::new、String[]::new

流操作

Stream.of("-1", "0", "1") // 生成
.map(函数) // 映射
.filter(返回布尔值函数) // 过滤器（重构：找for中if）
.flatMap(函数) // 平面映射：多个流合并
.min(Comparator.comparing(x -> x.getLength()))
.reduce(0, (a, b) -> a+b); // 缩小
a一开始是第一个参数0，b是不断传入的流元素，
这个式子的功能是求和，
可以用Integer的sum函数替代第二个式子，
写成.reduce(0, Integer::sum);
.forEach // 遍历，可以不纯
.peek(e -> System.out.println("Mapped value: " + e))
可以记录中间值用于调试，不会像forEach那样使得流不可用
.collect(Collector)
interface Collector // 输入类型，累加器，返回类型
接口方法：
Supplier supplier(); // 供应器：创建容器
BiConsumer accumulator(); // 累加器：类似reduce的第二参数（函数式）
BinaryOperator combiner(); // 组合器：合并容器
Function finisher(); // 完工者：转换为想要的结果类型
Set characteristics(); // 特征：返回不可变集合
.collect(Collectors.toList()); // 采集：生成列表
.collect(Collectors.toCollection(TreeSet::new))
.collect(Collectors.joining(", ", "[", "]"));
.collect(Collectors.summingInt(Integer::valueOf))
.collect(Collectors.partitioningBy(x->x.length()>1)); // Map>
.collect(Collectors.groupingBy(String::length)) // Map>
.collect(Collectors.groupingBy(String::length,Collectors.counting()))
下游收集器 = Collectors.mapping(String::length, Collectors.toList());
.collect(Collectors.groupingBy(String::length,下游收集器));
.collect(Collectors.maxBy(Comparator 比较规则))

.parallel() // BaseStream 并行流
集合.parallelStream()
影响性能因素：1.数据大小、2.结构、3.装箱、4.核心数、5单元处理开销
分解性能：
好：ArrayList、数组、IntStream.range
中：HashSet、TreeSet
差：LinkedList、Streams.iterate、BefferedReader.lines
无状态：filter、flatMap（速度快）
有状态：sorted、distinct、limit

.mapToInt() // 映射并转换为基本类型，其他类似
基本类型速度快、占用小

IntStream.of(1, 2, 3).summaryStatistics()
.getCount()
.getSum()
.getMin()
.getAverage()
.getMax()

// 供应者：只有get方法的函数
public interface Supplier { T get(); }

// 判定：返回布尔值的函数
Predicate { boolean test(T t); and; 否定 negate; or; isEqual }

// 函数
Function {R apply(T t); 组合compose; andThen; 同一 identity}

重载时 javac 会选最具体的

Optional.of("a")
.isPresent()
.get()
.orElse("b")
.orElseGet(只有get方法的函数)

TDD 测试驱动开发
BDD 行为驱动开发，TDD 的一个变种
DSL 领域专用语言

public class 类名 {{ }} // 匿名构造函数
public class 类名 { public 类名() {} }

并行运行基于集合流的质数计数程序
public long countPrimes(int upTo) {
    return IntStream.range(1, upTo)
            .parallel()
            .filter(this::isPrime)
            .count();
}
private boolean isPrime(int number) {
    return IntStream.range(2, number)
            .allMatch(x -> (number % x) != 0);
}

使用 Map 的 computeIfAbsent 方法高效计算斐波那契数列。
这里的“高效”是指避免将那些较小的序列重复计算多次。
public class Fibonacci {

    private final Map cache;

    public Fibonacci() {
        cache = new HashMap<>();
        cache.put(0, 0L);
        cache.put(1, 1L);
    }

    public long fibonacci(int x) {
        return cache.computeIfAbsent(x, n -> fibonacci(n-1) + fibonacci(n-2));
    }

}

Map.merge(key,value,BiFunction)

BufferedReader::lines