Stream

一:介绍

1.Stream也叫Stream流，是JDK8开始新增的一套API(java.util.stream.*)，可以用用于操作集合或者数组的数据。

2.优势：Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。

3.简单示例：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Test1 {
    public static void main(String[] args) {
        List<String> Name = new ArrayList<>();
        Collections.addAll(Name, "王凯","蔡建宇","樊军鑫","余洋","杨博铭");
        // 要筛选出名字为三个字的人
        // 正常方式
        List<String> list1 = new ArrayList<>();
        for (String s : Name) {
            if (s.length() == 3){
                list1.add(s);
            }
        }
        System.out.println(list1);

        // Stream流方式
        List<String> list2 = Name.stream().filter(s -> s.length() == 3).collect(Collectors.toList());
        System.out.println(list2);
    }
}

二:获取Stream流

1.获取集合的Stream流

方法：

Stream<E> stream() 获取当前集合对象的Stream流

2.获取数组的Stream流

stream(T[] array) 获取当前数组的Stream流

of(T...values) 获取当前接受数据的Stream流

3.示例：

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

public class Test2 {
    public static void main(String[] args) {
        // 1.获取List集合的Stream流
        List<String> goods = new ArrayList<>();
        Collections.addAll(goods, "手表","护腕","耳机","跑鞋");
        Stream<String> s1 = goods.stream();

        // 2.获取Set集合的Stream流
        Set<String> run = new HashSet<>();
        Collections.addAll(run, "压缩裤","速干衣","口粮鞋","运动耳机","运动手表");
        Stream<String> s2 = run.stream();

        // 3.获取Map集合的Stream流
        Map<String,Double> Speed = new HashMap<>();
        Speed.put("第一次五公里", 5.34);
        Speed.put("第二次五公里", 5.02);
        Speed.put("第三次五公里", 4.49);
        Speed.put("最新一次五公里", 4.07);
        Speed.put("第一次十公里", 4.49);
        Speed.put("第一次十五公里", 4.47);

        // ①分别获取键和值的
        Set<String> list1 = Speed.keySet();
        Stream<String> s3 = list1.stream();

        Collection<Double> list2 = Speed.values();
        Stream<Double> s4 = list2.stream();

        // ②通过键值对来获取
        Set<Map.Entry<String, Double>> entries = Speed.entrySet();
        Stream<Map.Entry<String, Double>> s5 = entries.stream();

        s5.filter(s -> s.getKey().contains("一")).forEach(System.out::println);
        // 4.获取数组中的Stream流
        int[] num = {11,22,33,44,55,66,77,88};
        // 方式①
        IntStream s6 = Arrays.stream(num);

        // 方式②
        Stream<int[]> s7 = Stream.of(num);
    }
}

三:Stream流常见的中间方法

1.中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）。

2.Stream流提供的常用中间方法：

filter(Predicate<? super T> predicate) 用于对流中数据进行过滤

sorted() 对元素进行升序排序

sorted(Comparator<? super T> comparator) 按照指定规则排序

limit(long maxSize) 获取前几个元素

skip(long n) 跳过前几个元素

distinct() 去除流中重复的元素

map(Function<? superT,? extends R> mapper) 对元素进行加工并返回对应的新流

concat(Stream a,Stream b) 合并a和b两个流为一个流

3.示例：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test3 {
    public static void main(String[] args) {
        List<Student> stu = new ArrayList<>();
        stu.add(new Student("蔡建宇", 18, 159.4));
        stu.add(new Student("蔡建宇", 18, 159.4));
        stu.add(new Student("高赞翔", 21, 164.6));
        stu.add(new Student("李炜洁", 19, 173.4));
        stu.add(new Student("付志豪", 20, 178.9));

        //1.过滤出身高高于175的人
        stu.stream().filter(s -> s.getHeight()>175).forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //2.对按照年龄对对象进行升序排序
        stu.stream().sorted().forEach(System.out::println);//默认对于对象没指定比较规则无法排序
        System.out.println("------------------------------------------------------");

        //3.按照升高对对象身高进行降序排序
        stu.stream().sorted(((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))).forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //4.获取集合中的身高最高的三人
        stu.stream().sorted(((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))).limit(3).forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //5，集合中跳过最高三人获取最矮的那个人
        stu.stream().sorted(((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))).skip(3).forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //6.去除流中重复的元素
        stu.stream().distinct().forEach(System.out::println);//默认希望去除内容一样的对象要重写类中的equals和hashCode方法
        System.out.println("------------------------------------------------------");

        //7.对元素进行加工并返回对应的新流如找到低于160的人并去除名字相同的对象
        stu.stream().filter(s -> s.getHeight() < 160).map(Student::getName)//Student::getName 相当于 s -> s.getName
        .distinct().forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //8.合并两个流为一个流
        Stream<String> s1 = Stream.of("王凯", "蔡建宇");
        Stream<String> s2 = Stream.of("刘涛", "田猛");
        Stream.concat(s1, s2).forEach(System.out::println);

    }
}

四:Stream流常见的终结方法

1.终结方法指的是调用完成后，不会返回新的Stream了，没法继续使用流了。

收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。

Stream流：方便操作集合/数组的手段；集合/数组：才是开发中的目的。

2.Stream提供的常见终结方法：

forEach(Consumer action) 对此流运算后的元素执行遍历

count() 统计此流运算后的元素个数

max(Comparator<? super T> comparator) 获取此流运算后的最大值元素

min(Comparator<? super T> comparator) 获取此流运算后的最小值元素

collect(Collector collector) 把流处理后的结果收集到一个指定的集合中去

toArray() 把流处理后的结果收集到一个数组中去

3.示例：

import java.util.*;
import java.util.stream.Collectors;

public class Test4 {
    public static void main(String[] args) {
        List<Student> stu = new ArrayList<>();
        stu.add(new Student("蔡建宇", 18, 159.4));
        stu.add(new Student("蔡建宇", 18, 159.4));
        stu.add(new Student("高赞翔", 21, 164.6));
        stu.add(new Student("李炜洁", 19, 173.4));
        stu.add(new Student("付志豪", 20, 178.9));

        //1.对此流运算后的元素执行遍历
        stu.stream().filter(s -> s.getAge() > 20).forEach(System.out::println);
        System.out.println("------------------------------------------------------");

        //2.统计此流运算后的元素个数
        long size = stu.stream().filter(s -> s.getHeight() > 160).count();
        System.out.println(size);
        System.out.println("------------------------------------------------------");

        //3.得到身高最高的人
        Student s1 = stu.stream().max(((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))).get();
        System.out.println(s1);
        System.out.println("------------------------------------------------------");

        //4.得到身高最低的人
        Student s2 = stu.stream().min(((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))).get();
        System.out.println(s2);
        System.out.println("------------------------------------------------------");

        //5.将身高超过160的人储存到一个新的集合中去
        List<Student> s3 = stu.stream().filter(s -> s.getHeight() > 160).collect(Collectors.toList());
        System.out.println(s3);
        System.out.println("------------------------------------------------------");

        Set<Student> s4 = stu.stream().filter(s -> s.getHeight() > 160).collect(Collectors.toSet());
        System.out.println(s4);
        System.out.println("------------------------------------------------------");

        //6.将身高超过170的人的名字和身高存储到Map集合中去
        Map<String, Double> s5 = stu.stream().filter(s -> s.getHeight() > 170).collect(Collectors.toMap(a -> a.getName(), b -> b.getHeight()));
        System.out.println(s5);


    }
}