关于java:JAVA-18-新特性-Stream

36次阅读

共计 17792 个字符，预计需要花费 45 分钟才能阅读完成。

什么是 Stream？Stream 将要解决的元素汇合看作一种流，在流的过程中，借助 Stream API 对流中的元素进行操作，比方：筛选、排序、聚合等。

Stream能够由数组或汇合创立，对流的操作分为两种：

  1. 两头操作，每次返回一个新的流，能够有多个。
  2. 终端操作，每个流只能进行一次终端操作，终端操作完结后流无奈再次应用。终端操作会产生一个新的汇合或值。

另外，Stream有几个个性：

  1. stream 不存储数据，而是依照特定的规定对数据进行计算，个别会输入后果。
  2. stream 不会扭转数据源，通常状况下会产生一个新的汇合或一个值。
  3. stream 具备提早执行个性，只有调用终端操作时，两头操作才会执行。

Stream能够通过汇合数组创立。

1、通过 java.util.Collection.stream() 办法用汇合创立流

List<String> list = Arrays.asList("a", "b", "c");
// 创立一个程序流
Stream<String> stream = list.stream();
// 创立一个并行流
Stream<String> parallelStream = list.parallelStream();

2、应用 java.util.Arrays.stream(T[] array) 办法用数组创立流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3、应用 Stream 的静态方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

输入后果：

0 3 6 9
0.4626673076243447
0.9061170024636954
0.4901337233769709

stream和 parallelStream 的简略辨别：stream是程序流，由主线程按程序对流执行操作，而 parallelStream 是并行流，外部以多线程并行执行的形式对流进行操作，但前提是流中的数据处理没有程序要求。

如果流中的数据量足够大，并行流能够放慢处速度。除了间接创立并行流，还能够通过 parallel() 把程序流转换成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

在应用 stream 之前，先了解一个概念：Optional。

Optional类是一个能够为 null 的容器对象。如果值存在则 isPresent() 办法会返回 true，调用get() 办法会返回该对象。

这是前面案例中应用的员工类：

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));

class Person {
  private String name; // 姓名
  private int salary; // 薪资
  private int age; // 年龄
  private String sex; // 性别
  private String area; // 地区

  // 构造方法
  public Person(String name, int salary, int age,String sex,String area) {
    this.name = name;
    this.salary = salary;
    this.age = age;
    this.sex = sex;
    this.area = area;
  }
  // 省略了 get 和 set，请自行添加

}

2.1 遍历 / 匹配（foreach/find/match）

Stream也是反对相似汇合的遍历和匹配元素的，只是 Stream 中的元素是以 Optional 类型存在的。Stream的遍历、匹配非常简单。

// import 已省略，请自行添加，前面代码亦是

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        // 遍历输入符合条件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意（实用于并行流）Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否蕴含合乎特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x < 6);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于 6 的值：" + anyMatch);
    }
}

2.2 筛选（filter）

筛选，是依照肯定的规定校验流中的元素，将符合条件的元素提取到新的流中的操作。

案例一：筛选出 Integer 汇合中大于 7 的元素，并打印进去

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 7).forEach(System.out::println);
  }
}

预期后果：

8 9

案例二：筛选员工中工资高于 8000 的人，并造成新的汇合。造成新汇合依赖collect（收集），后文有具体介绍。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

    List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
        .collect(Collectors.toList());
    System.out.print("高于 8000 的员工姓名：" + fiterList);
  }
}

运行后果：

高于 8000 的员工姓名：[Tom, Anni, Owen]

2.3 聚合（max/min/count)

max、min、count这些字眼你肯定不生疏，没错，在 mysql 中咱们罕用它们进行数据统计。Java stream 中也引入了这些概念和用法，极大中央便了咱们对汇合、数组的数据统计工作。

案例一：获取 String 汇合中最长的元素。

public class StreamTest {public static void main(String[] args) {List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

    Optional<String> max = list.stream().max(Comparator.comparing(String::length));
    System.out.println("最长的字符串：" + max.get());
  }
}

输入后果：

最长的字符串：weoujgsd

