Java学习--JDK1.8新特性Stream

一、Stream流的概述

Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

流的生成（创建Stream）：
a.用集合生成
List.stream()
b. 根据数字
IntStream.of(1,2,3,4);
c.把数组变成流
Arrays.stream(数组);
d.把文件中的每一行读取出来作为流元素

Files.lines(Paths.get("1.txt")).forEach( s -> System.out.println(s) );

e.使用生产者接口
Stream.generate(生产者接口)
生成5个随机数

Random r = new Random();
Stream.generate( () -> r.nextInt(100) ).limit(5).forEach( x->System.out.println(x));

二、七个重要接口

1. Predicate 断言接口
   对应的lambda 一个参数，返回结果是boolean
   (a) -> { return true|false; }
2. Function 函数接口
   对应的lambda 一个参数，一个返回结果，参数和返回结果的类型可以不一样
3. BiPredicate 双参数断言
   对应的lambda 两个参数，返回结果是boolean
   (a, b) -> { return true|false; }
4. BiFunction 双参数函数接口
   两个参数，一个结果
   (a, b) -> { 根据ab返回一个结果}
5. Consumer 消费接口
   一个参数 没有结果
   (a) -> { 不需要return }
6. BiConsumer 双参数消费接口
   两个参数，没有结果
7. Supplier 生产者接口
   没有参数，返回一个结果
   () -> {return 结果}

三、Stream API
1.filter ():
进行过滤的，lambda返回true会留下，lambda返回为false的过滤掉

    // 过滤方法
     Stream<Integer> stream2 = stream1.filter(i -> i % 2 == 0); // 2， 4

2.map ()：接收一个方法作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
映射的, lambda把原有的元素转换为另一个元素， 不会改变个数

   // 各个元素*2, 映射 2-> 2*2 ， 4-> 4*2
    Stream<Integer> stream3 = stream2.map((i) -> i * 2); // 4, 8

3.flatMap ()：对每个元素执行mapper指定的操作，并用所有mapper返回的Stream中的元素组成一个新的Stream作为最终返回结果，通俗易懂就是将原来的stream中的所有元素都展开组成一个新的stream
扁平化映射

       List<String[]> list = new ArrayList<>();
        list.add(new String[]{"张三", "李四"});
        list.add(new String[]{"王五", "张三"});
        list.add(new String[]{"钱七", "周八"});
        //   字符串数组 变为 流
        List<String> list3 = list.stream().flatMap(strings -> stream(strings)).collect(toList());
        System.out.println(list3);

4.forEach ()
遍历流，接收一个Consumer

        // 遍历
        list3.stream().forEach((a) -> {
            System.out.println(a);
        });

map集合的遍历

      // map的遍历
        Map<String, String> map = new HashMap<>();
        map.put("a", "张");
        map.put("b", "李");
        map.forEach((key, value) -> {
            System.out.println("key:" + key + " value:" + value);
        });

5.sorted() ：使用该方法排序数据
6.limit():使用该方法截断

//排序＋截断（3）
list.stream().sorted((h1, h2) -> h2.getPower() -h1.getPower()).limit(3).forEach(h -> System.out.println(h.getName()));

7.distinct()：使用该方法去重

//去除重复
System.out.println(list3.stream().distinct().collect(toList()));

8.count ,max，min，avg, sum

        // 求个数
        System.out.println(list3.stream().count());
        // 如果是数字流
        System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).max());
        System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).min());
        System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).average());
        System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).sum());

9.findFirst() ：使用该方法获取第一个元素
10.分组 groupingBy()

List<Student> students = Arrays.asList(
        new Student("zhang", "男", "西安"),
        new Student("li", "男", "西安"),
        new Student("wang", "女", "北京"),
        new Student("zhao", "女", "上海"),
        new Student("zhou", "男", "北京")
);

// 按性别分组
Map<String, List<Student>> map3 = students.stream().collect(Collectors.groupingBy((s) -> s.getSex() ));
System.out.println(map3);
// 按城市分组
Map<String, List<Student>> map4 = students.stream().collect(Collectors.groupingBy((s) -> s.getCity()));
System.out.println(map4);

11.方法引用(了解)
对lambda表达式的扩展
第一种： 对象::方法名
例子: System.out::println

第二种： 类名::静态方法名

class ABC {
    public static boolean aaa(Integer x ) {
        // 代码多
        return x % 2 == 0;
    }
}

可以使用： ABC::aaa

第三种： 类名::new
可以取代 Supplier接口的lambda
例如 () -> new Student()
可以替换为: Student::new

Stream api中有一个重要思想：
1.Pipeline 流水线思想：把流中的数据一个接一个进行处理。每个数据会经过后续的filter， map等方法依次调用。

2.在整个执行过程中，lambda表达式是懒惰的，不执行终结方法的话，不会触发lambda的执行。
终结方法： collect， sum， max， min …
这样可以减少迭代次数，计算完成之后stream就会失效。

3.运算过程中不会改变原始集合，收集器会生成新的集合对象