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

1 篇文章 0 订阅
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 +
                    '}';
        }
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值