案例二：获取 Integer 汇合中的最大值。

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

    // 天然排序
    Optional<Integer> max = list.stream().max(Integer::compareTo);
    // 自定义排序
    Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {return o1.compareTo(o2);
      }
    });
    System.out.println("天然排序的最大值：" + max.get());
    System.out.println("自定义排序的最大值：" + max2.get());
  }
}

输入后果：

天然排序的最大值：11
自定义排序的最大值：11

案例三：获取员工工资最高的人。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

    Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
    System.out.println("员工工资最大值：" + max.get().getSalary());
  }
}

输入后果：

员工工资最大值：9500

案例四：计算 Integer 汇合中大于 6 的元素的个数。

import java.util.Arrays;
import java.util.List;

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);

    long count = list.stream().filter(x -> x > 6).count();
    System.out.println("list 中大于 6 的元素个数：" + count);
  }
}

输入后果：

list 中大于 6 的元素个数：4

2.4 映射(map/flatMap)

映射，能够将一个流的元素依照肯定的映射规定映射到另一个流中。分为 map 和flatMap：

  • map：接管一个函数作为参数，该函数会被利用到每个元素上，并将其映射成一个新的元素。
  • flatMap：接管一个函数作为参数，将流中的每个值都换成另一个流，而后把所有流连接成一个流。

案例一：英文字符串数组的元素全副改为大写。整数数组每个元素 +3。

public class StreamTest {public static void main(String[] args) {String[] strArr = {"abcd", "bcdd", "defde", "fTr"};
    List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());

    List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
    List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());

    System.out.println("每个元素大写：" + strList);
    System.out.println("每个元素 +3：" + intListNew);
  }
}

输入后果：

每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素 +3：[4, 6, 8, 10, 12, 14]

案例二：将员工的薪资全副减少 1000。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

    // 不扭转原来员工汇合的形式
    List<Person> personListNew = personList.stream().map(person -> {Person personNew = new Person(person.getName(), 0, 0, null, null);
      personNew.setSalary(person.getSalary() + 10000);
      return personNew;
    }).collect(Collectors.toList());
    System.out.println("一次改变前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
    System.out.println("一次改变后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());

    // 扭转原来员工汇合的形式
    List<Person> personListNew2 = personList.stream().map(person -> {person.setSalary(person.getSalary() + 10000);
      return person;
    }).collect(Collectors.toList());
    System.out.println("二次改变前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
    System.out.println("二次改变后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
  }
}

输入后果：

一次改变前：Tom–>8900
一次改变后：Tom–>18900
二次改变前：Tom–>18900
二次改变后：Tom–>18900

案例三：将两个字符数组合并成一个新的字符数组。

public class StreamTest {public static void main(String[] args) {List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
    List<String> listNew = list.stream().flatMap(s -> {
      // 将每个元素转换成一个 stream
      String[] split = s.split(",");
      Stream<String> s2 = Arrays.stream(split);
      return s2;
    }).collect(Collectors.toList());

    System.out.println("解决前的汇合：" + list);
    System.out.println("解决后的汇合：" + listNew);
  }
}

输入后果：

解决前的汇合：[m-k-l-a, 1-3-5]
解决后的汇合：[m, k, l, a, 1, 3, 5]

2.5 归约(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对汇合求和、求乘积和求最值操作。

案例一：求 Integer 汇合的元素之和、乘积和最大值。

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
    // 求和形式 1
    Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
    // 求和形式 2
    Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
    // 求和形式 3
    Integer sum3 = list.stream().reduce(0, Integer::sum);
    
    // 求乘积
    Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

    // 求最大值形式 1
    Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
    // 求最大值写法 2
    Integer max2 = list.stream().reduce(1, Integer::max);

    System.out.println("list 求和：" + sum.get() + "," + sum2.get() + "," + sum3);
    System.out.println("list 求积：" + product.get());
    System.out.println("list 求和：" + max.get() + "," + max2);
  }
}

输入后果：

list 求和：29,29,29
list 求积：2112
list 求和：11,11

案例二：求所有员工的工资之和和最高工资。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

    // 求工资之和形式 1：Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
    // 求工资之和形式 2：Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),
        (sum1, sum2) -> sum1 + sum2);
    // 求工资之和形式 3：Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);

    // 求最高工资形式 1：Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
        Integer::max);
    // 求最高工资形式 2：Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
        (max1, max2) -> max1 > max2 ? max1 : max2);

    System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
    System.out.println("最高工资：" + maxSalary + "," + maxSalary2);
  }
}

