六、Stream流
1、 什么是stream流
现阶段，可以把stream流看成一个高级版的Iterator。普通的Iterator只能实现遍历，遍历做什么，就需要具体些功能代码函数了。而这个stream可以实现一些遍历常见的功能（例如：非空、求最大值、遍历打印等）
2、 效率高吗？
采用lazy模式（懒处理模式），所有操作最后一起执行，在一次循环中结束。
3、 创建stream流
1） list集合
list对象.stream()即可
2） 数组
Arrays.stream(数组对象)
或者
Stream.of(数组对象)
4、 常见的方法
例如：
package com.lennar.jdk8learn.learn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class LeanStream {
@Test
public void test1() {
List<String> list
= new ArrayList<>();
String[] strings = new String[10];
for (int i = 0; i < 10; i++) {
list.add(String.valueOf(i));
strings[i]
= String.valueOf(i);
}
//创建流stream
Stream listStream
= list.stream();
Stream arrayStream
= Arrays.stream(strings);
Stream arrayStream2
= Stream.of(strings);
//forEach遍历方法
listStream.forEach(System.out::println);
System.out.println("---------------");
arrayStream.forEach(System.out::println);
System.out.println("---------------");
arrayStream2.forEach(System.out::println);
System.out.println("---------------");
}
@Test
public void test2() {
Student student1 = new Student("1", "张三", "唐山");
Student student2 = new Student("2", "李四", "唐山");
Student student3 = new Student("3", "王五", "北京");
Student student4 = new Student("4", "赵六", "杭州");
List<Student> list
= new ArrayList<>();
list.add(student1);
list.add(student1);
list.add(student2);
list.add(student3);
list.add(student4);
//collect方法：将Steam流转换成list、set、map
List<Student> newList
= list.stream().collect(Collectors.toList());
System.out.println(newList);
Set<Student> set = list.stream().collect(Collectors.toSet());//去重
System.out.println(set);
//Collectors.toMap(获取key的方法，获取value的方法，key相同时的方法)
Map<String, Student> map = list.stream().collect(Collectors.toMap(Student::getName, student -> student, (k1, k2) -> k1));//name作key，student对象作value，键相同则取前者。
System.out.println(map);
Map<String, Student> map2 = list.stream().collect(Collectors.toMap(Student::getId, student -> student, (k1, k2) -> k1));
System.out.println(map2);
Map<String, Student> map3 = list.stream().collect(Collectors.toMap(Student::getAddress, student ->
student, (k1, k2)
-> k2));
System.out.println(map3);
//Collectors.groupingBy(获取分组key的方法)
Map<String, List<Student>>
groupMap = list.stream().collect(Collectors.groupingBy(Student::getId));
System.out.println(groupMap);
Map<String, List<Student>>
groupMap2 = list.stream().collect(Collectors.groupingBy(Student::getName));
System.out.println(groupMap2);
Map<String, List<Student>>
groupMap3 = list.stream().collect(Collectors.groupingBy(Student::getAddress));
System.out.println(groupMap3);
//最大max(里面本质就是一个Comparator的方法)、最小min(里面本质就是一个Comparator的方法)
//Comparator.comparing(获取要比较的属性的方法)
Optional<Student> minStudentOptional = list.stream().min(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return -o1.getId().compareTo(o2.getId());
}
});
Student minStudent = minStudentOptional.get();
System.out.println("min:" + minStudent);
Optional<Student> maxStudentOptional = list.stream().max(Comparator.comparing(Student::getId));
Student maxStudent = maxStudentOptional.get();
System.out.println(maxStudent);
//排序sorted(里面本质就是一个Comparator的方法)
List<Student> students
= list.stream().sorted(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return -o1.getId().compareTo(o2.getId());
}
}).collect(Collectors.toList());
System.out.println(students);
List<Student> students2
= list.stream().sorted(Comparator.comparing(Student::getId)).collect(Collectors.toList());
System.out.println(students2);
//过滤filter(里边返回一个boolean类型数据就行)
List<Student> filterList
= list.stream().filter(student
-> {
boolean flag = false;
if (!student.getAddress().equals("唐山")) {
flag = true;
} else {
if (!student.getId().equals("1")) {
flag = true;
}
}
return flag;
}).collect(Collectors.toList());
System.out.println(filterList);
//limit(n)，仅仅研究前n个
List<Student> limitList
= list.stream().limit(2).collect(Collectors.toList());
System.out.println(limitList);
//skip(n),跳过前n个
List<Student> skipList
= list.stream().skip(2).collect(Collectors.toList());
System.out.println(skipList);
//distict()，去重
List<Student> distinctList
= list.stream().distinct().collect(Collectors.toList());
System.out.println(distinctList);
//map(把原内容变成新内容的方法)
List<String> nameList
= list.stream().map(student
-> student.getName()).collect(Collectors.toList());
System.out.println(nameList);
//allMatch(匹配方法lambda表达式)，都匹配返回true；对每一个元素判断，最后取交集
Boolean f1 = list.stream().allMatch(student
-> {
boolean flag = false;
if (null == student.getName()) {
flag = true;
}
return flag;
});
System.out.println(f1);
//anyMatch(匹配方法lambda表达式)，有元素匹配返回true；对每一个元素判断，最后取交集
boolean f2 = list.stream().anyMatch(student
-> {
boolean flag = false;
if ("张三".equals(student.getName())) {
flag = true;
}
return flag;
});
System.out.println(f2);
//noneMatch(匹配方法lambda表达式)，都不匹配返回true；对每一个元素判断，最后取交集
boolean f3 = list.stream().noneMatch(student
-> {
boolean flag = false;
if ("唐山".equals(student.getAddress())) {
flag = true;
}
return flag;
});
System.out.println(f3);
}
@Test
public void test3() {
List<Integer> list
= new ArrayList<>();
for (int i = 1; i <= 100; i++) {
list.add(i);
}
IntSummaryStatistics collect = list.stream().collect(Collectors.summarizingInt(value -> value));
System.out.println(collect.getSum());
System.out.println(collect.getMax());
System.out.println(collect.getMin());
System.out.println(collect.getAverage());
System.out.println(collect.getCount());
List<Double> list2
= new ArrayList<>();
for (int i = 1; i <= 100; i++) {
list2.add((double) i);
}
DoubleSummaryStatistics collect2 = list2.stream().collect(Collectors.summarizingDouble(value -> value));
System.out.println(collect2.getSum());
System.out.println(collect2.getMax());
System.out.println(collect2.getMin());
System.out.println(collect2.getAverage());
System.out.println(collect2.getCount());
}
}
@Data
@NoArgsConstructor
@AllArgsConstructor
class Student {
private String id;
private String name;
private String address;
}