文章/答案/技术大牛

发布

社区首页 >专栏 >Java8——Stream流

Java8——Stream流

Java旅途

发布于 2020-07-16 07:46:05

54000

代码可运行

文章被收录于专栏：Java旅途Java旅途

运行总次数：0

代码可运行

Stream是数据渠道，用于操作集合、数组等生成的元素序列。

Stream操作的三个步骤：

创建Stream
中间操作
终止操作

一、获取stream的四种方式

通过collection系列集合的stream()或parallelStream()获取。

1@Test
2void test11(){
3    List<String> list = new ArrayList<>();
4    Stream<String> stringStream = list.stream();
5}

通过Arrays中的静态方法stream()获取数组流。

1@Test
2void test11(){
3    Person[] person = new Person[10];
4    Arrays.stream(person);
5}

通过Stream中的静态方法of()。

1@Test
2void test11(){
3    Stream<String> stream = Stream.of("a", "b", "c");
4}

创建无限流

1/**
2 * 迭代
3 */
4@Test
5void test11(){
6    Stream<Integer> integerStream = Stream.iterate(0, x -> x + 2);
7}

1/**
2 * 生成
3 */
4@Test
5void test11(){
6    Stream.generate(() -> Math.random());
7}

二、中间操作

中间操作不会执行任何操作，只有终止操作才会一次性输出全部值，即“惰性求值”。

2.1 筛选与切片

filter——接收lamdba，从流中排除某些元素

 1@Test
 2void test12(){
 3    List<Person> personList = Arrays.asList(
 4        new Person("Java旅途",18),
 5        new Person("Java旅途",20)
 6    );
 7    // 中间操作
 8    Stream<Person> personStream = personList.stream()
 9        .filter(e -> e.getAge() > 18);
10    // 终止操作
11    personStream.forEach(System.out::println);
12}

limit——截断流，使其元素不超过给定数量

 1@Test
 2void test12(){
 3
 4    List<Person> personList = Arrays.asList(
 5        new Person("Java旅途",18),
 6        new Person("Java旅途",20)
 7    );
 8    personList.stream()
 9        .limit(1)
10        .forEach(System.out::println);
11}

skip(n)——跳过元素，返回一个扔掉前n个元素的流，若不足n个，则返回一个空流。与limit(n)互补。

 1@Test
 2void test12(){
 3
 4    List<Person> personList = Arrays.asList(
 5        new Person("Java旅途",18),
 6        new Person("Java旅途",20)
 7    );
 8    personList.stream()
 9        .skip(1)
10        .forEach(System.out::println);
11}

distinct——筛选，通过生成元素的hashCode()和equals()，去除重复元素。

 1@Test
 2void test12(){
 3
 4    List<Person> personList = Arrays.asList(
 5        new Person("Java旅途",18),
 6        new Person("Java旅途",20),
 7        new Person("Java旅途",20)
 8    );
 9    personList.stream()
10        .distinct()
11        .forEach(System.out::println);
12}

注意：使用distinct的时候需要重写实体的hashCode()和equals()方法。

2.2 映射

map——接收lamdba，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

 1/**
 2 * 获取personList的所有name
 3 */
 4@Test
 5void test13(){
 6    List<Person> personList = Arrays.asList(
 7        new Person("Java旅途",18),
 8        new Person("Java旅途",20),
 9        new Person("Java旅途",20)
10    );
11    personList.stream()
12        .map(Person::getName)
13        .forEach(System.out::println);
14}

flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流生成一个流。

1// 将字符串转换为字符，并将字符放进list返回
2static Stream<Character> filterCharcter(String string){
3
4    List<Character> list = new ArrayList<>();
5    for (Character ch : string.toCharArray()){
6        list.add(ch);
7    }
8    return list.stream();
9}

1@Test
2void test13(){
3    List<String> list = Arrays.asList("aaa","bbb","ccc");
4
5    list.stream()
6        .flatMap(LamdbaApplicationTests::filterCharcter)
7        .forEach(System.out::println);
8}

2.3 排序