输入后果：

工资之和：49300,49300,49300
最高工资：9500,9500

2.6 收集(collect)

collect，收集，能够说是内容最繁多、性能最丰盛的局部了。从字面上去了解，就是把一个流收集起来，最终能够是收集成一个值也能够收集成一个新的汇合。

collect次要依赖 java.util.stream.Collectors 类内置的静态方法。

2.6.1 归集(toList/toSet/toMap)

因为流不存储数据，那么在流中的数据实现解决后，须要将流中的数据从新归集到新的汇合里。toList、toSet和 toMap 比拟罕用，另外还有 toCollection、toConcurrentMap 等简单一些的用法。上面用一个案例演示 toList、toSet 和toMap：

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
    List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
    Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    
    Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
        .collect(Collectors.toMap(Person::getName, p -> p));
    System.out.println("toList:" + listNew);
    System.out.println("toSet:" + set);
    System.out.println("toMap:" + map);
  }
}

运行后果：

toList：[6, 4, 6, 6, 20]
toSet：[4, 20, 6]
toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

2.6.2 统计(count/averaging)

Collectors提供了一系列用于数据统计的静态方法：

  • 计数：count
  • 平均值：averagingInt、averagingLong、averagingDouble
  • 最值：maxBy、minBy
  • 求和：summingInt、summingLong、summingDouble
  • 统计以上所有：summarizingInt、summarizingLong、summarizingDouble

案例：统计员工人数、平均工资、工资总额、最高工资。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

    // 求总数
    Long count = personList.stream().collect(Collectors.counting());
    // 求平均工资
    Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
    // 求最高工资
    Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
    // 求工资之和
    Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
    // 一次性统计所有信息
    DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

    System.out.println("员工总数：" + count);
    System.out.println("员工平均工资：" + average);
    System.out.println("员工工资总和：" + sum);
    System.out.println("员工工资所有统计：" + collect);
  }
}

运行后果：

员工总数：3
员工平均工资：7900.0
员工工资总和：23700
员工工资所有统计：DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}

2.6.3 分组(partitioningBy/groupingBy)

  • 分区：将 stream 按条件分为两个Map，比方员工按薪资是否高于 8000 分为两局部。
  • 分组：将汇合分为多个 Map，比方员工按性别分组。有单级分组和多级分组。

案例：将员工按薪资是否高于 8000 分为两局部；将员工按性别和地区分组

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, "male", "New York"));
    personList.add(new Person("Jack", 7000, "male", "Washington"));
    personList.add(new Person("Lily", 7800, "female", "Washington"));
    personList.add(new Person("Anni", 8200, "female", "New York"));
    personList.add(new Person("Owen", 9500, "male", "New York"));
    personList.add(new Person("Alisa", 7900, "female", "New York"));

    // 将员工按薪资是否高于 8000 分组
        Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("员工按薪资是否大于 8000 分组状况：" + part);
        System.out.println("员工按性别分组状况：" + group);
        System.out.println("员工按性别、地区：" + group2);
  }
}

输入后果：

员工按薪资是否大于 8000 分组状况：{false=[mutest.Person@2d98a335, mutest.Person@16b98e56, mutest.Person@7ef20235], true=[mutest.Person@27d6c5e0, mutest.Person@4f3f5b24, mutest.Person@15aeb7ab]}
员工按性别分组状况：{female=[mutest.Person@16b98e56, mutest.Person@4f3f5b24, mutest.Person@7ef20235], male=[mutest.Person@27d6c5e0, mutest.Person@2d98a335, mutest.Person@15aeb7ab]}
员工按性别、地区：{female={New York=[mutest.Person@4f3f5b24, mutest.Person@7ef20235], Washington=[mutest.Person@16b98e56]}, male={New York=[mutest.Person@27d6c5e0, mutest.Person@15aeb7ab], Washington=[mutest.Person@2d98a335]}}

