2020-06-27

java8 Stream流

1、什么是流
流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达而不是临时编写一个实现），此外流还可以透明的并行处理。
下面来看一个例子：

public class Dish {

    private String name;
    private boolean vegetarian;//蔬菜
    private int calories;//卡路里
    private Type type;

    public Dish(String name, boolean vegetarian, int calories, Type type) {
        this.name = name;
        this.vegetarian = vegetarian;
        this.calories = calories;
        this.type = type;
    }
   public boolean isVegetarian() { 
      return vegetarian; 
   }
     .......

    public enum Type {MEAT, FISH, OTHER}
}

List<Dish> menu = Arrays.asList(
                new Dish("猪肉", false, 800, Dish.Type.MEAT),
                new Dish("牛肉", false, 700, Dish.Type.MEAT),
                new Dish("鸡肉", false, 400, Dish.Type.MEAT),
                new Dish("炸薯条", true, 530, Dish.Type.OTHER),
                new Dish("米饭", true, 350, Dish.Type.OTHER),
                new Dish("水果", true, 120, Dish.Type.OTHER),
                new Dish("披萨", true, 550, Dish.Type.OTHER),
                new Dish("大虾", false, 300, Dish.Type.FISH),
                new Dish("鱼肉", false, 450, Dish.Type.FISH) );


List<Dish> lowCaloricDishes = new ArrayList<>();//将卡路里低于400的菜品放入集合
        for(Dish d: menu){
            if(d.getCalories() < 400){
                lowCaloricDishes.add(d);
            }
        }
        Collections.sort(lowCaloricDishes, new Comparator<Dish>() {//按卡路里高低排序
            public int compare(Dish d1, Dish d2){
                return Integer.compare(d1.getCalories(), d2.getCalories());
            }
        });
        List<String> lowCaloricDishesName = new ArrayList<>();//将菜名放入集合
        for(Dish d: lowCaloricDishes){
            lowCaloricDishesName.add(d.getName());
        }

 List<String> lowCaloricDishesName =  //java 8
                menu.stream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCalories))
                        .map(Dish::getName)
                        .collect(toList());

（1）、代码是以声明性方式写的:说明想要完成什么,而不是说明如何实现一个操作(利用for if 等控制语句).这种方法加上行为参数化,可以让你很轻松的应对变化的需求,你很容易再创建一个代码版本，利用Lambda表达式来筛选高卡路里的菜肴，而用不着去复制粘贴代码
（2）、你可以把几个基础操作连接起来:来表达复杂的数据流水线工作,同时保证代码清晰可读.filter 的结果被传给了 sorted 方法，再传给 map 方法，最后传给 collect 方法。

2、流简介：
流的简短的定义就是:"从支持数据处理操作的源生成的元素序列";
(1)元素序列: 就像集合一样,流提供了一个接口,可以访问特定元素类型的一组有序值.因为集合是数据结构,所以它的主要目的是以特定的时间/空间复杂度来存储访问元素.但流的目的在于表达计算.
(2)源: 流会使用一个提供数据的源,这些源可以是数组,集合,或输入输出资源.注意:从有序结合生成的流会保留原有的顺序,由列表生成的流,其元素顺序也与列表一致.
(3)数据处理操作: 流的数据处理功能类似于数据库的操作.以及函数式编程语言的常用操作.如 filter 、 map 、 reduce 、 find 、 match 、 sort 等。流操作可以顺序执行，也可并行执行。
此外，流操作有两个重要的特点。

流水线: 很多流操作本身会返回一个流.这样多个操作就可以连接起来形成一个更大的流水线.流水线操作可以看成对数据源进行数据库式查询.
内部迭代: 与使用迭代器对集合进行显示迭代不同,流的迭代都是在背后进行的.

List<String> lowCaloricDishes =
                //1.从 menu 获得流（菜肴列表）,建立操作流水线
                menu.stream()
                        //2.选出高热量菜肴
                        .filter(d -> d.getCalories() > 300)
                        //3.输出菜肴名称
                        .map(Dish::getName)
                        //4.只选择前三个
                        .limit(3)
                        //5.将结果保存在另一个List中
                        .collect(toList());

