【Java8】Stream API | 叶遮沉阳

Java

发布日期: 2020-08-13

作者: 叶遮沉阳

文章字数: 2.6k

阅读时长: 12 分

阅读次数:

1. 前言

Java8提供了Stream操作，针对集合可以完成复杂的查找、过滤以及数据映射等操作。

完成一个完整的Stream操作，可分为三步走：

(1) 流的创建：从数据源（集合或数组）中获取一个流；

(2) 中间操作：对流进行过滤、筛选等操作；

(3) 终止操作：对流进行最后的统计或收集等操作。

注意：中间操作需要等到终止操作调用才会执行。

2. 流的创建

2.1 `Collection`

Collection接口提供两种方法来创建流。

Stream<E> stream() 返回一个顺序流；
Stream<E> parallelStream() 返回一个并行流。

注意：数据量不大的情况下，使用顺序流便足够了。

栗子：

static void testParallel() {
    // 程序开始时间
    Instant startTime = Instant.now();

    List<String> list = Arrays.asList("java", "python", "javascript", "html");

    //顺序流
    Stream<String> stream = list.stream().filter(i -> i.startsWith("ja"));
    stream.forEach(System.out::println);

    Instant middleTime = Instant.now();

    //并行流
    Stream<String> stream2 = list.parallelStream().filter(i -> i.startsWith("ja"));
    stream2.forEach(System.out::println);

    // 程序结束时间
    Instant endTime = Instant.now();
    long millis1 = ChronoUnit.MILLIS.between(startTime, middleTime);
    long millis2 = ChronoUnit.MILLIS.between(middleTime, endTime);

    System.out.println("stream程序消耗时间(毫秒)" + millis1);
    System.out.println("parallelStream程序消耗时间(毫秒)" + millis2);
}

输出结果：

javascript
java
javascript
java
stream程序消耗时间(毫秒)73
parallelStream程序消耗时间(毫秒)82

2.2 `Arrays`

数组可以通过Arrays.stream(arr)创建一个流。

栗子：

static void testArrayStream(){
    String[] arr = {"java", "python", "javascript", "html"};
    Stream<String> stream = Arrays.stream(arr).filter(i -> i.startsWith("ja"));
    stream.forEach(System.out::println);
}

2.3 `Stream`

通过Stream.of()可以直接创建一个流。

栗子：

static void testStreamDirect() {
    Stream<String> stream = Stream.of("java", "python", "javascript", "html") //根据多个Value值直接创建一个流
            .filter(i -> i.startsWith("ja")); //半路拦截，只留下以“ja”开头的字符串
    stream.forEach(System.out::println);
}

通过Stream.iterate()和Stream.generate()创建无限流。

栗子：

static void testInfiniteStream(){
    //Stream.iterate()
    Stream<Integer> stream = Stream.iterate(10, x -> x * 2); //从10开始，每次翻倍
    stream.limit(3).forEach(System.out::println);
    System.out.println("----------- 我是最靓分割线 ------------");
    //Stream.generate()
    Stream.generate(Math::random).limit(5).forEach(System.out::println); //整5个随机数玩玩
}

输出结果：

10
20
40
----------- 我是最靓分割线 ------------
0.28733224175718597
0.37745872228126487
0.5575898714168762
0.8904672894488914
0.27626278982879915

3. 中间操作

3.1 筛选

3.1.1 `filter`

对流中的元素进行过滤，满足条件的留下，不满足的全部Game Over！

栗子：

static void testFilter(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    list.stream().filter(i -> i % 2 == 0) // 偶数者留，奇数者去也
            .forEach(System.out::println);
}

// result: 4 2 10

3.1.2 `limit`

限流，只允许指定个数的元素通过，后面的元素一边凉快去吧。

栗子：

static void testLimit(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    list.stream().limit(3) // 只保留前3个元素
            .forEach(System.out::println);
}

// result: 1 3 4

3.1.3 `skip`

跳过，抛弃前面的指定个数的元素，直接跳跃到后面进行流处理。

栗子：

