1. 流
2. 流操作的整体步骤
3. 中间操作 - 筛选和切片
4. 中间操作 - 映射
5. 查找
6. 终端操作 - 归约
7. 基本类型特化的流
8. 其他应用

流

1. 元素序列, 就是一个流对象提供的接口, 可以访问到一组元素.
2. 源, 流会使用一个提供数据的源, 由其他集合生成的流, 排序情况(或者无序)与原集合一致
3. 数据处理操作, 这个类似于SQL语句, 对每一个流中的元素进行一些操作, 比如filter, map, reduce, find, match, sort等, 都是函数式编程中的常见操作.
4. 流水线, 很多流操作不会变更原来的流, 而是返回一个新的流, 这和操作集合对象有些不同. 这些操作可以串起来成为一个流水线
5. 内部迭代, 很多流的数据处理操作暗含了迭代, 无需编写显式的迭代代码.

public static void main(String[] args) {

    //一个Dish的List
    List<Dish> dishes = Dish.getMenu();

    //转换成一个Dish的流对象源
    Stream<Dish> dishes1 = dishes.stream();

    List<String> newDishes = dishes.stream()
            //数据处理操作filter, 这个操作生成了一个新的流
            .filter(dish -> dish.getCalories() > 300)
            //map方法表示接受一个lambda, 将元素转换成其他形式, map的意思表示对每个元素应用其中的lambda表达式, 收集应用后的结果
            //map操作也生成了一个新的流
            .map(dish -> dish.getName())
            //获取前三个, 生成一个新的流
            .limit(3)
            //收集成一个列表, 这个是终结流的操作, 每个流必须有一个终结操作, 否则之前确定的动作不会执行
            .collect(Collectors.toList());

    System.out.println(newDishes);
}

public class Consume {

    public static void main(String[] args) {
        List<String> title = Arrays.asList("Java8", "in", "action");

        Stream<String> s = title.stream();
        //这一行工作正常
        s.forEach(System.out::println);
        //想再次输出, 就会抛出流已经消费的异常
        s.forEach(System.out::println);
    }
}

流操作的整体步骤

1. 中间操作: 返回一个流的操作. 可以互相连接, 在连接的过程中不会发生实际操作.
2. 终端操作: 会从流生成一个结果, 并且消费掉这个流. 在执行了终端操作之后, 所有的中间操作才会启动.

1. 获取流, 常见的集合都提供了.stream()方法, 此外Stream库中也有生成流的方法
2. 中间操作, 常见的有filter, map, limit, sorted, distinct
3. 终端操作, 常见的有forEach, count, collect, 其中collect是将流规约, 其中又有很多操作

筛选和切片

Stream<T> filter(Predicate<? super T> predicate);

public static void main(String[] args) {
    List<Dish> dishes = Dish.getMenu();

    List<Dish> dishes1 = dishes.stream().filter(dish -> dish.getCalories() > 200).limit(2).collect(Collectors.toList());
    System.out.println(dishes1);

    List<Dish> dishes2 = dishes.stream().filter(dish -> dish.getCalories() > 400).skip(2).collect(Collectors.toList());
    System.out.println(dishes2);
}

映射

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<String> dishNames = dishes.stream()
        //第二种方法引用, 即任意实例的方法
        .map(Dish::getName)
        //组成一个List,此时List的类型是什么呢, 是Dish::getName返回的类型,也就是String
        .collect(Collectors.toList());

public static void main(String[] args) {

    List<String> ss = Arrays.asList("Hello", "world!");

    ss.stream().map(s -> s.split("")).forEach(System.out::println);
    ss.stream().map(s -> s.split("")).forEach(strings -> System.out.println(Arrays.toString(strings)));

}

[H, e, l, l, o]
[w, o, r, l, d, !]
[Ljava.lang.String;@783e6358
[Ljava.lang.String;@17550481

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

List<String> uniqueCharacters =
        ss.stream()
                //生成了一个流元素是字符串数组的流
                .map(w -> w.split(""))
                //传入的函数对象是将数组变成流
                //flatMap使用这个函数将每个数组变成流, 再将流中的每个元素合并到当前的流中
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());

import java.util.Arrays;

public class Ex52 {

    public static void main(String[] args) {
        int[] a1 = {1, 2, 3};
        int[] a2 = {3, 4};

        //想法, 用一个流和另外一个流生成对象, 再扁平化展开就可以了, 试验一下吧
        //这是将a1和一个数字10转换成一个Tuple流的代码, 现在要解决的就是把10改成来自于另外一个流
        Arrays.stream(a1).mapToObj(operand -> new Tuple<Integer>(operand, 10)).forEach(System.out::println);

        //对于a1中的每一个int, 返回一个Arrays.stream(a2).mapToObj(last -> new Tuple<Integer>(first, last))
        //Arrays.stream(a2).mapToObj(last -> new Tuple<Integer>(first, last)) 是针对a2中的每个 int 将其换成一个Tuple的流.

        //这样执行完之后, 实际上就得到了一个所有的元素都是流的流对象
        Arrays.stream(a1).mapToObj(first ->
                Arrays.stream(a2).mapToObj(last -> new Tuple<Integer>(first, last))
        ).forEach(s -> System.out.println(s.getClass()));

        //然后就需要展开了, 由于其中每一个流已经是流了, flatMap这里无需做任何处理, 就是 s -> s
        Arrays.stream(a1).mapToObj(first ->
                Arrays.stream(a2).mapToObj(last -> new Tuple<Integer>(first, last))
        ).flatMap(s -> s).forEach(System.out::println);

    }
}

查找

1. isPresent(), 是否包含值, 包含返回true
2. ifPresent(Consumer T consumer), 在值存在的时候对其执行consumer函数. 这个Consumer接口已经学过了, 接受T类型返回void.
3. T get(), 存在值的时候返回值, 否则抛出NoSuchElement异常.
4. T orElse(T other), 如果不存在的时候, 返回传入的other作为默认值, 如果存在, 等于 T get().

1. boolean anyMatch(Predicate<? super T> predicate); 根据条件只要有一个匹配, 就返回true
2. boolean allMatch(Predicate<? super T> predicate); 如果全部匹配, 才返回true
3. boolean noneMatch(Predicate<? super T> predicate); 如果全部不匹配, 才返回true

1. findFirst(), 找有顺序的第一个元素, 如果流无序, 则不确定是哪一个
2. findAny(), 找有顺序的第一个元素, 如果流无序, 则不确定是哪一个

终端操作 - 归约

//这里是静态方法引用
Optional<Integer> min = numbers.stream().reduce(Integer::min);

特化基础类型流

其他应用

1. 两个可以用于IntStream和LongStream的静态方法，帮助生成范文中的数：range和rangeClosed. 两者的区别是第一个方法是左闭右开, 第二个是两端都闭口.
2. 从值创建流, Stream.of("Java 8 ", "Lambdas ", "In ", "Action");, Stream 的 of 静态方法可以支持基础类型和很多内置的类型
3. 从数组创建流, Arrays.stream(numbers), 从数组创建流, 一样也支持很多内置类型
4. 从文件创建流, java.nio.file.Files中的很多静态方法都能够生成流, 比如File.lines(). NIO在1.4引入, 但随着1.8 的到来也加入了流要素, 估计也要看看才行.
5. 从函数生成流, Stream.iterate静态方法接受一个初始值和一个依次应用在初始值上的函数对象, 生成一个流, 这个流是无限流. 一般需要限制大小
6. 创造新的值, Stream.generate,静态方法接受一个Supplier<T>, 每次根据Supplier生成流, 也是无限流.