在本例中,我们显示对menu进行stream操作,得到一个流,数据源是菜肴列表menu,接下来对流进行一系列数据处理操作:filter 、 map 、 limit
和 collect 。除了 collect 之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线,于是就可以看作对源的一个查询.
最后collect开始处理流水线,并返回一个结果(collect和别的操作不一样,它返回的不是一个流而是一个list).
在调用collect之前,没有任何结果产生,事实上,根本就没有从menu里选择元素.你可以这么理解：链中的方法调用都在排队等待，直到调用 collect

3、流与集合：
（1）集合是数据结构，它的主要目的是以特定的时间/空间复杂度存储和访问元素，流的主要目的在于计算。集合是每个元素先算出来才能添加到集合中，流则是按需计算。
（2）流属于内部迭代，不像使用Collection接口需要用户去做外部迭代（比如for-each），内部迭代可以透明的并行处理，或者对顺序处理做优化
（3）和迭代器类似，流只能遍历一次。遍历完之后，我们就说这个流已经被消费掉了。

4、流操作
可以连起来的操作称为中间操作，关闭流的操作称为终端操作

 List<String> names = menu.stream()
                .filter(d -> d.getCalories() > 300)
                .map(Dish::getName)
                .limit(3)
                .collect(toList());

image.png

（1）诸如filter或sorted等中间操作会返回另一个流。这让多个操作可以连接起来形成一个查询。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理——它们很懒。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。

List<String> names =
                menu.stream()
                        .filter(d -> {
                            System.out.println("filtering" + d.getName());
                            return d.getCalories() > 300;
                        })
                        .map(d -> {
                            System.out.println("mapping" + d.getName());
                            return d.getName();
                        })
                        .limit(3)
                        .collect(toList());
        System.out.println(names);

        结果：
        filtering 猪肉
        mapping 猪肉
        filtering 牛肉
        mapping 牛肉
        filtering 鸡肉
        mapping 鸡肉
        [pork, beef, chicken]

尽管filter和map是两个独立的操作，但它们合并到同一次遍历中了（我们把这种技术叫作循环
合并）。

（2）终端操作会从流的流水线生成结果，比如collect()、count()、forEach()都是终端操作
在调用collect之前,没有任何结果产生,事实上,根本就没有从menu里选择元素.你可以这么理解：链中的方法调用都在排队等待，直到调用 collect

837EDECD-4B80-4EE4-93C4-92507228E245.png

5、使用流
（1）谓词筛选

 List<Dish> vegetarianMenu = menu.stream()//筛选出是素食的菜肴
                .filter(Dish::isVegetarian)
                .collect(toList());

（2）筛选各异元素

 List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
                .filter(i -> i % 2 == 0)
                .distinct()
                .forEach(System.out::println);

（3）截短流

        List<Dish> dishes = menu.stream()
                .filter(d -> d.getCalories() > 300)
                .limit(3)
                .collect(toList());

（4）跳过元素

 List<Dish> dishe = menu.stream()
                .filter(d -> d.getCalories() > 300)
                .skip(2)
                .collect(toList());

（5）map（它会接受一个函数作为参数,这个函数会被应用到每个元素上.并将其映射成一个新的元素.）

List<String> dishNames = menu.stream()
                .map(Dish::getName)
                .collect(toList());

（6） flatmap （把两个流合并起来,即扁平化为一个流.）

 String[] words = {"Goodbye", "World"};
        List<String> a = Arrays.stream(words)
                .map(w -> w.split(""))
                .flatMap(Arrays::stream)//Arrays.stream() 的方法可以接受一个数组并产生一个流
                .distinct()
                .collect(Collectors.toList());
        a.forEach(System.out::print);
输出：GodbyeWrl

（7）查找和匹配

 if(menu.stream().anyMatch(Dish::isVegetarian)) {
            System.out.println("The menu is (somewhat) vegetarian friendly!!");
        }

allMatch、noneMatch；

Optional<Dish> dish = menu.stream().filter(Dish::isVegetarian).findAny();

findFirst

