【Java 8】Stream常见场景使用，看这一篇就够啦

zombie._

已于 2022-08-18 11:51:59 修改

阅读量689

点赞数

分类专栏： java Stream API Stream 文章标签： java java-ee

于 2022-08-18 11:30:44 首次发布

本文链接：https://blog.csdn.net/weixin_45962830/article/details/126402405

版权

java 同时被 3 个专栏收录

6 篇文章 0 订阅

订阅专栏

Stream API

1 篇文章 0 订阅

订阅专栏

Stream

1 篇文章 0 订阅

订阅专栏

学习Stream API如何在常见场景下使用

Student2.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Student2 {
    private String id;
    private String name;
    private double score;
    private String teacher;
    private int classId;

    public Student2(String name, double score, String teacher, int classId) {
        this.id = UUID.randomUUID().toString().substring(0,8);
        this.name = name;
        this.score = score;
        this.teacher = teacher;
        this.classId = classId;
    }
    public static List<Student2> getStudent()
    {
        Student2  a = new Student2("王冬冬1",88.8,"晓东老师1",1);
        Student2  b = new Student2("王冬冬5",60,"晓东老师1",1);
        Student2  c = new Student2("王冬冬3",70,"晓东老师1",1);
        Student2  d = new Student2("王冬冬4",95,"晓东老师1",1);
        System.out.println("说明 sum1(4): "+(88.8+95+70+60) + "--" +(88.8+95+70+60)/4);
        Student2  f = new Student2("王冬冬6",55,"晓东老师3",3);
        Student2  e = new Student2("王冬冬5",100,"晓东老师2",2);
        Student2  g = new Student2("王冬冬7",45,"晓东老师1",2);
        Student2  h = new Student2("王冬冬8",90,"晓东老师2",2);
        Student2  j = new Student2("王冬冬9",75,"晓东老师2",2);
        Student2  k = new Student2("王冬冬10",88.8,"晓东老师2",2);
        System.out.println("说明 sum2(5): "+(88.8+100+45+90+75) + "--" +(88.8+100+45+90+75)/5);

        return Stream.of(a, b, c, d, e, f, g, h, j, k).collect(Collectors.toList());
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getTeacher() {
        return teacher;
    }

    public void setTeacher(String teacher) {
        this.teacher = teacher;
    }

    public int getClassId() {
        return classId;
    }

    public void setClassId(int classId) {
        this.classId = classId;
    }

    @Override
    public String toString() {
        return "\nStudent2{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", score=" + score +
                ", teacher='" + teacher + '\'' +
                ", classId='" + classId + '\'' +
                "}\n";
    }
}

练习题

1 查询出成绩不及格的集合
2 查询出晓东老师1所带班级的总分
3 查询出class==1，班级总人数
4 查询班级1的平均分
5 查询各班的总分
6 查询各班的平均分
7 按照班级进行分组，再通过name进行分组
8 获取各班的人数
9 获取学生老师的名字，不重复
10 获取学生老师的数量
11 获取每个老师带的学生个数
12 按照学生分数排名，获取列表
13 获取成绩前3的学生
-----解析字符串-----
1 “a,b;c;d;e,f;” 解析成Pair集合 List<Pair<Integer,Long>>
2 将 "a,b" 解析成Pair对象
-----数组操作-------
1 计算数组总和
2 计算数组平均值
3 给数组*2 计算总和
4 求和二维数组的个数
5 计算int[][] arr_2 的数组总和(求和二维数组)

Demo

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

public class Review {
    public static void main(String[] args) {
        List<Student2> list = Student2.getStudent();
        // 1 查询出成绩不及格的集合
        List<Student2> score_min_60 = list.stream().filter(student2 -> student2.getScore() < 60).collect(Collectors.toList());
        System.out.println("1 查询出成绩不及格的集合\n"+score_min_60);

        // 2 查询出晓东老师1所带班级的总分
        double sum_1 = list.stream().filter(student2 -> "晓东老师1".equalsIgnoreCase(student2.getTeacher())).mapToDouble(Student2::getScore).sum();
        System.out.println("2 查询出晓东老师1所带班级的总分\t"+sum_1);

        // 3 查询出class==1，班级总人数
        long count = list.stream().filter(student2 -> student2.getClassId() == 1).count();
        System.out.println("3 查询出class==1，班级总人数\t"+count);

        // 4 查询班级1的平均分

            // first
        long count1 = list.stream().filter(student2 -> student2.getClassId() == 1).count();
        double sum = list.stream().filter(student2 -> student2.getClassId() == 1).mapToDouble(Student2::getScore).sum();
            // second
        double avg = list.stream().filter(student2 -> student2.getClassId() == 1).mapToDouble(Student2::getScore).average().orElse(0.0);
        System.out.println("4 查询班级1的平均分\t"+(sum/count1));
        System.out.println("4.1 (orElse)查询班级1的平均分\t"+ avg);

        // 5 查询各班的总分
        Map<Integer, Double> score_1_sum = list.stream().collect(Collectors.groupingBy(Student2::getClassId, Collectors.summingDouble(Student2::getScore)));
        System.out.println("5 查询各班的总分");
        priMap(score_1_sum);

        // 6 查询各班的平均分
        Map<Integer, Double> score_1_avg = list.stream().collect(Collectors.groupingBy(Student2::getClassId, Collectors.averagingDouble(Student2::getScore)));
        System.out.println("6 查询各班的平均分");
        priMap(score_1_avg);

        // 7 按照班级进行分组，再通过name进行分组
        Map<Integer, Map<String, Student2>> map_class_name = list.stream().collect(Collectors.groupingBy(Student2::getClassId, Collectors.toMap(Student2::getName, student2 -> student2)));
        System.out.println("7 按照班级进行分组，再通过name进行分组");
        Student2 wdd1 = map_class_name.get(1).get("王冬冬1");
        System.out.println("7.1 获取class1_王冬冬1   wdd1\t"+wdd1);
        priMap(map_class_name);

        // 8 获取各班的人数
        Map<Integer, Integer> map_count = list.stream().collect(Collectors.groupingBy(Student2::getClassId, Collectors.summingInt(student -> 1)));
        System.out.println("8 获取各班的人数");
        priMap(map_count);

        // 9 获取学生老师的名字，不重复
        Set<String> teachers = list.stream().map(Student2::getTeacher).collect(Collectors.toSet());
        System.out.println("9 获取学生老师的名字，不重复\t" + teachers);
        // 10 获取学生老师的数量
        long teacher_count = list.stream().map(Student2::getTeacher).distinct().count();
        System.out.println("10 获取学生老师的数量 \t" + teacher_count);

        // 11 获取每个老师带的学生个数
        Map<String, Integer> teacher_student_cnt = list.stream().collect(Collectors.groupingBy(Student2::getTeacher, Collectors.summingInt(Student2 -> 1)));
        System.out.println("11 获取每个老师带的学生个数");
        priMap(teacher_student_cnt);

        // 12 按照学生分数排名，获取列表
        List<Student2> sorted_stu = list.stream().sorted((a,b)->Double.compare(b.getScore(),a.getScore())).collect(Collectors.toList());
        System.out.println("12 按照学生分数排名，获取列表 \t"+ sorted_stu);

        // 13 获取成绩前3的学生
        List<Student2> top_3 = list.stream().sorted((a, b) -> Double.compare(b.getScore(), a.getScore())).limit(3).collect(Collectors.toList());
        System.out.println("13 获取成绩前3的学生\t"+top_3);

        System.out.println("--------------解析字符串-------------------");

        // a 将 “a,b;c;d;e,f;” 解析成P对象的集合 List<Pair<Integer,Long>>
        String pairs = "100,2;101,2;102,3;103,4";
        List<Pair<Integer, Long>> str_pairs = Arrays.stream(pairs.split(";"))
                .map(str -> str.split(","))
                .map(arr -> new Pair<Integer, Long>(Integer.parseInt(arr[0]), Long.parseLong(arr[1])))
                .collect(Collectors.toList());
        System.out.println("a 将 “a,b;c;d;e,f;” 解析成P对象的集合 List<Pair<Integer,Long>>\t"+str_pairs);
        // b 将 "a,b" 解析成P对象
        String pair = "101,2";
            // fir
        List<Pair<Integer, Long>> pairs1 = Stream.of(pair).map(str -> {
            String[] sp = str.split(",");
            if(sp.length<2) return  null;
            return new Pair<Integer, Long>(Integer.parseInt(sp[0]), Long.parseLong(sp[1]));
        }).collect(Collectors.toList());
            // second
        Pair<Integer, Long> fir = Stream.of(pair).map(str -> {
            String[] sp = str.split(",");
            if (sp.length < 2) return null;
            return new Pair<Integer, Long>(Integer.parseInt(sp[0]), Long.parseLong(sp[1]));
        }).findFirst().get();
        System.out.println("b1 将 \"a,b\" 解析成P对象" + pairs1.get(0));
        System.out.println("b2 将 \"a,b\" 解析成P对象" + fir);

        // arr1 计算数组总和
        int[] arr = {1,2,3};
        int arr_sum = Arrays.stream(arr).sum();
        System.out.println("arr1 计算数组总和\t"+arr_sum);
        // arr2 计算数组平均值
        double avg_arr = Arrays.stream(arr).average().orElse(0.0);
        System.out.println("arr2 计算数组平均值\t"+ avg_arr);
        // arr3 给数组*2 计算总和
        int sum_2 = Arrays.stream(arr).map(num -> num * 2).sum();
        System.out.println("arr3 给数组*2 计算总和\t"+sum_2);
        // arr4 计算int[][] arr_2 的数组总和(求和二维数组)
        int[][] arr_2 = {{1,2,3},{2,3}};
        int sum_2_21 = Stream.of(arr_2).mapToInt(ar -> Arrays.stream(ar).sum()).sum();
        System.out.println("arr4 求和二维数组\t" + sum_2_21);

        // arr5 求和二维数组的个数
        int avg_2_arr = Stream.of(arr_2).mapToInt(ar -> ar.length).sum();
        System.out.println("arr5 求和二维数组的个数\t"+avg_2_arr);

        // arr6 获取数组中的最大值
        int max = Arrays.stream(arr).max().orElseGet(() -> 0);
        System.out.println("arr6 获取数组中的最大值\t"+max);
        // arr7 获取数组中的最小值
        int min = Arrays.stream(arr).min().orElseGet(() -> 0);
        System.out.println("arr7 获取数组中的最小值\t"+min);
        // arr8 判断元素是否在数组中(ar==1)
        boolean is_one_in = Arrays.stream(arr).anyMatch(ar -> ar == 1);
        System.out.println("arr8 判断元素是否在数组中(ar==1)\t"+is_one_in);
        // arr9 判断元素是否不在数组中(ar==10)
        boolean is_not_in = Arrays.stream(arr).noneMatch(ar -> ar == 10);
        System.out.println("arr9 判断元素是否不在数组中(ar==10)\t"+is_not_in);
        // arr10 获取最大的元素
    }

    public static void priMap(Map map)
    {
        map.entrySet().forEach(System.out::println);
    }

    static class Pair<T,V>
    {
        public T key;
        public V value;

        public Pair() {
        }

        public Pair(T key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public String toString() {
            return "MyPair{" +
                    "key=" + key +
                    ", value=" + value +
                    '}';
        }
    }
}