Stream中间操作

多个 中间操作可以连接起来形成一个 流水线，除非流水线上触发终止操作，否则 中间操作不会执行任何的处理！而在 终止操作时一次性全部处理，称为“惰性求值”。

筛选与切片

方法	描述
filter(Predicate p)	接收 Lambda ， 从流中排除某些元素
distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补，配合可以实现类似mysql的limit n1,n2

ArrayList<Player> players = new ArrayList<>();
players.add(new Player("James", 36, 25.4));
players.add(new Player("Curry", 32, 29.3));
players.add(new Player("Durant", 32, 28.4));
players.add(new Player("Kobe", 43, 26.8));
players.add(new Player("Wade", 40, 25.8));
players.add(new Player("Paul", 36, 17.6));
players.add(new Player("Paul", 36, 17.6));
players.add(new Player("Paul", 36, 17.6));

Stream<Player> stream = players.stream();

// 过滤掉年龄超过40的
stream.filter(player->player.getAge() < 40).forEach(System.out::println);

System.out.println();

// 跳过前三名且只显示1名球员信息
stream = players.stream(); // 需要重新获取流
stream.skip(3).limit(1).forEach(System.out::println);

System.out.println();

// 过滤重复数据
stream = players.stream();
stream.distinct().forEach(System.out::println);

映射

方法	描述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

ArrayList<Player> players = new ArrayList<>();
players.add(new Player("James", 36, 25.4));
players.add(new Player("Curry", 32, 29.3));
players.add(new Player("Durant", 32, 28.4));
players.add(new Player("Kobe", 43, 26.8));
players.add(new Player("Wade", 40, 25.8));
players.add(new Player("Paul", 36, 17.6));

Stream<Player> stream = players.stream();
// 获取只包含球员姓名的stream
Stream<String> stringStream = stream.map(Player::getName);
stringStream.forEach(System.out::println);

// 球员的年龄和得分组成一个streamA，每个球员的streamA用<b>一个</b>新的stream保存
System.out.println();
stream = players.stream();
Stream<Double> doubleStreams = stream.flatMap(player -> {
    ArrayList<Double> playerDigit = new ArrayList<>();
    playerDigit.add((double) player.getAge());
    playerDigit.add(player.getScore());

    return playerDigit.stream();
});

doubleStreams.forEach(System.out::println);

排序

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序

ArrayList<Player> players = getPlayers();
Stream<Player> stream = players.stream();

// 自然排序，按年龄排
stream.sorted().forEach(System.out::println);

// 定制排序，按年龄从小到大，再按得分从小到大
System.out.println("========================================");
stream = players.stream();
stream.sorted(
        Comparator.comparing(Player::getAge)
                .thenComparing(Player::getScore)
).forEach(System.out::println);

// 定制排序，先按年龄从大到小、再按得分从小到大
System.out.println("========================================");
stream = players.stream();
stream.sorted((p1, p2) -> {
    int ret = Integer.compare(p2.getAge(), p1.getAge());

    if (ret == 0) {
        ret = Double.compare(p1.getScore(), p2.getScore());
    }

    return ret;
}).forEach(System.out::println);