（8）归约（将流反复组合起来,得到一个值比如Integer,这样的查询可被归类为归约操作.）

 int sum1 = numbers.stream().reduce(0, (a2, b2) -> a2 + b2);//求和
 int sum2 = numbers.stream().reduce(0, Integer::sum);//Integer的静态方法
 Optional<Integer> sum3 = numbers.stream().reduce((a1, b1) -> (a1 + b1));//不给初始值
 Optional<Integer> max = numbers.stream().reduce(Integer::max);//最大值
 Optional<Integer> min = numbers.stream().reduce(Integer::min);//最小值

（9）数值流

 int cal = menu.stream().map(Dish::getCalories)
                .reduce(0, Integer::sum);//它有一个暗含的拆箱成本。每个 Integer 都必须拆箱成一个原始类型

 int calories = menu.stream()
                .mapToInt(Dish::getCalories)//返回一个InStream
                .sum();
        
 IntStream intStream = menu.stream().mapToInt(Dish::getCalories);//将Stream转换为数值流
Stream<Integer> stream = intStream.boxed();//将数值流转换为Stream
        
IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);//一个从1到100的偶数流

（10）创建流的几种方式：

 /*//通过Collection得Stream()方法（串行流）或者 parallelStream()方法（并行流）创建Stream
        List<String> list = Arrays.asList("1","2","3","4","0","222","33");
        Stream<String> stream = list.stream();
        Stream<String> stream1 = list.parallelStream();

        //通过Arrays中得静态方法stream获取数组流
        IntStream stream = Arrays.stream(new int[]{1,2,3});

        //通过Stream类中的of()静态方法获取流
        Stream<String> stream = Stream.of("a","b","c");

        //需要传入一个种子，也就是起始值,然后传入一个一元操作
        Stream<Integer> stream1 = Stream.iterate(2, (x) -> x * 2);
        //生成(无限产生对象)
        Stream<Double> stream2 = Stream.generate(() -> Math.random());*/

6、收集器（Collector）
Collector会对每一个元素应用一个转换函数(如:toList()),将结果累积在一个数据结构中,从而产生这一过程的最终输出.

 Map<Currency, List<Transaction>> transactionsByCurrencies =
                new HashMap<>();
        for (Transaction transaction : transactions) {
            Currency currency = transaction.getCurrency();
            List<Transaction> transactionsForCurrency =
                    transactionsByCurrencies.get(currency);
            if (transactionsForCurrency == null) {
                transactionsForCurrency = new ArrayList<>();
                transactionsByCurrencies
                        .put(currency, transactionsForCurrency);
            }
            transactionsForCurrency.add(transaction);
        }

Map<Currency, List<Transaction>> transactionsByCurrencies =
                transactions.stream().collect(groupingBy(Transaction::getCurrency));

（1）归约汇总

 long howManyDishes = menu.stream().collect(Collectors.counting());//计算菜单里有多少菜

Optional<Dish> mostCalorieDish = menu.stream().collect(maxBy(Comparator.comparingInt(Dish::getCalories)));//最大热量的菜

int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));//所有菜的热量  averagingInt

 String shortMenu = menu.stream().map(Dish::getName).collect(joining(", "));//拼接字符串

（2）分组（一个常见的数据库操作是根据一个或多个属性对集合中的项目进行分组）


Map<Dish.Type, List<Dish>> dishesByType menu.stream().collect(groupingBy(Dish::getType));

 Map<Dish.Type, Map<CaloricLevel, List<Dish>>> map = menu.stream().collect(
                groupingBy(Dish::getType,
                        groupingBy(dish -> {
                            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                            else return CaloricLevel.FAT;
                        })
                )
        );

Map<Dish.Type, Long> map = menu.stream()
                .collect(groupingBy(Dish::getType, counting()));

（3）分区（由一个谓词（返回一个布尔值的函数）作为分类函数，它称分区函
数。分区函数返回一个布尔值）

Map<Boolean, List<Dish>> partitionedMenu menu.stream().collect(partitioningBy(Dish::isVegetarian));

{false=[pork, beef, chicken, prawns, salmon], 
 true=[french fries, rice, season fruit, pizza]}