static void testSkip(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    list.stream().skip(3) // 只保留前3个元素
            .forEach(System.out::println);
}

// result: 2 7 10

3.1.4 `distinct`

去重，过滤重复的元素，相同元素只保留一个。

栗子：

static void testDistinct(){
    List<String> list = Arrays.asList("java","java","java","javascript");
    list.stream().distinct() // 请尝尝传说中的归一大法吧
            .forEach(System.out::println);
}

// result: java javascript

3.2 排序

3.2.1 默认排序

栗子：

static void testSorted(){
    List<String> list = Arrays.asList("short","int","char","byte");
    list.stream().sorted() //自然排序
            .forEach(System.out::println);
}

// result: byte char int short

3.2.2 自定义排序

栗子：

static void testDefinedSorted(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    list.stream().sorted((a, b) -> b - a)   //倒序
            .forEach(System.out::println);
}

// result: 10 7 4 3 2 1

3.3 映射

3.3.1 `map`

将流中的元素的值经过一番变化映射成另外一个值。
栗子：

static void testSimpleMap(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4);
    list.stream().map(i -> i * 10)
            .forEach(System.out::println);
}

//result: 10 20 30 40

3.3.2 `flatMap`

map和flatMap有点类似于List中的add和addAll。

add添加一个List只会当做原来的List中一个普通成员，而如果是addAll，则会将新添加的List和原来的List合并成一个List。

static void testAddAll(){
    List<Object> oldList = new ArrayList<>();
    oldList.add(1); //添加单个元素
    oldList.add(Arrays.asList(2, 3)); //添加 List
    System.out.println(Arrays.toString(oldList.toArray()));

    oldList.clear(); //清空
    oldList.add(1); //添加单个元素
    oldList.addAll(Arrays.asList(2, 3)); //添加 List
    System.out.println(Arrays.toString(oldList.toArray()));
}

// result:
// [1, [2, 3]]      //纵横交错深万里
// [1, 2, 3]        //水平扩展一线牵

map处理中如果返回的是Stream，那么只会在原来的Stream中添加Stream作为普通成员，最终的结果是Stream中包含Stream。

而如果flapMap处理中如果返回的是Stream，则会将其合并到原来的Stream中去，最终的结果只有一个Stream。

栗子：

//比 FlatMap 多了一层 foreach
static void testMap(){
    List<Integer[]> list = Arrays.asList(new Integer[]{1 , 2}, new Integer[]{3, 4});
    list.stream().map(integers -> Arrays.stream(integers).map(i -> i * 10))
            .forEach(integerStream -> {integerStream.forEach(System.out::println);});
}

//result: 10 20 30 40

static void testFlatMap(){
    List<Integer[]> list = Arrays.asList(new Integer[]{1 , 2}, new Integer[]{3, 4});
    list.stream().flatMap(integers -> Arrays.stream(integers).map(i -> i * 10))
            .forEach(System.out::println);
}

//result: 10 20 30 40

4. 终止操作

看来是藏不住杀招了，上面的中间操作方法返回类型都Stream，下面的终止操作返回类型都非Stream！

4.1 匹配

4.1.1 `anyMatch`

只要任意一个满足匹配条件，便返回true。

static void testAnyMatch(){
    List<String> list = Arrays.asList("java", "javascript", "python", "html");
    boolean b = list.stream().anyMatch(i -> i.startsWith("p"));
    System.out.println("所有元素字符串中，只要有一个元素是以p开头，便会返回" + b);
}

// result: 所有元素字符串中，只要有一个元素是以p开头，便会返回true

4.1.2 `allMatch`

所有元素满足匹配条件，才会返回true。

栗子：

static void testAllMatch(){
    List<String> list = Arrays.asList("java", "javascript", "python", "html");
    boolean b = list.stream().skip(1) //跳过不包含 t 的 java
            .allMatch(i -> i.contains("t"));
    System.out.println("需要全部元素都包含t，便会返回" + b);
}

// result: 需要全部元素都包含t，便会返回true

4.1.3 `noneMatch`

没有一个元素能够满足匹配条件，便会返回true。

