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);