2.6.4 接合(joining)

joining能够将 stream 中的元素用特定的连接符（没有的话，则间接连贯）连接成一个字符串。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

    String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
    System.out.println("所有员工的姓名：" + names);
    List<String> list = Arrays.asList("A", "B", "C");
    String string = list.stream().collect(Collectors.joining("-"));
    System.out.println("拼接后的字符串：" + string);
  }
}

运行后果：

所有员工的姓名：Tom,Jack,Lily
拼接后的字符串：A-B-C

2.6.5 归约(reducing)

Collectors类提供的 reducing 办法，相比于 stream 自身的 reduce 办法，减少了对自定义归约的反对。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

    // 每个员工减去起征点后的薪资之和（这个例子并不谨严，但一时没想到好的例子）Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
    System.out.println("员工扣税薪资总和：" + sum);

    // stream 的 reduce
    Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
    System.out.println("员工薪资总和：" + sum2.get());
  }
}

运行后果：

员工扣税薪资总和：8700
员工薪资总和：23700

2.7 排序(sorted)

sorted，两头操作。有两种排序：

  • sorted()：天然排序，流中元素需实现 Comparable 接口
  • sorted(Comparator com)：Comparator 排序器自定义排序

案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();

    personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
    personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
    personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 8800, 26, "male", "New York"));
    personList.add(new Person("Alisa", 9000, 26, "female", "New York"));

    // 按工资升序排序（天然排序）List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
        .collect(Collectors.toList());
    // 按工资倒序排序
    List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
        .map(Person::getName).collect(Collectors.toList());
    // 先按工资再按年龄升序排序
    List<String> newList3 = personList.stream()
        .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
        .collect(Collectors.toList());
    // 先按工资再按年龄自定义排序（降序）List<String> newList4 = personList.stream().sorted((p1, p2) -> {if (p1.getSalary() == p2.getSalary()) {return p2.getAge() - p1.getAge();} else {return p2.getSalary() - p1.getSalary();}
    }).map(Person::getName).collect(Collectors.toList());

    System.out.println("按工资升序排序：" + newList);
    System.out.println("按工资降序排序：" + newList2);
    System.out.println("先按工资再按年龄升序排序：" + newList3);
    System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
  }
}

运行后果：

按工资升序排序：[Lily, Tom, Sherry, Jack, Alisa]
按工资降序排序：[Sherry, Jack, Alisa, Tom, Lily]
先按工资再按年龄升序排序：[Lily, Tom, Sherry, Jack, Alisa]
先按工资再按年龄自定义降序排序：[Alisa, Jack, Sherry, Tom, Lily]

2.8 提取 / 组合

流也能够进行合并、去重、限度、跳过等操作。

public class StreamTest {public static void main(String[] args) {String[] arr1 = {"a", "b", "c", "d"};
    String[] arr2 = { "d", "e", "f", "g"};

    Stream<String> stream1 = Stream.of(arr1);
    Stream<String> stream2 = Stream.of(arr2);
    // concat: 合并两个流 distinct：去重
    List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
    // limit：限度从流中取得前 n 个数据
    List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
    // skip：跳过前 n 个数据
    List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

    System.out.println("流合并：" + newList);
    System.out.println("limit：" + collect);
    System.out.println("skip：" + collect2);
  }
}

运行后果：

流合并：[a, b, c, d, e, f, g]
limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
skip：[3, 5, 7, 9, 11]

文章起源：https://blog.csdn.net/mu_wind…

看到这里明天的分享就完结了，如果感觉这篇文章还不错，来个 分享、点赞、在看 三连吧，让更多的人也看到～

欢送关注集体公众号 「JavaClub」，定期为你分享一些技术干货。

正文完
java
发表至： java
2022-01-17
 0
关于java:微信服务商分账功能开发PHP
关于java:盲盒一番赏小程序和盲盒app的一些玩法介绍
Java 嵌入 SPL 轻松实现数据分组
关于java:Java-时间工具类-总结