java8新特性：Stream API

原创

日星月云 2021-04-03 15:44:21 ©著作权

文章标签 java stream 数据迭代 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者日星月云的原创作品，请联系作者获取转载授权，否则将追究法律责任

Stream API

正文
代码

StreamAPITest 类
StreamAPITest1 类
StreamTest2 类

图片

总结于尚硅谷学习视频
视频链接 https://www.bilibili.com/video/BV1Kb411W75N?p=677

正文

1.Stream关注的是对数据的运算，与CPU打交道
集合关注的是数据的存储，与内存打交道

1 Stream 自己不会存储元素
2 Stream 不会改变源对象，相反，他们会返回一个持有结果的新Stream
3 Stream 操作是延迟执行的，这意味着他们会等到需要结果的时候才执行

3.Stream执行流程

1 Stream的实例化
2 一系列的中间操作（过滤、映射、…）
3 终止操作

4.说明

4.1 一个中间操作链，对数据源的数据进行处理
4.2 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

代码

StreamAPITest 类

package com.day0329_1;

import com.day0328_1.Employee;
import com.day0328_1.EmployeeData;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1.Stream关注的是对数据的运算，与CPU打交道
 *  集合关注的是数据的存储，与内存打交道
 *
 *  2.
 *  1 Stream    自己不会存储元素
 *  2 Stream    不会改变源对象，相反，他们会返回一个持有结果的新Stream
 *  3 Stream    操作是延迟执行的，这意味着他们会等到需要结果的时候才执行
 *
 *  3.Stream执行流程
 *  1 Stream的实例化
 *  2 一系列的中间操作（过滤、映射、...）
 *  3 终止操作
 *
 *  4.说明
 *  4.1 一个中间操作链，对数据源的数据进行处理
 *  4.2 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
 *
 *
 */
public class StreamAPITest {

    //创建Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> employees= EmployeeData.getEmployee();

//        default Stream<E> stream() :返回一个顺序流
        Stream<Employee> stream =employees.stream();
//        default Stream<E> parallelStream(): 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();

    }

    //创建 Stream 方式二：通过数组
    @Test
    public void test2(){
        int [] arr=new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> stream (T [] array):返回一个流

        IntStream stream= Arrays.stream(arr);

        Employee e1=new Employee(1001,"Tom");
        Employee e2=new Employee(1002,"Jerry");
        Employee[] arr1=new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }

    //创建 Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream =Stream.of(1,2,3,4,5,6);
    }

    //创建Stream 方式四：创建无限流
    @Test
    public void test4(){
//        迭代
//        public static <T> Stream<T> iterate (final T seed,final UnaryOperator<T> f)
        //遍历前十个偶数
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);


//        生成
//        public static <T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }
}

StreamAPITest1 类

package com.day0329_1;

import com.day0328_1.Employee;
import com.day0328_1.EmployeeData;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 测试Stream的中间操作
 *
 */
public class StreamAPITest1 {

    //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployee();
//        filter(Predicate)——接收Lambda，从流中排除某些元素。
        Stream<Employee> stream=list.stream();
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e->e.getSalary()>7000).forEach(System.out::println);
        System.out.println();

//        limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

//        skip(n)——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回空格
        list.stream().skip(3).forEach(System.out::println);

//        distinct()——筛选，通过流所生成元素的hashCode()和equals()去除重复元素
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",41,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

//        System.out.println(list);

        list.stream().distinct().forEach(System.out::println);
    }

    //2-映射
    @Test
    public void test2(){
//        map(Function f)——接受一个函数作为参数，将元素转换成其他形式或提取信息，该函数就会被应用到每一个元素上，并将其映射成一个新的元素。
        List<String> list= Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);

//        练习1：获取员工姓名长度大于3的员工姓名
        List<Employee> employees=EmployeeData.getEmployee();
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(name->name.length()>3).forEach(System.out::println);
        System.out.println();

        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();

//        flatMap(Function f)——接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);


    }


    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list=new ArrayList<>();
        for (Character c :
                str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }


    @Test
    public void test3(){
        ArrayList list1=new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2=new ArrayList<>();
        list2.add(4);
        list2.add(5);
        list2.add(6);

//        list1.add(list2);     //Map
        list1.addAll(list2);    //flatMap

        System.out.println(list1);

    }

    //3-排序
    @Test
    public void test4(){
//        sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);

        //抛异常，原因：Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployee();
//        employees.stream().sorted().forEach(System.out::println);



//        sorted(Comparator com)——定制排序
        List<Employee> employees = EmployeeData.getEmployee();
        employees.stream().sorted((e1,e2)->{
             int ageValue=Integer.compare(e1.getAge(),e2.getAge());
             if(ageValue!=0){
                 return ageValue;
             }else {
                 return -Double.compare(e1.getSalary(),e2.getSalary());
             }

        }).forEach(System.out::println);


    }
}

StreamTest2 类

package com.day0329_1;

import com.day0328_1.Employee;
import com.day0328_1.EmployeeData;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 测试Stream的终止操作
 *
 */
public class StreamTest2 {

    //1-匹配与查找
    @Test
    public void test1() {

        List<Employee> employees = EmployeeData.getEmployee();

//        allMatch(Predicate|p)——检查是否匹配所有元素。
//        练习是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

//        anyMatch(Predicate p)——检查是否至少匹配一个元素。
//        练习:是否存在员工的工资大于10E
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch(Predicate  p)——检查是否没有匹配的元素。
//        练习:是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);

//        findFirst——返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);

//        findAny——返回当前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);




    }

    @Test
    public void test2(){

        List<Employee> employees = EmployeeData.getEmployee();

        //        count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

//        max(Comparator c)——返回流中最大值
//        练习:返回最高的工资:
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);

//        min(Comparator c)——返回流中最小值
//        练习返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);

//        forEach(Consumer c)——内部迭代
        //使用集合的遍历操作
        employees.stream().forEach(System.out::println);

    }

    //2-归约
    @Test
    public void test3(){
//        reduce(T identity ,BinaryOperator)——可以将流中的元素反复结合起来，得到一个值，返回个T
//        练习1：计算1-10的自然数的和
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);

//        reduce(BinaryOperator)——可以将流中的元素反复结合起来，得到一个值，返回个Optional<T>
//        练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployee();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2)->d1+d2);
        System.out.println(sumMoney);




    }

    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)——将流转换为其他形式。接受一个Collector接口的实现，用于给Stream中的元素总汇总的方法
//        练习1：查找工资大于6000的员工，结构返回一个list或set

        List<Employee> employees = EmployeeData.getEmployee();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());

        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet =employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());

        employeeSet.forEach(System.out::println);

    }

}