Stream流（java)

1、什么是Stream?

也叫Stream流，是Jdk8开始新增的一套APIjava.util.stream.*），可以用于操作集合或者数组的数据。
优势：Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操
作集合或者数组中的数据，代码更简洁，可读性更好。

例子：

使用stream流 找到姓王，且是两个字的名字，存入到新的集合中

package javaeeDay01.src.thread;

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


public class Test04 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三", "李四", "王五", "赵六", "田七");
        System.out.println(names.toString());

        //找出姓张,且是两个字的名字，存入新的集合
        List<String> newNames = names.stream().filter(s -> s.startsWith("王"))
                                              .filter(s -> s.length() == 2)
                                              .collect(Collectors.toList());
        System.out.println(newNames);

    }
}

 Stram流的使用步骤

 2、Stream流的常用方法

2.1、获取List集合的Stream流

        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三","李四","王五","赵六","钱七");
        Stream<String> stream1 = names.stream();

2、获取set集合的Stream流

        Set<String> set = new HashSet<>();
        Collections.addAll(set, "王德发", "狗蛋", "铁锤", "马德", "翠花");
        Stream<String> stream2 = set.stream();
        stream2.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));

3、获取map集合的Stream流

 //3、获取map集合的Stream流
        Map<String, Double> map = new HashMap<>();
        map.put("卡卡西", 172.3);
        map.put("千手扉间", 168.3);
        map.put("千手柱间", 166.3);
        map.put("自来也", 170.1);

        //获取map集合的key集合的Stream流
        Set<String> keys = map.keySet();
        Stream<String> ks = keys.stream();

        //获取map集合的value集合的Stream流
        Collection<Double> values = map.values();
        Stream<Double> vs = values.stream();

        //获取map集合的entry集合的Stream流
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        Stream<Map.Entry<String, Double>> kvs = entries.stream();
        //遍历键里含'千'的键值对
        kvs.filter(e -> e.getKey().contains("千")).forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));

4、获取数组的Stream流

 String[] name1 = new String[]{"张三", "李四", "王五", "赵六", "钱七"};
        String[] name2 = {"张三", "李四", "王五", "赵六", "钱七"};
        Stream<String> s1 = Arrays.stream(name2);
        Stream<String> s2 = Stream.of(name2);

3、Stream流常见的中间方法

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

Stream提供的常用中间方法	说明
Stream<T>filter(Predicate<?super T>predicate)	用于对流中的数据进行过滤。
Stream<I>sorted()	对元素进行升序排序
Stream<I>sorted(Comparator<?super I>comparator)	按照指定规则排序
Stream<T>limit(long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
Stream<T> distinct()	去除流中重复的元素。
<R>Stream<R>map(Eunction<?super L,?extends R>mapper)	对元素进行加工，并返回对应的新流
static<T>Stream<T>concat(Stream a，Stream b)	合并a和b两个流为一个流

package javaeeDay01.src.thread;

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

public class Test02 {
    public static void main(String[] args) {
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores, 88.5, 99.5, 100.5);
        // 找出成绩大于等于60分的学生升序并输出
        scores.stream().filter(s -> (s >= 60)).sorted().forEach(s -> System.out.println(s));

        List<Student> students = new ArrayList<>();

        Student student1 = new Student("张三", 54, 1.78);
        Student student4 = new Student("张三", 54, 1.78);
        Student student2 = new Student("李四", 26, 1.68);
        Student student3 = new Student("王五", 27, 1.88);

        Collections.addAll(students, student1, student2, student3);

        //找出年龄大于等于23 且年龄小于等于30岁的学生 并按照年龄降序输出
        students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30).sorted((o1, o2) -> o2.getAge() - o1.getAge()).forEach(s -> System.out.println(s));

        //取出身高最高的3名学生并输出
        System.out.println("========================================");
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight())).limit(3).forEach(s -> System.out.println(s));

        // 取出身高倒数的2名学生 并输出
        System.out.println("========================================");
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight())).skip(students.size() - 2).forEach(s -> System.out.println(s));

        //找出身高超过168的学生叫什么名字，要求去除重复的名字，在输出
        students.stream().filter(s -> s.getHeight() > 1.68).map(s -> s.getName()).distinct().forEach(s -> System.out.println(s));
        //map 加工成名字 与身高一一映射

        System.out.println("!========================================");
        students.stream().filter(s -> s.getHeight() > 1.68).distinct().forEach(s -> System.out.println(s));

        Stream<String> st1 = Stream.of("张三", "李四");
        Stream<String> st2 = Stream.of("王五", "赵六");
        Stream<String> allSt = Stream.concat(st1, st2);
        allSt.forEach(s -> System.out.println(s));
    }
}

class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Double.compare(height, student.height) == 0 && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, height);
    }
}

4、Stream流常见的终结方法

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

Stream提供的常用终结方法	说明
R collect(Colfector collector)	把流处理后的结果收集到一个指定的集合中去
Object[] toArray()	把流处理后的结果收集到一个数组中去

package javaeeDay01.src.thread;

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

public class Test03 {
    public static void main(String[] args) {

        List<Student> students = new ArrayList<>();

        Student s1 = new Student("张三", 54, 1.78);
        Student s2 = new Student("李四", 26, 1.68);
        Student s3 = new Student("王五", 27, 1.46);
        Student s4 = new Student("赵六", 26, 1.88);
        Student s5 = new Student("赵六", 26, 1.88);

        Collections.addAll(students, s1, s2, s3, s4, s5);

        // 计算身高超过168的学生有几个人
        Long count = students.stream().filter(s -> s.getHeight() > 1.68).count();
        System.out.println(count);

        // 请找出身高最高的学生对象 并输出
        Student max = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(max);

        // 请找出身高最矮的学生对象 并输出
        Student min = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(min);

        // 请找出身高超过170的学生对象,并放到一个新集合中去返回
        List<Student> newStudents1 = students.stream().filter(s -> s.getHeight() > 1.7).collect(Collectors.toList());
        System.out.println(newStudents1);

        // 请找出身高超过170的学生对象 并吧学生对象的名字和身高存入到一个Set ,Map,arr 集合中
        Set<Student> newStudents2 = students.stream().filter(s -> s.getHeight() > 1.7).collect(Collectors.toSet());
        System.out.println(newStudents2);

        Map<String, Double> map = students.stream().filter(s -> s.getHeight() > 1.7).distinct().collect(Collectors.toMap(s -> s.getName(), s -> s.getHeight()));
        System.out.println(map);

        Student[] arr = students.stream().filter(s -> s.getHeight() > 1.7).toArray(len -> new Student[len]);
        System.out.println(Arrays.toString(arr));

    }
}