使用流

筛选好，切片和匹配

• filter 过滤
  传入一个predicate<T>，predicate里面有一个test方法，boolean test(T t);

List<Dish> meat = menu.stream()
.filter(dish -> dish.getType().equals("meat"))
.collect(Collectors.toList());

image.png

• distinct 没有重复的元素，主要是根据元素的equals和hashcode方法来判断的。

 List<Dish> meat = menu.stream().
            filter(dish -> dish.getType().equals("meat"))
            .distinct()
            .collect(Collectors.toList());

• 截断流 也就是limit(n),限制流的返回个数,具体个数由n来决定

 List<Dish> meat = menu.stream().
            filter(dish -> dish.getType().equals("meat"))
            .distinct()
            .limit(1)
            .collect(Collectors.toList());

• 跳过元素，skip(n)和limit(n)很类似，skip(n)表示返回扔掉前n个元素的流，没有元素的话返回空。

  List<Dish> meats = menu.stream().
            filter(dish -> dish.getType().equals("meat"))
            .distinct()
            .skip(1)
            .collect(Collectors.toList());

• FAQ 如何筛选出前两个荤菜呢？

    List<Dish> twoMeats   = menu.stream()
            .filter(dish -> dish.getType().equals("meat"))
            .limit(2)
            .collect(Collectors.toList());

• 映射，对流中的每一个元素使用函数，也就是map方法，它接受一个函数,这个函数会应用到每一个元素上回映射生成一个新的元素。

        List<String> names = menu.stream()
            .map(dish -> dish.getName())
            .collect(Collectors.toList());

• 流的扁平化 让你把流中的每一个元素都换成流，然后把每一个流合并成一个流。

 List<DishColor> dishColors = menu.stream()
            .flatMap(dish -> dish.getDishColors().stream())
            .collect(Collectors.toList());

• FAQ
  给定1,2,3,4,5如何返回它的平方呢？

 List<Integer> numbers = Arrays.asList(1,2,3,4,5);
        List<Integer> nums = numbers.stream().map(x -> x * x)
            .collect(Collectors.toList());

给定1,2,3和3，4返回(1,3)(1,4)(2,1)(2,4)(3,1)(3,4)

List<Integer> number1s = Arrays.asList(1, 2, 3);
        List<Integer> number2s = Arrays.asList(3, 4);
        number1s.stream().
            flatMap(x ->
                number2s.stream()
                    .map(y -> new int[] {x, y}))
            .collect(Collectors.toList());

查找，匹配和规约

• anyMatch 至少匹配一个

 boolean isfind = menu.stream().anyMatch(dish -> dish.getType().equals("meat"));

• allMatch 匹配所有元素

 boolean allfind = menu.stream().allMatch(dish -> dish.getType().equals("meat"));

• noneMatch 一个匹配元素都没有

 boolean nonefind = menu.stream().noneMatch(dish -> dish.getType().equals("meat"));

• 查询元素 findAny 返回流中任意元素

 Optional<Dish> meat = menu.stream().filter(dish -> dish.getType().equals("meat")).findAny();

• 查询元素 findFirst 返回流中第一个元素

 Optional<Dish> meat = menu.stream().filter(dish -> dish.getType().equals("meat")).findFirst();

• Optional<T>
  是一个容器类，代表一个值的存在或者不存在，可以使用get()方法获取
  常用的方法有：isPresent() ifPreSent(Consumer<T> block) get() orElse(T t)

 Optional<Dish> meat = menu.stream().filter(dish -> dish.getType().equals("meat")).findAny();
        Dish dish = meat.get();
        System.out.println(dish);
        Dish orElse = meat.orElse(new Dish());
        System.out.println(orElse);
        boolean present = meat.isPresent();
        System.out.println(present);

• 归约 将流中所有元素反复结合起来，得到一个值，主要的查询操作就叫做归约。

        Integer reduce = numbers.stream().reduce(0, (x, y) -> x + y);
        Optional<Integer> reduce1 = numbers.stream().reduce( (x, y) -> x + y);
        Integer reduce2 = numbers.stream().reduce(0, Integer::sum);

reduce 接受两个参数
一个初始值
一个BinaryOperator<T>来将两个元素合并产生一个新的元素，
lambda (x,y)->x+y
求最大和最小值

      //max
        Optional<Integer> max = numbers.stream().reduce((x, y) -> x > y ? x : y);
        Optional<Integer> max1 = numbers.stream().reduce(Integer::max);
        //min
        Optional<Integer> min = numbers.stream().reduce((x, y) -> x <= y ? x : y);
        Optional<Integer> min1 = numbers.stream().reduce(Integer::min);

• FAQ 求菜单菜的数量

 Optional<Integer> reduce3 = menu.stream().map(dish1 -> 1).reduce(Integer::sum);
   long count = menu.stream().count();

使用数值范围等数值流

原始类型流特化
Java8引入三个原始类型流特化接口：IntStream LongStream DoubleStream分别将流中的元素特化为int ,long,double,从而避免装箱成本。

• 映射到数值流
  mapToInt,mapToDouble,MapToLong

 IntStream intStream = menu.stream().mapToInt(Dish::getCategary);
 int count =  intStream.count();

• 转换到对象流

Stream<Integer> boxed = intStream.boxed();

总计一下

这一章主要是介绍了流的一下常见用法，filter,map,flatMap,reduce