Stream
Stream是一种流式结构.是jdk8的特性。为操作集合提供了很多好用的方法。可读性较低。
1 获取流的方式
public static void main(String[] args) {
// 获取Stream流的方式
// 方式一:
// 获取集合
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
// 获取集合的Stream流
Stream<Integer> stream = list.stream();
// 方式二:
Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6, 7);
// 方式三:
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(5, 6, 7, 8);
List<Integer> list3 = Arrays.asList(5,6,8,9);
Stream<Integer> stream2 = Stream.concat(list1.stream(), list2.stream());
Stream<Integer> stream3 = Stream.concat(stream2, list3.stream());
}
2 Stream的使用
- 对集合的数据进行去重/降序排列,并且获取前3个值
private static void method1() {
// 对集合的数据进行去重/降序排列,并且获取前3个值
List<Integer> list = new ArrayList<>();
Collections.addAll(list,1,34,66,7,5,22,89,54,89,66,7,45);
//
// // 把list转换成TreeSet
// TreeSet<Integer> set = new TreeSet<>(list);
// System.out.println(set);
// List<Integer> dataList = new ArrayList<>();
// for (int i = 0; i < 3; i++) {
// Integer integer = set.pollLast();
// dataList.add(integer);
// }
// System.out.println(dataList);
// 获取流
Stream<Integer> stream = list.stream();
// 去重
Stream<Integer> stream1 = stream.distinct();
// 降序排序 默认是升序
Stream<Integer> stream2 = stream1.sorted(Comparator.reverseOrder());
// 对结果的数量进行限定
Stream<Integer> stream3 = stream2.limit(3);
List<Integer> collect = stream3.collect(Collectors.toList());
System.out.println(collect);
// 链式调用
List<Integer> collect1 = list.
stream().
distinct().
sorted(Comparator.reverseOrder()).
limit(3).
collect(Collectors.toList());
System.out.println(collect1);
}
- 统计多个集合中的最大最小值，平均值，求和。降序排序并去重后获取结果。
private static void method2() {
// 统计多个集合中的最大最小值，平均值，求和。降序排序并去重后获取结果。
List<Integer> list1 = Arrays.asList(1, 2, 4, 5, 6, 7, 8);
List<Integer> list2 = Arrays.asList(13, 15, 16, 17, 18, 20,5,6);
List<Integer> list3 = Arrays.asList(67, 45, 89, 55, 3,7,8);
// 将多个数据源合并到一个Stream流中
// Stream<Integer> stream = Stream.concat(list1.stream(), Stream.concat(list2.stream(), list3.stream()));
// 匿名内部类
// Stream<Object> stream = Stream.of(list1, list2, list3).flatMap(new Function<List<Integer>, Stream<?>>() {
// // 参数就是合并之后的集合
// @Override
// public Stream<?> apply(List<Integer> integers) {
// return integers.stream();
// }
// });
// lambda表达式
// Stream.of(list1,list2,list3).flatMap(integers -> integers.stream());
List<Integer> list = Stream.of(list1, list2, list3)
.flatMap(List::stream)
.distinct()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println(list);
// 匿名内部类方式
// list.stream().mapToInt(new ToIntFunction<Integer>() {
// @Override
// public int applyAsInt(Integer value) {
// return value.intValue();
// }
// });
// lambda表达式
// list.stream().mapToInt(v -> v.intValue());
// sum终止操作
int sum = list.stream().mapToInt(Integer::intValue).sum();
System.out.println("和是" + sum);
IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt(Integer::intValue).summaryStatistics();
// 平均值
System.out.println(intSummaryStatistics.getAverage());
// 求和
System.out.println(intSummaryStatistics.getSum());
// 最大值
System.out.println(intSummaryStatistics.getMax());
// 最小值
System.out.println(intSummaryStatistics.getMin());
// 长度
System.out.println(intSummaryStatistics.getCount());
}
- 统计集合中名称带m,分数>90的人,根据成绩进行降序排序，根据id升序排序
private static void method3() {
List<Student> students = Arrays.asList(
new Student(1, "tom", 97),
new Student(2, "jerry", 95),
new Student(3, "peiqi", 89),
new Student(4, "qiaozhi", 93),
new Student(5, "amianbaobao", 88),
new Student(6, "ggbrand", 100),
new Student(7, "mike", 99),
new Student(8, "mini", 97)
);
// 统计集合中名称带m,分数>90的人,根据成绩进行降序排序，根据id升序排序
// 传统方式实现
// List<Student> dataList = new ArrayList<>();
// for (Student student : students) {
// if (student.getName().contains("m") && student.getScore() > 90){
// dataList.add(student);
// }
// }
// System.out.println(dataList);
// dataList.sort(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getId));
// System.out.println(dataList);
// students.stream().filter(new Predicate<Student>() {
// // 对集合中的结果进行过滤
// // 返回true，就留在集合的流中
// // 返回false,就被过滤掉
// // 参数是集合中的元素
// @Override
// public boolean test(Student student) {
// return student.getScore() > 90;
// }
// }).filter(new Predicate<Student>() {
// @Override
// public boolean test(Student student) {
// return student.getName().contains("m");
// }
// });
// students.stream().filter(new Predicate<Student>() {
// // 对集合中的结果进行过滤
// // 返回true，就留在集合的流中
// // 返回false,就被过滤掉
// // 参数是集合中的元素
// @Override
// public boolean test(Student student) {
// return student.getScore() > 90 && student.getName().contains("m");
// }
// });
List<Student> list = students.stream()
.filter(student -> student.getScore() > 90 && student.getName().contains("m"))
.sorted(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getId))
.collect(Collectors.toList());
// lambda表达式
// List<Student> list = students.stream()
// .filter(student -> student.getScore() > 90)
// .filter(student -> student.getName().contains("m"))
// .sorted(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getId))
// .collect(Collectors.toList());
// list.forEach(System.out::println);
}
- 把集合中的学生名称全部转换成大写,获取名称中带M的
private static void method4() {
List<Student> students = Arrays.asList(
new Student(1, "toM", 97),
new Student(2, "jerry", 95),
new Student(3, "peiqi", 89),
new Student(4, "qiaozhi", 93),
new Student(5, "amianbaobao", 88),
new Student(6, "ggbrand", 100),
new Student(7, "mike", 99),
new Student(8, "mini", 97)
);
// 获取集合中所有的学生名称并且转换成大写,获取名称中带M的
// List<String> nameList = new ArrayList<>();
// 传统写法
// for (Student student : students) {
// nameList.add(student.getName().toUpperCase());
// }
// System.out.println(nameList);
// 泛型第一个表示参数的类型 第二个表示返回值类型
// 通过map方法，可以获取类的任意一个属性
// students.stream().map(new Function<Student, String>() {
// @Override
// public String apply(Student student) {
// return student.getName().toUpperCase();
// }
// });
// 最终写法
List<String> collect = students.stream()
.map(student -> student.getName().toUpperCase())
.filter(str -> str.contains("M"))
.collect(Collectors.toList());
System.out.println(collect);
}
- 把集合中的学生成绩减5分
private static void method5() {
List<Student> students = Arrays.asList(
new Student(1, "toM", 97),
new Student(2, "jerry", 95),
new Student(3, "peiqi", 89),
new Student(4, "qiaozhi", 93),
new Student(5, "amianbaobao", 88),
new Student(6, "ggbrand", 100),
new Student(7, "mike", 99),
new Student(8, "mini", 97)
);
// 把每个学生的成绩都减5分
// 匿名内部类
// students.stream().map(new Function<Student, Student>() {
// @Override
// public Student apply(Student student) {
// student.setScore(student.getScore() - 5);
// return student;
// }
// });
// 对类中属性执行相同行为的时候，可以使用map也可以使用peek ，建议使用peek
//lambda表达式
// List<Student> collect = students.stream().map(student -> {
// student.setScore(student.getScore() - 5);
// return student;
// }).collect(Collectors.toList());
// System.out.println(collect);
// students.stream().peek(new Consumer<Student>() {
// @Override
// public void accept(Student student) {
// student.setScore(student.getScore() - 5);
// }
// });
List<Student> collect = students.stream().peek(student -> student.setScore(student.getScore() - 5)).collect(Collectors.toList());
collect.forEach(System.out::println);
}