JDK1.8新特性之Stream API

Stream API 从1.8引入的api  ,  都和集合有关

一. 问题引入

List<Integer> list = Arrays.asList(1,2,3,4,5);
写一个方法找偶数，返回一个新的list包含结果

(1) 旧的实现：

// 设计模式中，策略模式
public static List<Integer> exec(List<Integer> list, Predicate<Integer> predicate) {
    List<Integer> list2 = new ArrayList<>();
    // 遍历原始集合
    for(Integer i :list) {
        if(predicate.test(i)) {
            list2.add(i);
        }
    }
    return list2;
}

 

调用时采用

List<Integer> list = Arrays.asList(1,2,3,4,5);
System.out.println(exec(list, new Predicate<Integer>(){
    @Override
    public boolean test(Integer i) {
        return i % 2 == 0;
    }
}));

 

(2) 采用lambda改进

// 返回一个经过了筛选后的新集合 , 其中筛选规则是 i ->  i % 2 == 0
System.out.println(exec(list, i ->  i % 2 == 0));

(3) 采用stream api改进,更加简洁，原来的exec方法也不需要了

list.filter(i ->  i % 2 == 0).collect(Collectors.toList());

二.重要接口

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的过滤掉
2. map 
映射的, lambda把原有的元素转换为另一个元素， 不会改变个数

举例:

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream1 = list.stream();

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

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

        //  一个参数， 有一个结果

        // 收集结果
        List<Integer> list2 = stream3.collect(Collectors.toList());
        System.out.println(list2);//[4, 8]

3. flatMap 
扁平化映射

举例:

首先有一个集合,存放的是字符串数组

        List<String[]> list = new ArrayList<>();
        list.add(new String[]{"张三", "李四"});
        list.add(new String[]{"王五", "张三"});
        list.add(new String[]{"钱七", "周八"});

扁平化映射

  List<String> list2 = list.stream().flatMap(strings -> stream(strings)).collect(toList());
        System.out.println(list2);//[张三, 李四, 王五, 张三, 钱七, 周八]

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

list.stream().forEach((a) -> {
            System.out.println(a);
        });

5. map的流遍历
接收一个BiConsumer

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

6. 其它常见api
求个数

 System.out.println(list.stream().count());

去除重复

System.out.println(list.stream().distinct().collect(toList()));

获取最大最小值

// 返回的是Optional 类型，怕集合为空时，没有合法的最大值
List<String> list4 = Arrays.asList("zhang", "li", "zhao", "wang");       
System.out.println(list4.stream().max((a, b) -> a.compareTo(b)));
System.out.println(list4.stream().min((a, b) -> a.compareTo(b)));

如果是数字流，除了最大最小值外，还有平均值，和求和

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());

7. 分组

举例:

有一个list集合,存放的是学生对象

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);
/**
运行结果:
{女=[Student{name='wang', sex='女', city='北京'}, Student{name='zhao', sex='女', city='上海'}], 
 男=[Student{name='zhang', sex='男', city='西安'}, Student{name='li', sex='男', city='西安'}, Student{name='zhou', sex='男', city='北京'}]}
*/

按城市分组
 

Map<String, List<Student>> map4 = students.stream().collect(Collectors.groupingBy((s) -> s.getCity()));
        System.out.println(map4);
/**
运行结果:
{上海=[Student{name='zhao', sex='女', city='上海'}], 
 西安=[Student{name='zhang', sex='男', city='西安'}, Student{name='li', sex='男', city='西安'}], 
 北京=[Student{name='wang', sex='女', city='北京'}, Student{name='zhou', sex='男', city='北京'}]}
*/

8. 流的生成
(1) 用集合生成
List.stream()
(2) 根据数字
IntStream.of(1,2,3,4);
(3) 把数组变成流
Arrays.stream(数组);

(4) 把文件中的每一行读取出来作为流元素

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

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

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

9. 方法引用(了解)
对lambda表达式的扩展
第一种： 对象::方法名

 Stream.generate( () -> r.nextInt(100) ).limit(5).forEach( x->System.out.println(x) ); // 一个参数，没有结果
 Stream.generate( () -> r.nextInt(100) ).limit(5).forEach( System.out::println ); // 一个参数，没有结果

 

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

举例:有一个类ABC

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

可以使用：  ABC::aaa

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

四.Stream api中有一个重要思想:Pipeline 流水线思想

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

在整个执行过程中，lambda表达式是懒惰的，不执行终结方法的话，不会触发lambda的执行。
终结方法：  collect， sum， max， min ..

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