Stream之filter、distinct、skip、map、flatMap、match、find、reduce

一、Stream之filter、distinct、skip：

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;

 public class StreamFilter {

     public static void main(String[] args) {
         List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 7, 8);

         //取出偶数
         List<Integer> result = list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());
         System.out.println(result);

         //去重
         List<Integer> result1 = list.stream().distinct().collect(Collectors.toList());
         System.out.println(result1);

         //跳过前面的5个元素
         List<Integer> result2 = list.stream().skip(5).collect(Collectors.toList());
         System.out.println(result2);

         //只要前面的5个
         List<Integer> result3 = list.stream().limit(5).collect(Collectors.toList());
         System.out.println(result3);
     }
 }

打印结果：

[2, 4, 6, 6, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
[6, 6, 7, 7, 8]
[1, 2, 3, 4, 5]

二、Stream之map、flatMap：　　

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

 public class StreamMap {

     public static void main(String[] args) {
         List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 7, 8);

         //list集合中每个数放大两倍
         List<Integer> result1 = list.stream().map(i -> i * 2).collect(Collectors.toList());
         System.out.println(result1);

         //只返回Dish中的name
         List<String> result2 = listDish().stream().map(d -> d.getName()).collect(Collectors.toList());
         System.out.println(result2);

         /**
          * 需求：将Hello和World单词中重复的字母去掉
          * flatmap flat(扁平化)
          */
         String[] words = {"Hello", "World"};
         //{H,e,l,l,o}, {W,o,r,l,d}
         Stream<String[]> stream = Arrays.stream(words).map(w -> w.split(""));   //Stream<String[]>
         //H,e,l,l,o,W,o,r,l,d
         Stream<String> stringStream = stream.flatMap(Arrays::stream);
         List<String> result3 = stringStream.distinct().collect(Collectors.toList());
         System.out.println(result3);
     }

     private static List<Dish> listDish(){
         List<Dish> menu = Arrays.asList(
                 new Dish("pork", false, 800, Dish.Type.MEAT),
                 new Dish("beef", false, 700, Dish.Type.MEAT),
                 new Dish("chicken", false, 400, Dish.Type.MEAT),
                 new Dish("french fries", true, 530, Dish.Type.OTHER),
                 new Dish("rice", true, 350, Dish.Type.OTHER),
                 new Dish("season fruit", true, 120, Dish.Type.OTHER),
                 new Dish("pizza", true, 550, Dish.Type.OTHER),
                 new Dish("prawns", false, 300, Dish.Type.FISH),
                 new Dish("salmon", false, 450, Dish.Type.FISH));
         return menu;
     }
 }

打印结果：

[2, 4, 6, 8, 10, 12, 12, 14, 14, 16]
[pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon]
[H, e, l, o, W, r, d]

三、stream之match、find、reduce：

match：anyMatch、noneMatch、allMatch

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.stream.Stream;

 public class StreamMatch {

     public static void main(String[] args) {
         Stream<Integer> s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});

         //s中是否所有元素都大于0
         boolean b = s.allMatch(i -> i > 0);
         System.out.println(b); 　　　　　　　　　　　　　　//true

         //只要有一个元素大于6就返回true
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
         boolean b2 = s.anyMatch(i -> i>6);
         System.out.println(b2);　　　　　　　　　　　　　　//true

         //没有一个元素满足小于1
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
         boolean b3 = s.noneMatch(i -> i<0);
         System.out.println(b3);　　　　　　　　　　　　　　//true
     }
 }

find:

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;

 public class StreamFind {

     public static void main(String[] args) {
         Stream<Integer> s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});

         //过滤出偶数之后，随便返回一个
         Optional<Integer> optional1 = s.filter(i -> i % 2 == 0).findAny();
         System.out.println(optional1.get());

         //过滤出大于100的数，任意返回一个，如果有值正常返回，没值返回-1
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
         Optional<Integer> optional2 = s.filter(i -> i > 100).findAny();
         System.out.println(optional2.orElse(-1));

         //过滤出偶数，找到第一个，如果存在就打印
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
         Optional<Integer> optional3 = s.filter(i -> i % 2 == 0).findFirst();
         optional3.ifPresent(System.out::println);
     }
 }

打印：

2
-1
2

reduce：

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;

 public class StreamReduce {

     public static void main(String[] args) {
         //reduce: 聚合的作用
         Stream<Integer> s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});

         //求和，初始值设置为0
         Integer result = s.reduce(0, (i, j) -> i + j);
         System.out.println(result);

         //求最大值
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
         s.reduce((i, j) -> i > j ? i : j).ifPresent(System.out::println);

         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
         s.reduce(Integer::max).ifPresent(System.out::println);

         //只对里面的偶数进行相乘，计算结果
         s = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
         Integer result2 = s.filter(i -> i % 2 == 0).reduce(1, (i, j) -> i * j);
         Optional.of(result2).ifPresent(System.out::println);
     }
 }

打印：

15
5
5
8

-----