sorted()——自然排序（comparable）
sorted(comparator com)——定制排序（comparator ）

 1/**
 2* 定制排序，e1和e2按age排序，age一样按name排
 3*/
 4@Test
 5void test14(){
 6    List<Person> personList = Arrays.asList(
 7            new Person("Java旅途",18),
 8            new Person("Java旅途",20)
 9    );
10    personList.stream()
11        .sorted((e1,e2) -> {
12            if(e1.getAge() == e2.getAge()){
13                return e1.getName().compareTo(e2.getName());
14            }else{
15                return e1.getAge()+"".compareTo(e2.getAge()+"");
16            }
17        }).forEach(System.out::println);
18}

三、终止操作

3.1 查找与匹配

完善一下Person类

 1@Data
 2public class Person implements Serializable {
 3    private static final long serialVersionUID = -7008474395345458049L;
 4
 5    private String name;
 6    private int age;
 7    private Status status;
 8
 9    public Person() {
10    }
11    public Person(String name, int age) {
12        this.name = name;
13        this.age = age;
14    }
15    public Person(String name, int age, Status status) {
16        this.name = name;
17        this.age = age;
18        this.status = status;
19    }
20    public enum Status {
21        FRER,
22        BUSY;
23    }
24}

allMatch——检查是否匹配所有元素

 1/**
 2* 是否所有元素都是Fire状态，是返回true
 3*/
 4@Test
 5void test15(){
 6    List<Person> personList1 = Arrays.asList(
 7        new Person("Java旅途",18, Person.Status.FRER),
 8        new Person("Java旅途",20, Person.Status.BUSY)
 9    );
10    boolean b = personList1.stream()
11        .allMatch(e -> e.getStatus().equals(Person.Status.FRER));
12    System.out.println(b);
13}

anyMatch——检查是否至少匹配一个元素

 1@Test
 2void test15(){
 3    List<Person> personList1 = Arrays.asList(
 4        new Person("Java旅途",18, Person.Status.FRER),
 5        new Person("Java旅途",20, Person.Status.BUSY)
 6    );
 7    boolean b = personList1.stream()
 8        .anyMatch(e -> e.getStatus().equals(Person.Status.FRER));
 9    System.out.println(b);
10}

noneMatch——检查是否所有元素都不匹配

 1@Test
 2void test15(){
 3    List<Person> personList1 = Arrays.asList(
 4        new Person("Java旅途",18, Person.Status.FRER),
 5        new Person("Java旅途",20, Person.Status.BUSY)
 6    );
 7    boolean b = personList1.stream()
 8        .noneMatch(e -> e.getStatus().equals(Person.Status.FRER));
 9    System.out.println(b);
10}

findFirst——返回第一个元素

 1@Test
 2void test15(){
 3    List<Person> personList1 = Arrays.asList(
 4        new Person("Java旅途",18, Person.Status.FRER),
 5        new Person("Java旅途",20, Person.Status.BUSY)
 6    );
 7    Optional b = personList1.stream()
 8        .findFirst();
 9    System.out.println(b.get());
10}

findAny——返回当前流中的任意元素

 1@Test
 2void test15(){
 3    List<Person> personList1 = Arrays.asList(
 4        new Person("Java旅途",18, Person.Status.FRER),
 5        new Person("Java旅途",20, Person.Status.BUSY)
 6    );
 7    Optional b = personList1.stream()
 8        .findAny();
 9    System.out.println(b.get());
10}

count——返回流中元素的总数
max——返回流中最大值
min——返回流中最小值

3.2 规约

reduce(T identity, BinaryOperator)/reduce(BinaryOperator)——可以将流中元素反复结合起来，得到一个值。

 1/**
 2  * reduce 第一个参数是起始值
 3  */
 4@Test
 5void test16(){
 6    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
 7    Integer sum = list.stream()
 8                      .reduce(0,(x,y) -> x+y);
 9    System.out.println(sum);
10
11    Optional<Integer> reduce = list.stream()
12                                   .reduce((x, y) -> x + y);
13    System.out.println(reduce.get());
14}

3.3 收集

collect——将流转化为其他形式。接收一个Collector接口的实现。用于给Stream中元素做汇总的方法。

 1/**
 2* 取出名字放在一个list中
 3*/
 4@Test
 5void test16(){
 6    List<Person> personList1 = Arrays.asList(
 7        new Person("Java旅途",18, Person.Status.FRER),
 8        new Person("Java旅途",20, Person.Status.BUSY)
 9    );
10    List<String> collect = personList1.stream()
11        .map(Person::getName)
12        .collect(Collectors.toList());
13    collect.forEach(System.out::println);
14}