01、准备
为了学习方便创建的实体类
//实体类
public class Employee {
private Integer age;
private String name;
private Status status;
}
//状态枚举类
public enum Status{
LIZHI,
BUSY,
VOCATION
}
02、创建流
- collection系列集合提供的stream()方法 或paralleStream
- 通过Arrays 中的静态方法stream()
- Stream中的静态方法of()
//1、collection系列集合提供的stream()方法 或paralleStream
Stream<Employee> stream = emps.stream();
//2、通过Arrays 中的静态方法stream()
Employee[] emps1 = new Employee[10];
Stream<Employee> stream1 = Arrays.stream(emps1);
//3、Stream中的静态方法of()
Stream<String> stream2 = Stream.of("a", "b", "c");
03、操作流
1、筛选与切片
- filter:接收lamda,从流中排除一些元素
- limit:截断取出指定数量
- skip(n):跳过元素,返回一个扔掉前n个元素的流,若流中元素不足n则返回一个空流
- distinct:筛选,通过流所生成的元素的hashcode 和equals方法去除再重复元素
List<Employee> emps = Arrays.asList(
new Employee(27,"刘富强"),
new Employee(34,"刘民主"),
new Employee(23,"刘文明"),
new Employee(42,"刘和谐"),
new Employee(19,"刘自由"),
new Employee(24,"刘平等"),
new Employee(32,"刘公平"),
new Employee(28,"刘法治"),
new Employee(33,"刘爱国"),
new Employee(37,"刘敬业")
);
//1、filter 筛选30岁以上的员工
stream.filter(x -> x.getAge() > 30).forEach(System.out::println);
//打印结果:
Employee(age=34, name=刘民主, status=null)
Employee(age=42, name=刘和谐, status=null)
Employee(age=32, name=刘公平, status=null)
Employee(age=33, name=刘爱国, status=null)
Employee(age=37, name=刘敬业, status=null)
<======================================================>
//2、filter 筛选30岁以上的员工 取出前三个
stream.filter(x -> x.getAge() > 30).limit(3).forEach(System.out::println);
//打印结果:
Employee(age=34, name=刘民主, status=null)
Employee(age=42, name=刘和谐, status=null)
Employee(age=32, name=刘公平, status=null)
<=====================================================>
//3、filter 筛选30岁以上的员工 跳过前四个
stream.filter(x -> x.getAge() > 30).skip(4).forEach(System.out::println);
//打印结果:
Employee(age=37, name=刘敬业, status=null)
distinct是去重操作,于是我将Employee(37,“刘敬业”)多添加了三条记录
List<Employee> emps = Arrays.asList(
new Employee(32,"刘公平"),
new Employee(28,"刘法治"),
new Employee(33,"刘爱国"),
new Employee(37,"刘敬业"),
new Employee(37,"刘敬业"),
new Employee(37,"刘敬业")
);
stream.filter(x -> x.getAge() > 30).distinct().forEach(System.out::println);
//打印结果:去除了重复的记录
Employee(age=32, name=刘公平, status=null)
Employee(age=33, name=刘爱国, status=null)
Employee(age=37, name=刘敬业, status=null)
2、映射
- map(Function f) :接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
- flatMap(Function f) :接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有的流连接成一个流
List<String> emps = Arrays.asList("aa","bb","cc","dd","ee","ff");
Stream<String> stream = emps.stream();
//将字符转换成待大写
stream.map(String::toUpperCase).forEach(System.out::println);
//打印结果:
AA
BB
CC
DD
EE
FF
现在有这样的一种情况,此时stream1是一个包含着Stream流的一个流,,此时steam1类似{{a,a},{b,b},{c,c},{d,d},{e,e},{f,f}}。但是使用flatMap就类似于{a,a,b,b,c,c,d,d,e,e,f,f}
List<String> emps = Arrays.asList("aa","bb","cc","dd","ee","ff");
Stream<String> stream = emps.stream();
//steam流经过映射后返回steam1
Stream<Stream<Character>> stream1 = stream.map((x) -> filterCharacter(x));
//打印stream1:是这样样式
java.util.stream.ReferencePipeline$Head@15f8701f
java.util.stream.ReferencePipeline$Head@514cd540
......
<=========================================================>
Stream<Character> characterStream = stream.flatMap(x -> filterCharacter(x));
//返回一个stream<Character>
public Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>();
for (char c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
3、排序
- sorted():自然排序
- sorted(Comparator com):定制排序
//自然排序
List<String> list = Arrays.asList("bb","aa","ee","jj","cc","dd");
Stream<String> stream = list.stream();
stream.sorted().forEach(System.out::println);
//打印结果:
aa bb cc dd ee jj
对employee进行定制排序
List<Employee> emps = Arrays.asList(
new Employee(27,"刘富贵"),
new Employee(34,"刘生产"),
new Employee(23,"刘团结"),
new Employee(23,"刘向前"),
new Employee(19,"刘复兴")
);
Stream<Employee> stream1 = emps.stream();
stream1.sorted((x,y) -> {
if(x.getAge().equals(y.getAge())){
return x.getName().compareTo(y.getName());
}
return Integer.compare(x.getAge(),y.getAge());
}).forEach(System.out::println);
4、查找与匹配
- allMatch :检查是否匹配所有元素,不全部匹配返回false
- anyMatch :检查是否至少匹配一个元素
- noneMatch :检查是否没有匹配所有元素
- findFirst :返回第一个元素
- findAny :返回当前流中的任意元素
- count :返回流中的元素总个数
- max :返回流中的最大值
- min :返回流中的最小值
List<Employee> emps = Arrays.asList(
new Employee(27,"刘富贵", Status.ZAIZHI),
new Employee(34,"刘生产",Status.BUSY),
new Employee(23,"刘团结",Status.LIZHI),
new Employee(23,"刘向前",Status.VOCATION),
new Employee(19,"刘复兴",Status.ZAIZHI)
);
Stream<Employee> stream = emps.stream();
boolean b = stream.allMatch(x -> x.getStatus().equals(Status.LIZHI));
System.out.println(b); //false
boolean c = stream.anyMatch(x -> x.getStatus().equals(Status.LIZHI));
System.out.println(c);//true
boolean b = stream.noneMatch(x -> x.getStatus().equals(Status.LIZHI));
System.out.println(b);//false
Optional<Employee> first = stream.findFirst();
System.out.println(first);
Optional<Employee> max = stream.max((x, y) -> x.getAge().compareTo(y.getAge()));
System.out.println(max);
5、归约,转换
- reduce:将流中的元素结合起来,得到一个值
- collect:收集将流转换为其他的形式,接受一个collector的接口的实现,用于Stream中做元素汇总的方法
reduce使用有两种形式,一种存在起始值,返回Interger类型,第二种无起始值,返回Optional类型
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Stream<Integer> stream = list.stream();
Integer reduce = stream.reduce(0, (x, y) -> x + y);
Optional<Integer> reduce1 = stream.reduce((x, y) -> x + y);
在collect()中传入Collector接口的实现,这个实现类可以使用Collectors提供的静态方法得到。
List<Employee> emps = Arrays.asList(
new Employee(27,"刘富贵", Status.ZAIZHI),
new Employee(34,"刘生产",Status.BUSY),
new Employee(23,"刘团结",Status.LIZHI),
new Employee(23,"刘向前",Status.VOCATION),
new Employee(19,"刘复兴",Status.ZAIZHI)
);
Stream<Employee> stream = emps.stream();
List<String> nameList = stream.map(x -> x.getName()).collect(Collectors.toList());
System.out.println(nameList);