Java8新特性之streamAPI（二）

stream操作的三个步骤之中间操作： 

• 筛选与切片
  ​​​​​​filter——接收Lambda，从流中排除某些元素
  limit——截断流，使其元素不超过给定数量
  skip——跳过元素，返回一个扔掉了前n个元素的流。若留着元素不足n个，则返回一个空流。与limit(n)互补
  distinct——筛选，通过流所生成元素的hashCode()和equals()去除重复元素。

• 内部迭代：迭代操作由StreamAPI完成

• 映射
  map——接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

• 排序
  sorted()——自然排序Comparable
  sorted(Comparator com)——定制排序

  package streamAPI;
  
  import lambda.Employee;
  import org.apache.hadoop.yarn.webapp.hamlet.Hamlet;
  import org.junit.Test;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import java.util.stream.Stream;
  
  
  public class TestStreamAPI2 {
  
      List<Employee> employees = Arrays.asList(
              new Employee("张三", 25, 9000),
              new Employee("李四", 38, 10000),
              new Employee("王晓", 45, 12000),
              new Employee("李华", 28, 9500),
              new Employee("花花", 22, 8000),
              new Employee("李华", 28, 9500),
              new Employee("花花", 22, 8000),
              new Employee("花花", 22, 8000),
              new Employee("李华", 28, 9500),
              new Employee("花花", 22, 8000)
      );
  
      //中间操作
      /*
       *筛选与切片
       * filter——接收Lambda，从流中排除某些元素
       * limit——截断流，使其元素不超过给定数量
       * skip——跳过元素，返回一个扔掉了前n个元素的流。若留着元素不足n个，则返回一个空流。与limit(n)互补
       * distinct——筛选，通过流所生成元素的hashCode()和equals()去除重复元素。
       */
  
      /**
       * 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则智能关键操作不会执行，
       * 而在终止操作时一次性全部处理，称为“惰性求值”
       */
  
      //内部迭代：迭代操作由StreamAPI完成
      @Test
      public void test1() {
          //中间操作
          Stream<Employee> stream1 = employees.stream()
                  .filter((e) -> e.getAge() > 35);
          //终止操作
          stream1.forEach(System.out::println);
      }
  
      @Test
      public void test2() {
          employees.stream()
                  .filter((e) -> {
                      System.out.println("短路！");
                      return e.getSalary() > 5000;
                  })
                  .limit(2)
                  .forEach(System.out::println);
      }
  
      @Test
      public void test3() {
          employees.stream()
                  .filter((e) -> e.getSalary() > 5000)
                  .skip(2)
                  .forEach(System.out::println);
      }
  
      @Test
      public void test4() {
          employees.stream()
                  .filter((e) -> e.getSalary() > 5000)
                  .skip(2)
                  .distinct()
                  .forEach(System.out::println);
      }
  
      //中间操作
      /*
       * 映射
       * map——接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
       * flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
       */
      @Test
      public void test5() {
          List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
          list.stream()
                  .map((str) -> str.toUpperCase())
                  .forEach(System.out::println);
  
          System.out.println("----------------------------------");
  
          employees.stream()
                  .distinct()
                  .map(Employee::getName)
                  .forEach(System.out::println);
  
          //{{a,a,a},{b,b,b},{c,c,c},{d,d,d},{e,e,e}}
          Stream<Stream<Character>> stream = list.stream()
                  .map(TestStreamAPI2::filterCharacter);
          stream.forEach((sm) ->
                  sm.forEach(System.out::println));
  
          System.out.println("---------------------------");
  
  
          //{a,a,a,b,b,b,c,c,c,d,d,d,e,e,e}
          list.stream()
                  .flatMap(TestStreamAPI2::filterCharacter)
                  .forEach(System.out::println);
      }
  
      public static Stream<Character> filterCharacter(String str) {
          List<Character> list = new ArrayList<>();
          for (Character ch : str.toCharArray()) {
              list.add(ch);
          }
          return list.stream();
      }
  
      //中间操作
      /*
       *排序
       * sorted()——自然排序Comparable
       * sorted(Comparator com)——定制排序
       */
      @Test
      public void test6() {
          List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
  
          list.stream()
                  .sorted()
                  .forEach(System.out::println);
  
          System.out.println("----------------------------------");
  
          employees.stream()
                  .sorted((e1,e2)-> {
                      if (e1.getAge() == e2.getAge()) {
                          return e1.getName().compareTo(e2.getName());
                      }
                      else {
                          return Integer.compare(e1.getAge(),e2.getAge());
                      }
                  })
                  .forEach(System.out::println);
      }
  }
  

  相关函数声明详见：https://blog.csdn.net/qq_38358499/article/details/104636487