学习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 +
'}';
}
}
}
本文含有隐藏内容,请 开通VIP 后查看