流的转换操作

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

中间操作符

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

• flatMap可以将A转化为多个B

• limli限流操作

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

• peek跳出操作

• skip跳过操作

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

终止操作

• collection收集操作，使用官方提供的Collections提供的收集器

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

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

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

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

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

• forEach遍历操作

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

filter方法

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

List<Integer> list = new ArrayList<Integer>();
list.add(15);
list.add(32);
list.add(5);
list.add(232);
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<Integer>();
list.add(15);
list.add(32);
list.add(5);
list.add(232);
List<String> result = list.stream().map(i -> String.valueOf(i)).filter(i -> i.length() > 2)
                .collect(Collectors.toList());
System.out.println(result);

flatMap方法

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

List<Integer> list1 = new ArrayList<>();
list1.add(15);
list1.add(10);
list1.add(20);
list1.add(33);
List<Integer> list2 = new ArrayList<>();
list1.add(1100);
list1.add(1200);
list1.add(1300);
​
Map<String, List<Integer>> testMap = new HashMap<>();
testMap.put("aa", list1);
testMap.put("ss", list2);
​
//testMap.values()获取到两个Collection<List<Integer>>
List<Integer> result = testMap.values().stream().flatMap(num ->                     num.stream()).collect(Collectors.toList());
System.out.println(result);

limlit方法

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

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

skip方法

跳过多少个元素，继续后续处理

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

distinct方法

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

List<Integer> list = new ArrayList<Integer>();
list.add(10);
list.add(25);
list.add(10);
list.add(9);
list.add(25);
​
List<Integer> result = list.stream().distinct().collect(Collectors.toList());
System.out.println(result);

sorted方法

遍历整个流的所有数据，并且在产生任何数据元素之前进行排序，注意Comparable和Comparatoe接口

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

聚合操作

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

min和max用于获取最下值和最大值，主意啊compareto接口

count用于统计元素个数

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

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

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

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

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

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

List<Integer> list = new ArraysList<>();
    list.add(10);
    list.add(25);
    list.add(10);
    list.add(9);
    list.add(25);
Integer res = list.parallelstream().filter(i->i > 20).findAny().get();

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

List<Integer> list = new ArraysList<>();
    list.add(10);
    list.add(25);
    list.add(10);
    list.add(9);
    list.add(25);
boolean res = list.parallelstream().anyMatch(i->i > 100);

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