lambda表达式二之Stream流

Stream流
是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。

集合讲的是数据，流讲的是计算

• Stream自己不会存储元素
• Stream不会改变源对象，会返回一个持有结果的新Stream。
• Stream操作是延迟执行的，意味着会等待需要结果的时候才执行。

操作步骤

一、创建Stream

一个数据源，获取一个流
1.可以通过Collection系列集合提供的stream()或者parallelStream()
2.通过Arrays中静态方法stream()获取数组流
3.通过Stream类中的静态方法of()
4.创建无限流，迭代 Stream.iterate()或者生成 Stream.generate()

二、中间操作

一个中间操作链，对数据源的数据进行处理

1. 筛选与切片
   

public class StreamTest {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("22");
        list.add("333");
        list.add("55555");
        list.add("55555");
        list.add("6666666");
        list.stream().skip(3)
                .filter(x -> x.length() > 2)
                .limit(2)
                .distinct()
                .forEach(System.out::println);
    }

输出为55555
2. 映射

public class StreamTest {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("bb");
        ArrayList<String> listA = new ArrayList<>();
        listA.add("111");
        list.stream().map(x->x.toUpperCase())
                .forEach(System.out::println);
        listA.stream().mapToInt(x->Integer.valueOf(x))
                .forEach(System.out::println);
    }
}

1. 排序
   

public class StreamTest {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("ccc");
        list.add("dddd");
        list.add("aa");
        list.add("bbb");
        list.add("ccc");
        //compare
        list.stream().sorted()
                .forEach(System.out::println);
        //comparator
        List<String> collect = list.stream().sorted((x, y) -> {
            if (x.length() > y.length())
                return 1;
            return 0;
        }).collect(Collectors.toList());
        System.out.println(collect);

    }
}

三、终止操作
执行中间操作链，并产生结果。
其结果可以是任何不是流的值。

• allMatch：检查是否匹配所有元素
• anyMatch：检查是否至少匹配一个元素
• noneMatch：检查是否没有匹配所有元素
• findFirst：返回第一个元素
• findAny：返回当前流中的任意元素
• count：返回流中元素的总个数
• max：返回流中最大值
• min：返回流中最小值

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("eee");
        list.add("ccc");
        list.add("dddd");
        list.add("aa");
        list.add("bbb");
        list.add("ddd");

        //allMatch
        boolean a = list.stream().filter(x -> x.length() > 2)
                .allMatch(x -> x.equals("ccc"));
        System.out.println(a);

        //findFirst
        String b = list.stream().filter(x -> x.length() > 2)
                .findFirst().get();
        System.out.println(b);

        //findFirst
        String c = list.stream().filter(x -> x.length() > 2)
                .findAny().get();
        System.out.println(c);

        //max
        String max = list.stream().filter(x -> x.length() > 2)
                .max((x,y) ->Integer.compare(x.length(),y.length())).get();
        System.out.println(max);
    }

归约

可以将流中的元素反复结合起来，得到一个值

//第一个参数为起始值
 reduce(T identity,BinaryOperator)   
 或 reduce(BinrayOperator)

        //int类型
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        Integer reduce = integers.stream().reduce(0, (x, y) -> x + y);
        System.out.println(reduce);
        //String类型
        List<String> strings = Arrays.asList("a", "bb", "cc", "dd");
        strings.stream().reduce(String::concat);

收集

将流转换成其他形式，接收一个Collector接口实现
用于给Stream中元素做汇总的方法

public class StreamTest2 {

   List<Employee> emps = Arrays.asList(
           new Employee(1, "一一", 18),
           new Employee(2, "二二", 28),
           new Employee(3, "三三", 38),
           new Employee(4, "司司", 48),
           new Employee(5, "五五", 48),
           new Employee(6, "溜溜", 58)
   );


   /**
    * 收集
    * collect -- 将流转换成其他形式，接收一个Collector接口实现，
    * 用于给Stream中元素做汇总的方法
    **/
   public void test1() {
       List<String> list = emps.stream()
               .map(x -> x.getMame())
               .collect(Collectors.toList());
       list.forEach(System.out::println);

       System.out.println("---------------------");

       Set<String> set = emps.stream()
               .map(x -> x.getMame())
               .collect(Collectors.toSet());
       set.forEach(System.out::println);

       HashSet hs = emps.stream()
               .map(x -> x.getMame())
               .collect(Collectors.toCollection(HashSet::new));
       hs.forEach(System.out::println);


       //总数
       Long count = emps.stream()
               .collect(Collectors.counting());
       System.out.println(count);

       //平均值
       Double avg = emps.stream()
               .collect(Collectors.averagingInt(Employee::getAge));
       System.out.println(avg);

       //总和
       Integer num = emps.stream()
               .collect(Collectors.summingInt(Employee::getAge));
       System.out.println(num);

       //最大
       Optional<Employee> op = emps.stream()
               .collect(Collectors.maxBy(
                       (e1,e2) ->Integer.compare(e1.getAge(), e2.getAge())));
       System.out.println(op.get());


       //分区
       Map<Boolean, List<Employee>> map3 = emps.stream()
               .collect(Collectors.partitioningBy((e) -> e.getAge() > 40));
       System.out.println(map3);

       //统计
       DoubleSummaryStatistics dss = emps.stream()
               .collect(Collectors.summarizingDouble(Employee::getAge));
       System.out.println(dss.getSum());
       System.out.println(dss.getAverage());
       System.out.println(dss.getMax());

       //连接
       String str = emps.stream()
               .map(x->x.getMame())
               //.collect(Collectors.joining(""));//只是拼接收到字符什么都不加
               //.collect(Collectors.joining(","));//每个名字中间增加一个逗号
               .collect(Collectors.joining(",", "----", "===="));//字符串首尾加特殊字符
       System.out.println(str);
   }
}