栗子：

static void testNoneMatch(){
    List<String> list = Arrays.asList("java", "javascript", "python", "html");
    boolean b = list.stream().noneMatch(i -> i.contains("z"));
    System.out.println("没有一个元素都包含z，便会返回" + b);
}

// result: 没有一个元素都包含z，便会返回true

4.2 查找

4.2.1 `findFirst`

返回流中的第一个元素。

栗子：

static void testFindFirst(){
    List<String> list = Arrays.asList("java", "javascript", "python", "html");
    Optional<String> s = list.stream().filter(i -> i.contains("t"))
            .findFirst();
    System.out.println("返回第一个元素：" + s);
}

// result: 返回第一个元素：Optional[javascript]

4.2.2 `findAny`

返回流中任意一个元素。

栗子：

static void testFindAny(){
    List<String> list = Arrays.asList("java", "javascript", "python", "html");
    Optional<String> s = list.stream().filter(i -> i.contains("a"))
            .findAny();
    System.out.println("返回任意一个元素：" + s);
}

// result: 返回任意一个元素：Optional[java]

4.3 统计

4.3.1 `count

static void testCount(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    long count = list.stream().filter(i -> i % 2 == 0).count();
    System.out.println("集合中偶数的个数：" + count);
}

// result: 集合中偶数的个数：3

4.3.2 `max`

static void testMax(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    Optional<Integer> integer = list.stream().filter(i -> i % 2 == 0)
            .max(Integer::compareTo);
    System.out.println("集合中偶数的最大值：" + (integer.orElse(null)));
}

// result: 集合中偶数的最大值：10

4.3.3 `min`

static void testMin(){
    List<Integer> list = Arrays.asList(1, 3, 4, 2, 7, 10);
    Optional<Integer> integer = list.stream().filter(i -> i % 2 == 0)
            .min(Integer::compareTo);
    System.out.println("集合中偶数的最小值：" + (integer.orElse(null)));
}

// result: 集合中偶数的最小值：2

4.4 归约

static void testReduce(){
    List<Integer> list = Arrays.asList(1, 3, 4);
    Integer integer = list.stream().reduce(100, (a, b) -> a + b * 2);
    System.out.println("初始值为100，然后将集合中的数值乘以2，再与初始值累加。");
    System.out.println("最终结果：100 + (1 * 2) + (3 * 2) + (4 * 2) = " + integer);
}
// result:
// 初始值为100，然后将集合中的数值乘以2，再与初始值累加。
// 最终结果：100 + (1 * 2) + (3 * 2) + (4 * 2) = 116

4.5 收集

主要介绍Collectors工具类的使用。

4.5.1 返回`Collection`

将流中的元素装入List集合。

List<Integer> list = Stream.of(1, 2, 3).collect(Collectors.toList());

将流中的元素装入Set集合。

Set<Integer> set = Stream.of(1, 2, 3).collect(Collectors.toSet());

将流中元素装入Map集合。

// key: x , value: x * x
Map<Integer, Integer> map = Stream.of(1, 2, 3).collect(Collectors.toMap(x -> x, x -> x * x));
Optional<String> s = map.entrySet().stream()
        .map(x ->  "{" + x.getKey() + ":" + x.getValue() + "}")
        .reduce((x, y) -> x + "," + y);
System.out.println("打印Map新方式，result = [" + s.orElse(null) + "]");

// result: 打印Map新方式，result = [{1:1},{2:4},{3:9}]

将流中的元素装入指定集合。

HashSet<Integer> hashSet = Stream.of(1, 2, 3).collect(Collectors.toCollection(HashSet::new));

4.5.2 拼接字符串

static void testJoinStr(){
    List<String> list = Arrays.asList("java","javascript");
    String collect1 = list.stream().collect(Collectors.joining());
    String collect2 = list.stream().collect(Collectors.joining(","));
    String collect3 = list.stream().collect(Collectors.joining(",", "{", "}"));
    System.out.println(collect1);
    System.out.println(collect2);
    System.out.println(collect3);
}

// result:
// javajavascript
// java,javascript
// {java,javascript}

4.5.2 统计

统计流中元素的个数

Long count = Stream.of(1, 2, 3).collect(Collectors.counting());

统计流中元素的最大值

Optional<Integer> max = Stream.of(1, 2, 3).collect(Collectors.maxBy(Integer::compareTo));

统计流中元素的最小值

Optional<Integer> min = Stream.of(1, 2, 3).collect(Collectors.minBy(Integer::compareTo));

统计流中元素的平均值

// 除了 averagingInt ，还有 averagingLong , averagingDouble
Double avg = Stream.of(1, 1, 2, 3).collect(Collectors.averagingInt(x -> x));

统计流中元素的总和

// 除了 summingInt ，还有 summingLong , summingDouble
Integer sum = Stream.of(1, 1, 2, 3).collect(Collectors.summingInt(x -> x));

统计汇总

// 除了 summarizingInt ，还有 summarizingLong , summarizingDouble
IntSummaryStatistics statistics = Stream.of(1, 1, 2, 3).collect(Collectors.summarizingInt(x -> x));
long count1 = statistics.getCount();
int max1 = statistics.getMax();
int min1 = statistics.getMin();
double average = statistics.getAverage();
long sum1 = statistics.getSum();

4.5.3 其他用法

Collectors.reducing与Stream.reduce类似，进行累计运算。

// 100 + ((1 + 2) + 3)
Integer collect = Stream.of(1, 2, 3).collect(Collectors.reducing(100, (x, y) -> x + y));

// 100 + (((1 + 1) + (2 + 1)) + (3 + 1))
Integer collect = Stream.of(1, 2, 3).collect(Collectors.reducing(100, x -> x + 1, (x, y) -> x + y));

Collectors.mapping与Stream.map类似，进行数据映射。

Integer integer = Stream.of(1, 2, 3).collect(Collectors.mapping(x -> x * 2, Collectors.summingInt(x -> x)));

String collect = Stream.of("a", "b", "c").collect(Collectors.mapping(x -> x.toUpperCase(), Collectors.joining(",")));

Collectors.collectingAndThen

String s = Stream.of("a", "b", "c").collect(Collectors.collectingAndThen(Collectors.joining(","), x -> x.toUpperCase()));

// result: A,B,C

叶遮沉阳

https://yezhechenyang.gitee.io/2020/081334770.html

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源叶遮沉阳 !

【JavaScript】Dom元素的一次往返运动

定时器实现元素往返运动

2020-08-13 JavaScript

JavaScript Interval Observer

【Spring Boot】Redis缓存

SpringBoot 中引入 Redis 缓存

2020-08-11 Spring Boot

Spring Boot 缓存 Redis

1. 前言

2. 流的创建

2.1 Collection

2.2 Arrays

2.3 Stream

3. 中间操作

3.1 筛选

3.1.1 filter

3.1.2 limit

3.1.3 skip

3.1.4 distinct

3.2 排序

3.2.1 默认排序

3.2.2 自定义排序

3.3 映射

3.3.1 map

3.3.2 flatMap

4. 终止操作

4.1 匹配

4.1.1 anyMatch

4.1.2 allMatch

4.1.3 noneMatch

4.2 查找

4.2.1 findFirst

4.2.2 findAny

4.3 统计

4.3.1 `count

4.3.2 max

4.3.3 min

4.4 归约

4.5 收集

4.5.1 返回Collection

4.5.2 拼接字符串

4.5.2 统计

4.5.3 其他用法

你的赏识是我前进的动力!

2.1 `Collection`

2.2 `Arrays`

2.3 `Stream`

3.1.1 `filter`

3.1.2 `limit`

3.1.3 `skip`

3.1.4 `distinct`

3.3.1 `map`

3.3.2 `flatMap`

4.1.1 `anyMatch`

4.1.2 `allMatch`

4.1.3 `noneMatch`

4.2.1 `findFirst`

4.2.2 `findAny`

4.3.2 `max`

4.3.3 `min`

4.5.1 返回`Collection`