Java-Stream流

Stream

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

Stream流的使用步骤

Stream流的常用方法

####1.获取Stream流

​

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

public class StreamTest2 {
    public static void main(String[] args) {
        //TODO 集合&数组如何获取Stream流
        //1.如何获取List集合的Stream流
        List<String> list = new ArrayList<>();
        Collections.addAll(list,".","..","...");
        Stream<String> listStream = list.stream();
        List<String> rs = list.stream().filter(s -> s.length() == 3).collect(Collectors.toList());
        System.out.println(rs);

        //2.如何获取Set集合的Stream流
        Set<String> set = new HashSet<>();
        Collections.addAll(set,"1","2","3");
        Stream<String> setStream = set.stream();

        //3.如何获取Map集合的Stream流
        Map<String,Double> map = new HashMap<>();
        map.put("迪丽热巴",169.2);
        map.put("马尔扎哈",169.5);
        map.put("玛玛哈哈",167.3);
        map.put("卡尔扎巴",161.2);

        //a.分别将键和值存储到Set集合中，
        // 再调用collection自带的stream方法创建stream对象
        // 即键流和值流
        Set<String> keys = map.keySet();
        Stream<String> mapKeysStream = keys.stream();//ks
        Collection<Double> values = map.values();
        Stream<Double> mapValuesStream = values.stream();//vs

        //b.调用entrySet()方法将键值对对象存储到Set集合中
        // 再调用collection自带的stream方法创建stream对象
        // 即键值对流
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        Stream<Map.Entry<String, Double>> mapKeysAndValuesStream = entries.stream();//kvs
        mapKeysAndValuesStream.filter(kv -> kv.getKey().contains("巴"))
                .forEach(kv -> System.out.println(kv.getKey() + "->" + kv.getValue()));

        //4.如何获取数组的Stream流？
        String[] array = {"a","b","c","d"};
        //a.Arrays类的stream(T[] array)
        Stream<String> arrayStream1 = Arrays.stream(array);
        //b.Stream类的of(T ...values)
        Stream<String> arrayStream2 = Stream.of(array);
    }
}

2.Stream流常见的中间方法

package d1_stream;

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

public class StreamTest3 {
    public static void main(String[] args) {
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores,12.0,100.0,55.0,66.0,88.8,99.9,66.6);
        //需求1：找出成绩大于等于60分的数据，并升序后，在输出
        scores.stream().filter(s -> s >= 60).sorted().forEach(s -> System.out.println(s));

        System.out.println("---------------------------");
        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精",26,172.5);
        Student s2 = new Student("蜘蛛精",26,172.5);
        Student s3 = new Student("紫霞",23,167.6);
        Student s4 = new Student("白晶晶",25,169.0);
        Student s5 = new Student("牛魔王",35,183.3);
        Student s6 = new Student("牛夫人",34,168.5);
        Collections.addAll(students,s1,s2,s3,s4,s5,s6);

        //需求2：找出年龄大于等于23，且年龄小于等于30的学生，并按照年龄降序输出
        students.stream().filter(s -> s.getAge() >= 23).filter(s -> s.getAge() <= 30)
                .sorted((o1, o2) ->o2.getAge() - o1.getAge())
                .forEach(s -> System.out.println(s));
        System.out.println("---------------------------");
        //需求3：取出身高最高的前三名学生并输出
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(),o1.getHeight()))
                .limit(3).forEach(s -> System.out.println(s));
        System.out.println("----------------------------");
        //需求4：取出身高倒数的2名学生，并输出
        students.stream().sorted((o1,o2) -> Double.compare(o2.getHeight(),o1.getHeight()))
                .skip(students.size() - 2).forEach(System.out::println);
        System.out.println("-----------------------------");
        //需求5：找出身高超过168的学生叫什么名字，并要求去除重复的名字，再输出
        students.stream().filter(s -> s.getHeight() > 168)
//                .map(new Function<Student, Object>() {
//                })
                .map(s -> s.getName())//映射，将某种事物加工映射成另一种事物
                .distinct()//去重复
                .forEach(System.out::println);
        System.out.println("-----------------------------");
        //distinct去重复，自定义的对象（希望内容一样就认为重复，需要重写hashCode，equals方法）
        students.stream().filter(s -> s.getHeight() > 168)
                .distinct().forEach(System.out::println);
        System.out.println("-----------------------------");
        //concat合并两个流
        Stream<String> st1 = Stream.of("张三", "李四");
        Stream<String> st2 = Stream.of("张三2", "李四2","王五");
        Stream<String> allSt = Stream.concat(st1, st2);
        allSt.forEach(System.out::println);
        System.out.println("-----------------------------");
//        System.out.println(allSt);
    }
}

3.Stream流常见的终结方法

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

public class StreamTest4 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精",26,172.5);
        Student s2 = new Student("蜘蛛精",26,172.5);
        Student s3 = new Student("紫霞",23,167.6);
        Student s4 = new Student("白晶晶",25,169.0);
        Student s5 = new Student("牛魔王",35,183.3);
        Student s6 = new Student("牛夫人",34,168.5);
        Collections.addAll(students,s1,s2,s3,s4,s5,s6);

        //需求1：请计算身高超过168的学生有几人
        long size = students.stream().filter(s -> s.getHeight() > 168).count();
        System.out.println(size);

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

        //需求3：请找出身高最矮的学生对象并输出
        //a.max找到后存入容器中用get方法取出该对象
        Student sMin = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))
                .get();
        System.out.println(sMin);
//        //b.降序取最后 skip
//        students.stream().sorted((o1,o2) -> Double.compare(o2.getHeight(),o1.getHeight()))
//                .skip(students.size() - 1).forEach(System.out::println);
//        //c.升序取第一 limit
//        students.stream().sorted((o1,o2) -> Double.compare(o1.getHeight(),o2.getHeight()))
//                .limit(1).forEach(System.out::println);
    }
}

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

public class StreamTest4 {
    public static void main(String[] args) {
//需求4:找出身高超过170的学生对象，并放到一个新集合中返回
        //注意：流只能收集一次，可类比于迭代器迭代完跑到最后无法再迭代，水管的水流完了
        /*
        故遇到多次使用同一stream流，不可以将重复调用的流汇用一个stream流的变量来指代，即以下代码不可行
        Stream<Students> sss= students.stream();
         */
        List<Student> listStudents = students.stream().filter(s -> s.getHeight() > 170)
                .collect(Collectors.toList());
        Set<Student> setStudents = students.stream().filter(s -> s.getHeight() > 170)
                .collect(Collectors.toSet());
        System.out.println(listStudents);
        System.out.println(setStudents);

        //需求5：找出升高超过170的学生对象，并放到一个map集合中返回
        Map<String, Double> mapStudents =
                students.stream()
                .filter(s -> s.getHeight() > 170)
                .distinct()
                .collect(Collectors.toMap(s -> s.getName(), s -> s.getHeight()));



//        Map<String,Double> mapStudents = new HashMap<>();
//        for (Student listStudent : listStudents) {
//            double height = listStudent.getHeight();
//            String name = listStudent.getName();
//            mapStudents.put(name,height);
//        }
        System.out.println(mapStudents);

        //找出身高超过170的学生对象，并放到数组中返回
        Object[] arrayStudents = students.stream().filter(s -> s.getHeight() > 170).toArray();
        Student[] arrayStudents1 = students.stream().filter(s -> s.getHeight() > 170).toArray(len -> new Student[len]);
        System.out.println(Arrays.toString(arrayStudents1));
    }
}