Stream（2）（Java学习回顾）

流的转换操作

Stream的操作符基本可以分为中间操作符和终止操作符两大类，中间操作符会继续向下传递，终止操作符直接对数据进行消费或者收集，不会继续向下传递

中间操作符

• map转换操作符，可以将一个A转换为一个B

• flatMap可以将一个A转换为多个B

• limit限流操作

• distinct去重操作，底层采用equals进行比对

• filter过滤操作，去除不满足条件的数据

• peek跳出操作

• skip跳过操作

• sorted排序操作，Comparable和Comparator接口

终止操作

• collect收集操作，使用官方的Collectors提供的收集器

• count统计操作，统计数据个数

• findFirst/findAny查找操作，返回的类型为Optional

• noneMatch、AllMatch和anyMatch匹配操作，检查数据流中是否存在符合条件的数据

• min和max最值操作，需要比较器

• reduce规约操作，将数据流的值规约为一个值，例如count/min/max底层实际上就是使用reduce

• forEach遍历操作，可以对最终的数据进行消费

• toArray数组操作，用于将数据流的元素转换为数组

filter方法

filter方法用于对传入的数据流进行过滤处理，只返回满足条件的数据组成的新的数据流

List<Integer> list = new ArrayList<>(); 
list.add(15); 
list.add(32); 
list.add(5); 
list.add(232); 
System.out.println(list); 
List<Integer> result = list.stream().filter(i -> i > 50).collect(Collectors.toList()); 
System.out.println(result);

map方法

map方法用于对流中的数据进行某种形式的转换，转换操作函数当作参数传入方法

例如将Integer转换为String

List<Integer> list = new ArrayList<>(); 
list.add(15); 
list.add(32); 
list.add(5); 
list.add(232); 
List<String> result=list.stream().map(i->String.valueOf(i)) .collect(Collectors.toList()); 
List<String> result = list.stream().map(i -> String.valueOf(i)) .filter(bb->bb.length()>2).collect(Collectors.toList());

flatMap方法

flatMap可以对每个元素应用一个函数，并将返回的值收集到一个新的流中

List<Integer> list1=new ArrayList<>(); 
list1.add(34); 
list1.add(25); 
list1.add(35); 

List<Integer> list2=new ArrayList<>(); 
list2.add(999); 
list2.add(888); 
list2.add(999); 
list2.add(666); 

Map<String,List<Integer>> testMap=new HashMap<>(); 
testMap.put("aa",list1); 
testMap.put("bb",list2); 
List<Integer> result=testMap.values() //获取到两个Collection<List<Integer>>
    .stream().flatMap(num->num.stream()).collect(Collectors.toList());

limit方法

limit方法会返回一个包含指定个数元素的新stream，如果原始数据总长大小不足则返回原始流

List<Integer> list=new ArrayList<>(); 
for(int i=0;i<10;i++) 
    list.add(i); 
List<Integer> result=list.stream().limit(5).collect(Collectors.toList());

distinct方法

distinct会根据原始流中的元素返回一个具有相同顺序，但是剔除了重复值的流

List<Integer> list=new ArrayList<>(); 
list.add(10);
list.add(39);
list.add(10);
list.add(78);
list.add(39); 
list.stream().forEach(obj -> System.out.print(obj + "\t")); 
System.out.println(""); 
List<Integer> result=list.stream().distinct().collect(Collectors.toList()); 
System.out.println(result);

sorted方法

sorted方法是遍历整个流的所有数据，并且在产生任何数据元素之前对它进行排序。注意Comparable接口和Comparator接口

List<Integer> list=new ArrayList<>(); 
list.add(10);
list.add(39);
list.add(10);
list.add(78);
list.add(39); 
List<Integer> result=list.stream() .sorted(Integer::compareTo) //指定比较器，表示调用Integer类中的compareTo方法 
    .collect(Collectors.toList()); 
Random r=new Random(); 
r.ints().limit(10).sorted().forEach(System.out::println);

聚合操作

将流中的数据进行汇聚为一个值，一般都是终止操作

min和max用于获取最小值和最大值，注意Comparator接口

count用于统计元素个数

List<Integer> list = new ArrayList<>(); 
list.add(10); 
list.add(39); 
list.add(10); 
list.add(78); 
list.add(39); 
Integer maxValue = list.stream().max(Integer::compareTo).get(); 
System.out.println(maxValue); 
long len=list.stream().count(); 
System.out.println(len);

利用收集器Collectors实现的聚合操作

List<Integer> list = new ArrayList<>(); 
list.add(10); 
list.add(39); 
list.add(10); 
list.add(78); 
list.add(39); 
//总和、平均值、最大值、最小值 
// 针对int类型的数据进行累加操作，会使用参数lambda表达式将元素转换为int类型 
long sum = list.stream().collect(Collectors.summarizingInt(Integer::intValue)).getSum();
System.out.println(sum); 
// 求平均值 
Double avg = list.stream().collect(Collectors.averagingInt(Integer::intValue)); 
System.out.println(avg); 
//求最大值 
Integer maxValue=list.stream().collect(Collectors.maxBy(Integer::compare)).get(); 
Integer min=list.stream().collect(Collectors.minBy(Integer::compareTo)).get(); 
System.out.println("max:"+maxValue+",min:"+min);

Collectors类实现了很多的聚合操作，例如将流转换为集合或者聚合元素，Collector可以返回列表List或者字符串

List<String> list1=Arrays.asList("abc","","bcd","","efg","abcd","jklm"); 
List<String> list2=list1.stream().filter(str->!str.isEmpty())//剔除空字符串 
    .collect(Collectors.toList()); 
String result = list1.stream().filter(str -> !str.isEmpty()) 
    .collect(Collectors.joining(","));

查找元素

findFirst返回非空集合中的第一个元素值，一般会与filter方法结合使用

List<Integer> list = new ArrayList<>(); 
list.add(10); 
list.add(39); 
list.add(10); 
list.add(78); 
list.add(39); 
Optional<Integer> op = list.stream().filter(i -> i > 20).findFirst(); 
if(op.isPresent()) 
    System.out.println(op.get()); 
else
    System.out.println("没有数据");

findAny可以在stream中找到任意一个所匹配的元素就直接返回，在流的平行处理十分有效

List<Integer> list = new ArrayList<>(); 
list.add(10); 
list.add(39); 
list.add(10); 
list.add(78); 
list.add(39); 
Integer any=list.parallelStream().filter(i->i>20).findAny().get();

anyMathch判定是否还有匹配的元素，返回一个boolean值

List<Integer> list = new ArrayList<>(); 
list.add(10); 
list.add(39); 
list.add(10); 
list.add(78); 
list.add(39); 
boolean res=list.parallelStream().anyMatch(i->i>100);

类似的方法allMatch和noneMatch分别是判断所有元素都满足条件或者没有元素满足条件返回true，否则false。这些方法都是用来检查整个流，所以可以通过使用并行流提高速度