Effective Java 读书笔记（五）：Lambda和Stream

1 Lamdba优于匿名内部类

（1）DEMO1

• 匿名内部类：过时

Collections.sort(words, new Comparator<String>() {
	public int compare(String s1, String s2) {
   	 return Integer.compare(s1.length(), s2.length());
    }
});

• 上述使用了策略模式，Comparator接口为排序的抽象策略，匿名内部类为具体实现策略，但是匿名内部类的实现过于冗长。

• 在java8中，如果一个接口只有一个方法，那么这个接口可以看作一个函数接口，功能接口的实现类可以通过lambda来实现，lambda与匿名内部类类似，但是更加简洁。

• lamdba：常规

Collections.sort(words,(s1, s2) -> Integer.compare(s1.length(), s2.length()));

• 参数为String类型，返回值为int类型，编译器是如何知道的呢？

• 编译器使用称为类型推断的过程从上下文中推导出这些类型，但是编译器不是万能的，有时候仍然需要显式设定。

• lamdba：方法引用

Collections.sort(words, comparingInt(String::length));
words.sort(comparingInt(String::length));

（2）DEMO2

• 常量类：enum with function object

public enum Operation {
    PLUS("+") {
        public double apply(double x, double y) { return x + y; }
    },
    MINUS("-") {
        public double apply(double x, double y) { return x - y; }
    },
    TIMES("*") {
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE("/") {
        public double apply(double x, double y) { return x / y; }
    };
    private final String symbol;
    Operation(String symbol) { this.symbol = symbol; }
    @Override public String toString() { return symbol; }
    public abstract double apply(double x, double y);
}

• lambda：enum with function object

public enum Operation {
    PLUS ("+", (x, y) -> x + y),
    MINUS ("-", (x, y) -> x - y),
    TIMES ("*", (x, y) -> x * y),
    DIVIDE("/", (x, y) -> x / y);
    private final String symbol;
    private final DoubleBinaryOperator op;
    Operation(String symbol, DoubleBinaryOperator op) {
   	 this.symbol = symbol;
   	 this.op = op;
    }
    @Override public String toString() { return symbol; }
    public double apply(double x, double y) {
   	 return op.applyAsDouble(x, y);
	}
}

• lambda中的不要超过三行。
• lambda中无法访问枚举的实例成员。
• lambda无法创建抽象类的实例，但匿名内部类可以。
• lambda无法获取到对自身的引用。
• 如果需要反序列化一个函数接口，如：Comparator，我们需要使用私有静态内部类。

2 lambda中优先使用方法引用

（1）DEMO

// lambda代码块
map.merge(key, 1, (count, incr) -> count + incr);
// 方法引用
map.merge(key, 1, Integer::sum);

（2）类型

方法引用类型	例子	Lambda等效方案
Static	Integer::parseInt	str -> Integer.parseInt(str)
Bound	Instant.now()::isAfter	Instant then = Instant.now(); t -> then.isAfter(t)
Unbound	String::toLowerCase	str -> str.toLowerCase()
Class Constructor	TreeMap::new	() -> new TreeMap
Array Constructor	int[]::new	len -> new int[len]

• 如果方法引用更加简洁和清晰，请使用方法引用，反之使用Lambda表达式。

3 优先使用标准功能接口

（1）模板方法模式

• 由于Lambda的存在，通过子类重写基本方法以专门化超类的行为的方式有点过时。
• 替代方案：提供一个静态工厂或者构造器，它们接收一个函数对象来实现相同的效果。
• 一般来说，我们将编写更多以函数对象作为参数的构造函数和方法。

// 模板方法
abstract class A {
    public void print() {
        System.out.println("A");
        doSubThing();
    }
    abstract void doSubThing();
}
class B extends A {
    @Override
    void doSubThing() {
        System.out.println("B");
    }
}
// lambda
class A {
    private Supplier<String> supplier;
    public A(Supplier<String> supplier) {
        this.supplier = supplier;
    }
    public void print() {
        System.out.println("A");
        System.out.println(supplier.get());
    }
}
public static void main(String[] args) {
    A a = new A(() -> "B");
    a.print();
}

（2）标准函数接口

接口	函数签名	例子
UnaryOperator<T>	T apply(T t)	String::toLowerCase
BinaryOperator<T>	T apply(T t1, T t2)	BigInteger::add
Predicate<T>	boolean test(T t)	Collection::isEmpty
Function<T>	R apply(T t)	Arrays::asList
Supplier<T>	T get()	Instant::now
Consumer<T>	void accept(T t)	System.out::println

• 优先使用标准函数接口，这能够缩小概念表面积，从而降低学习成本。
• 但是如果所有标准函数接口都不能很好表示时，请
• 上述的六种接口拥有许多变种，如：int、long和double，甚至是int->long等等。
• 其实大多数变种都使用了基础类型，而不是包装类型，基础类型的运算更快，节省内存空间，不要使用包装类去替换它们。
• 其实我们并不会去记忆所有变种，变种随着JDK升级可能会增加或减少，只需要在使用时去翻翻java.util.function包是否有需要的接口即可。

具体请参考：JAVA8的java.util.function包

（3）Comparator接口

• Comparator接口与ToIntBiFunction接口的结构相同，但是仍然不要用ToIntBiFunction去替代Comparator
• 因为Comparator的名称含义十分清晰，它在jdk中已经广泛使用了，而且Comparator提供了许多有用默认方法。

（4）@FunctionalInterface

• @FunctionalInterface注解能够帮助开发者检查这个接口是否只有一个抽象方法，如果不只一个将无法编译。
• @FunctionalInterface目的：将某个接口标志为函数接口且提供编译时检查。

4 明智地使用Stream

4.1 概念

• 流：无限或有限的数据元素序列。

• 管道：对流中的元素进行多级计算。

• 流的源：集合、数组、文件、正则表达式或模式匹配器、伪随机数生成器或其他流。

• 管道操作：由源流后跟着零个或多个中间操作和一个终止操作。

• 中间操作：某种转换流的方式，如：元素映射或元素过滤等。

• 终止操作：执行最终计算，如：流装入容器中或是消费掉。

4.2 补充

• 流管道只包含中间操作时是惰性的：当一个流没有最终操作时，流管道是什么都不做的。
• 流管道的API被设计成链式编码风格。

4.3 流的使用时机

（1）不要滥用流

// 普通方式
// 读取文件中的单词，检查单词的字母，相同字母的单词收集在一起
public class Anagrams {
    public static void main(String[] args) throws IOException {
        File dictionary = new File(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);
        Map<String, Set<String>> groups = new HashMap<>();
        try (Scanner s = new Scanner(dictionary)) {
            while (s.hasNext()) {
                String word = s.next();
                groups.computeIfAbsent(alphabetize(word), (unused) -> new TreeSet<>()).add(word);
            }
        }
        for (Set<String> group : groups.values())
       	  if (group.size() >= minGroupSize)
        	 System.out.println(group.size() + ": " + group);
    }
    private static String alphabetize(String s) {
    	char[] a = s.toCharArray();
    	Arrays.sort(a);
    	return new String(a);
    }
}
// 过度使用流：虽然很简洁，但是对流不了解的开发人员可能无法理解。
// 打个比方，有些动漫是只有死宅才看的：永生之酒。
public static void main(String[] args) throws IOException {
    Path dictionary = Paths.get(args[0]);
    int minGroupSize = Integer.parseInt(args[1]);
    try (Stream<String> words = Files.lines(dictionary)) {
        words.collect(
            groupingBy(word -> word.chars().sorted()
                       .collect(StringBuilder::new,
                                (sb, c) -> sb.append((char) c),
                                StringBuilder::append).toString())
        )
        .values().stream()
        .filter(group -> group.size() >= minGroupSize)
        .map(group -> group.size() + ": " + group)
        .forEach(System.out::println);
    }
}
// 合适使用流方式
// 有的动漫是大家都看的：龙珠。对动漫不需要太了解也能够接收。
public static void main(String[] args) throws IOException {
    Path dictionary = Paths.get(args[0]);
    int minGroupSize = Integer.parseInt(args[1]);
    try (Stream<String> words = Files.lines(dictionary)) {
        words.collect(groupingBy(word -> alphabetize(word)))
            .values().stream()
            .filter(group -> group.size() >= minGroupSize)
            .forEach(group -> System.out.println(group.size() + ": " + group));
    }
}

• 字母排序方法抽取出来增加程序的可读性。
• lambda中参数的命名尤为重要，好的命名能够提升可读性。
• 也许大家都希望使用lambda来消灭循环，但实际是不可取的(元素少时lambda存在性能问题)。

（2）代码块与lambda

• Stream的缺点
  • 代码块能够读取或修改范围内的局部变量，lambda只能操作final变量和当前范围的局部变量。
  • 代码块中能够return、抛出异常、跳出循环或是跳过循环，lambda中都无法做到。
• Stream的优势
  • map：统一转换元素类型
  • filter：过滤序列
  • min、compute：计算最小值、合并序列等
  • reduce：累计序列
  • grouping：分组

（3）流无法做到同时在多级阶段访问相应的元素

• 通过操作反转来获取上一个流元素

public static void main(String[] args) {
    primes().map(p -> TWO.pow(p.intValueExact()).subtract(ONE))
        // (1-1/50)=98%代表isProbablePrime只有当98%几率为素数才返回true。
        .filter(mersenne -> mersenne.isProbablePrime(50))
        .limit(20)
        // mp.bitLength等于p值，反向运算来获取上一个流的值。
        .forEach(mp -> System.out.println(mp.bitLength() + ": " + mp));
}
static Stream<BigInteger> primes() {
    return Stream.iterate(TWO, BigInteger::nextProbablePrime);
}

（4）笛卡尔积

private static List<Card> newDeck() {
    List<Card> result = new ArrayList<>();
    for (Suit suit : Suit.values())
        for (Rank rank : Rank.values())
            result.add(new Card(suit, rank));
    return result;
}
// flatMap 用于展平一个序列，如：List<String> -> String.
private static List<Card> newDeck() {
    return Stream.of(Suit.values())
        .flatMap(suit ->
                 Stream.of(Rank.values())
                 .map(rank -> new Card(suit, rank)))
        .collect(toList());
}

5 优先选择流中无副作用的功能

（1）概述

• 为了得到stream的表现力、速度和并行度，我们必须遵守范式和使用API。
• stream范式最重要的部分：计算 -> 转换 ，每个转换（中间或终止操作）都是纯函数。
• 纯函数应该都是无副作用的（不依赖任何可变状态，不更新任何状态）。

（2）Collectors的基本方法

名称	作用
toCollection toList toSet	流转换为集合
toMap	流转换为Map
partitioningBy groupingBy groupingByConcurrent	分组
minBy maxBy	最值
counting	计数
summingInt averagingInt	和 平均值
joining mapping	合并 映射

（3）示例

// 不遵守范式，forEach应该只用于呈现流执行的计算结果
Map<String, Long> freq = new HashMap<>();
try (Stream<String> words = new Scanner(file).tokens()) {
    words.forEach(word -> freq.merge(word.toLowerCase(), 1L, Long::sum));
}
// 正确地使用流来初始化频率表
Map<String, Long> freq;
try (Stream<String> words = new Scanner(file).tokens()) {
	freq = words.collect(groupingBy(String::toLowerCase, counting()));
}
// 按照频次获取前十个元素
List<String> topTen = freq.keySet().stream()
                                   .sorted(comparing(freq::get).reversed())
                                   .limit(10)
                                   .collect(toList());
// groupingByConcurrent返回并发Map
ConcurrentHashMap<String, Long> freq;
try (Stream<String> words = new Scanner(file).tokens()) {
	freq = words.collect(groupingByConcurrent(String::toLowerCase, counting()));
}

（4）分组

• Collector<T, ?, Map<Boolean, List>> partitioningBy(Predicate<? super T> predicate)：true和false分成两组。
• Collector<T, ?, Map<K, List>> groupingBy(Function<? super T, ? extends K> classifier)：按照key值分组。

List<String> words = new ArrayList<>();
words.add("1");
words.add("1");
words.add("2");
words.add("3");
Map<Boolean, List<String>> map = words.stream().collect(
    partitioningBy(s -> s.equals("1"))
);
System.out.println(map); // {false=[2, 3], true=[1, 1]}
Map<String, List<String>> map = words.stream().collect(
    groupingBy(String::toLowerCase)
);
System.out.println(map); // {1=[1, 1], 2=[2], 3=[3]}

（5）List转Map

// List转Map的正确实现
Map<Integer, Data> collect = words.stream().collect(toMap(Data::getId, e -> e));
// key值重复时，获取销量最大的Album
Map<Artist, Album> topHits = albums.collect(
    toMap(Album::artist, a->a,maxBy(comparing(Album::sales)))
);
// 后访问的覆盖先访问的
Map<Artist, Album> topHits = albums.collect(
    toMap(Album::artist, a->a,(v1, v2) -> v2)
);
// 指定返回Map的类型
HashMap<Artist, Album> topHits = albums.collect(
    toMap(Album::artist, a->a,(v1, v2) -> v2,HashMap::new)
);

（6）List->字符串

// joining
List<String> words = new ArrayList<>();
words.add("2");
words.add("1");
words.add("1");
words.add("3");
String join1 = words.stream().collect(joining());
String join2 = words.stream().collect(joining(","));
String join3 = words.stream().collect(joining(",","[","]"));
System.out.println(join1); // 2113
System.out.println(join2); // 2,1,1,3
System.out.println(join3); //[2,1,1,3]
// mapping和map类似
 List<String> words = new ArrayList<>();
words.add("2");
words.add("1");
words.add("1");
words.add("3");
List<Integer> list1 = words.stream().collect(mapping(e -> Integer.valueOf(e), toList()));
List<Integer> list2 = words.stream().map(e -> Integer.valueOf(e)).collect(toList());
System.out.println(list1); // [2, 1, 1, 3]
System.out.println(list2); // [2, 1, 1, 3]

（7）计算

List<String> words = new ArrayList<>();
words.add("2");
words.add("1");
words.add("3");
// 求和
Integer sum1 = words.stream().collect(summingInt(value ->  Integer.valueOf(value)));
Integer sum2 = words.stream().mapToInt(value -> Integer.valueOf(value)).sum();
// 平均值
Double avg = words.stream().collect(averagingInt(value -> Integer.valueOf(value)));
// 最大值
String max1 = words.stream().max(comparing(Integer::valueOf)).get();
String max2 = words.stream().collect(maxBy(comparing(Integer::valueOf))).get();
// 总结值
IntSummaryStatistics summary = words.stream().collect(summarizingInt(Integer::valueOf));
System.out.println(summary.getAverage());
System.out.println(summary.getSum());
System.out.println(summary.getCount());
System.out.println(summary.getMax());
System.out.println(summary.getMin());

6 优先选择集合作为返回值

（1）stream的iterator

// need to cast
for (ProcessHandle ph : (Iterable<ProcessHandle>)ProcessHandle.allProcesses()::iterator){
	...
}
// Adapter from Stream<E> to Iterable<E>
public static <E> Iterable<E> iterableOf(Stream<E> stream) {
	return stream::iterator;
}
for (ProcessHandle p : iterableOf(ProcessHandle.allProcesses())) {
	// Process the process
}

（2）spliterator

// spliterator用于并行迭代
public static <E> Stream<E> streamOf(Iterable<E> iterable) {
	return StreamSupport.stream(iterable.spliterator(), false);
}
// 例子:并行计算1+2+...+10000
public static void main(String[] args) throws InterruptedException {
    List<String> words = new ArrayList<>();
    for (int i = 1; i <= 10000; i++) {
        words.add(i + "");
    }
    final AtomicInteger atomicInteger = new AtomicInteger(0);
    int count = 10;
    CountDownLatch latch = new CountDownLatch(count);
    final List<Spliterator<String>> splitList = split(words, count);
    for (int i = 0; i < count; i++) {
        int finalI = i;
        new Thread(() -> {
            try {
                splitList.get(finalI)
                    .forEachRemaining(s -> atomicInteger.getAndAdd(Integer.valueOf(s)));
            } finally {
                latch.countDown();
            }
        }, "Thread:" + i).start();
    }
    latch.await();
    System.out.println(atomicInteger.get());
}
public static <T> List<Spliterator<T>> split(List<T> list, int size) {
    List<Spliterator<T>> returnList = new ArrayList<>();
    returnList.add(list.spliterator());
    if (size > 1) spliterator(returnList, 2, size);
    return returnList;
}
private static <T> void spliterator(List<Spliterator<T>> returnList, int i, int size) {
    int j = i / 2 - 1;
    returnList.add(returnList.get(j).trySplit());
    if (size == i) return;
    spliterator(returnList, i + 1, size);
}

（3）原则

• Collection是Iterable的子类型，具有stream方法，因此提供迭代和流访问，因此Collection或适当的子类型通常是返回方法的最佳返回类型。
• 如果返回的序列小到足够放到内存中，则最好返回一个标准集合实现。

（4）DEMO

• 幂集

// {a，b，c}的幂集为{{}，{a}，{b}，{c}，{a，b}，{a，c}，{b，c}，{a，b ，c}}
public class PowerSet {
    public static final <E> Collection<Set<E>> of(Set<E> s) {
        List<E> src = new ArrayList<>(s);
        if (src.size() > 30)
        	throw new IllegalArgumentException("Set too big " + s);
        return new AbstractList<Set<E>>() {
            @Override public int size() {
                // 如果size > 31将导致溢出int的范围
           	 	return 1 << src.size(); // 2^size
            }
            @Override public boolean contains(Object o) {
            	return o instanceof Set && src.containsAll((Set)o);
            }
            @Override public Set<E> get(int index) {
                Set<E> result = new HashSet<>();
                for (int i = 0; index != 0; i++, index >>= 1)
                    if ((index & 1) == 1) result.add(src.get(i));
                return result;
            }
        };
    }
}

• 前缀子集、后缀子集

public class SubLists {
    public static <E> Stream<List<E>> of(List<E> list) {
        return Stream.concat(Stream.of(Collections.emptyList()),
        	prefixes(list).flatMap(SubLists::suffixes));
    }
    // (a,b,c) => ((a),(a,b),(a,b,c))
    private static <E> Stream<List<E>> prefixes(List<E> list) {
        return IntStream.rangeClosed(1, list.size())
        	.mapToObj(end -> list.subList(0, end));
    }
    // (a,b,c) => ((a,b,c),(b,c),(c))
    private static <E> Stream<List<E>> suffixes(List<E> list) {
        return IntStream.range(0, list.size())
      	  .mapToObj(start -> list.subList(start, list.size()));
    }
}

• 所有子列表

// [1,3,2] => [[1], [1, 3], [1, 3, 2], [3], [3, 2], [2]]
public static <E> Stream<List<E>> of(List<E> list) {
    return IntStream.range(0, list.size())
        .mapToObj(start -> IntStream.rangeClosed(start + 1, list.size())
                  .mapToObj(end -> list.subList(start, end)))// subList使用闭区间
        .flatMap(x -> x);
}

7 谨慎使用并行流

（1）原则

• ArrayList、HashMap、HsahSet、CouncurrentHashMap、数组、int范围流和long范围流的并行性性能效益最佳。

• 它们的范围可以确定，而执行任务的抽象为spliterator。

• 数组存储的元素在内存中相近，数据定位更快。而上面涉及的数据结构基本都基于数组实现。

• 流的终止操作会影响并行执行的有效性。而流的reduce操作或预先打包(min、max、count和sum)是并行流的最佳实践。

• 流的中间操作(anyMatch、allMatch和noneMatch)也适合并行操作。

• 流的collect操作则不适合。

• 自己实现Stream、Iterable或Collection且希望有良好的并行性能，则需要覆盖spliterator方法。

• 并行流是基于fork-join池实现的。

• 当无法写出正确的并行流，将导致异常或者错误的数据。

注：程序的安全性、正确性比性能更重要。

（2）DEMO

// 串行，10^8需要30秒
static long pi(long n) {
    return LongStream.rangeClosed(2, n)
        .mapToObj(BigInteger::valueOf)
        .filter(i -> i.isProbablePrime(50))
        .count();
}
// 并行，10^8需要9秒
static long pi(long n) {
    return LongStream.rangeClosed(2, n)
    .parallel()
    .mapToObj(BigInteger::valueOf)
    .filter(i -> i.isProbablePrime(50))
    .count();
}