JDK8新特性--Stream流

Stream流

Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作.

1.为什么使用Stream流

当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。我们来体验 集合操作数据的弊端，需求如下：

一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰,何线程
需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据

代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @program: qy150-springboot-shiro
 * @description:
 * @author: 闫克起2
 * @create: 2022-07-19 11:59
 **/
public class My {
    public static void main(String[] args) {
// 一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
// 需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
// 1.拿到所有姓张的
        ArrayList<String> zhangList = new ArrayList<>(); // {"张无忌", "张强", "张三丰"}
        for (String name : list) {
            if (name.startsWith("张")) {
                zhangList.add(name);
            }
        }
// 2.拿到名字长度为3个字的
        ArrayList<String> threeList = new ArrayList<>(); // {"张无忌", "张三丰"}
        for (String name : zhangList) {
            if (name.length() == 3) {
                threeList.add(name);
            }
        }
// 3.打印这些数据
        for (String name : threeList) {
            System.out.println(name);
        }
    }
}

分析:

这段代码中含有三个循环，每一个作用不同：

1. 首先筛选所有姓张的人；

2. 然后筛选名字有三个字的人；

3. 最后进行对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使 用另一个循环从头开始。

那Stream能给我们带来怎样更加优雅的写法呢？

Stream的更优写法

package demo08;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;


public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
        list.stream()
                .filter(item->item.startsWith("张"))
                .filter(item->item.length()==3)
                .forEach(item-> System.out.println(item));
    }
}

对集合的操作语法简洁:性能比传统快。

2.Stream流的原理

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

 Stream不存在数据，只对数据进行加工处理。

3.如何获取Stream流对象

 

package com.demo09;

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;

/**
 * @Author Li Qinghua
 * @Create 2022/7/20 15:28
 */
public class TestStream02 {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        Collections.addAll(list,1,5,8,3,45,23,8);

        Stream<Integer> stream = list.stream();
        stream.forEach(num-> System.out.println(num));
        //System.out.println(stream);

        int[] nums={1,4,2,74,3};
        IntStream intStream = Arrays.stream(nums);
        //System.out.println(intStream);
        intStream.forEach(num-> System.out.println(num));

        Stream<String> stringStream = Stream.of("hello", "world");
        //System.out.println(stringStream);
        stringStream.forEach(str-> System.out.println(str));

        LongStream longStream = LongStream.of(1, 2, 3);
        IntStream range = IntStream.range(1, 10);
        IntStream range1 = IntStream.rangeClosed(1, 10);

        /*range.forEach(num-> System.out.println(num));
        range1.forEach(System.out::println);*/

        //上面都是获取的串行流。还可以获取并行流。如果流中的数据量足够大，并行流可以加快处速度。
        range.parallel().forEach(System.out::println);
        list.parallelStream()
                .forEach(System.out::println);
    }
}

4.Stream流中常见的api

中间操作api: 一个操作的中间链，对数据源的数据进行操作。而这种操作的返回类型还是一个Stream对象。

终止操作api: 一个终止操作，执行中间操作链，并产生结果，返回类型不在是Stream流对象。

class Person {
    private String name;
    private Integer age;
    private String country;
    private char sex;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                ", sex=" + sex +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Person(String name, Integer age, String country, char sex) {
        this.name = name;
        this.age = age;
        this.country = country;
        this.sex = sex;
    }
}

List<Person> personList = new ArrayList<>();
personList.add(new Person("欧阳雪",18,"中国",'F'));
personList.add(new Person("Tom",24,"美国",'M'));
personList.add(new Person("Harley",22,"英国",'F'));
personList.add(new Person("向天笑",20,"中国",'M'));
personList.add(new Person("李康",22,"中国",'M'));
personList.add(new Person("小梅",20,"中国",'F'));
personList.add(new Person("何雪",21,"中国",'F'));
personList.add(new Person("李康",22,"中国",'M'));

(1)filter / foreach / count

//filter与forEach  条件筛选
personList.stream().filter(person -> person.getSex()=='M').forEach(System.out::println);

        System.out.println("~~~~~~~~");
        personList.stream().filter(person -> person.getName()=="Tom").forEach(person -> System.out.println(person));

        System.out.println("~~~~~~~~~~~~~");
        personList.stream().filter(person -> person.getAge()==22).forEach(System.out::println);

//count  满足该条件的个数
System.out.println(personList.stream().filter(person -> person.getAge() == 18).count());

(2) map | sorted

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

//map  集合中每个元素只要名.map--->原来流中每个元素转换为另一种格式。
personList.stream()
        .map(person -> {
            Map<String,Object> map=new HashMap<>();
            map.put("name",person.getName());
            map.put("age",person.getAge());
            return map;
        })
        .forEach(System.out::println);

System.out.println("!!!!!!!!!!");


//sorted  对流中元素排序 
personList.stream().
        sorted(((o1, o2) -> o1.getAge()- o2.getAge()))
        .forEach(System.out::println);
    

(3) min max

//查找最大年龄的人. max终止操作
Optional<Person> max = personList.stream().max(((o1, o2) -> o1.getAge() - o2.getAge()));
System.out.println(max);


Optional<Person> max1 = personList.stream().max((o1, o2) -> o1.getName().length() - o2.getName().length());
System.out.println("名字最长的为"+max1.get());

（4）规约reduce

 

Optional<Integer> reduce = personList.stream()
                                    .map(person -> person.getAge())
                                    .reduce((p1, p2) -> p1 + p2);
System.out.println("所有人的年龄和为"+reduce.get());

Integer age = personList.stream().
                    map(person -> {
                            return person.getAge();
                    })
                    .reduce(0, (p1, p2) -> p1 + p2);
System.out.println(age);

（5）collect搜集 match find

match:allMatch、anyMatch、noneMatch 有返回值为boolean

find:findFirst、findAny 有返回值为Optional<>

        boolean b = personList.stream()
                .filter(person -> person.getSex() == 'M')
                .allMatch(person -> person.getAge() == 20);
        System.out.println(b);

        Optional<Person> first = personList.stream()
                .filter(person -> person.getAge()==20)
                .findFirst();
        System.out.println(first.get());

        //搜集方法 collect 它属于终止方法
        List<Person> collect = personList.stream().filter(person -> person.getAge() > 20)
                .filter(person -> person.getSex() == 'M')
                .collect(Collectors.toList());
        System.out.println(collect);