Stream API 流式操作

/**
 *
 * 一、Stream 的三個操作步驟
 *
 * 1.建立Stream
 *
 * 2.中間操作
 *
 * 3.終止操作(終端操作)
 */
public class TestStreamAPI1 {
    //建立Stream
    @Test
    public void test(){
        //1.可以通過Collection 系列集合提供的stream()或parellelStream()
        List<String> list =new ArrayList<>();
        Stream<String> stream=list.stream();

        //2.通過Arrays中的靜态方法stream()擷取數組流
        User [] users=new User[10];
        Stream<User> stream1= Arrays.stream(users);

        //3.通過Stream類中的靜态方法of()
        Stream<String> stream2=Stream.of("aa","bb","cc");

        //4.建立無限流
          //疊代
        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2);
        stream3.limit(10).forEach(System.out::println);

         //生成
        Stream.generate(()->Math.random())
                .limit(5)
                .forEach(System.out::println);
    }
}
           

中間操作

/**
 *
 * 一、Stream 的三個操作步驟
 *
 * 1.建立Stream
 *
 * 2.中間操作
 *
 * 3.終止操作(終端操作)
 */
public class TestStreamAPI2 {

    List<User> users = Arrays.asList(new User("張三", 18, 8000.11),
            new User("李四", 56, 6000.11),
            new User("王五", 36, 8000.00),
            new User("趙六", 23, 8800.11),
            new User("趙六", 23, 8800.11),
            new User("趙六", 23, 8800.11),
            new User("田七", 8, 3000.00),
            new User("三八", 38, 3800.11));
    //中間操作

    /*
      篩選與切片
      filter——接收Lambda，從流中排除某些元素。
      limit——截斷流，使其元素不超過給定元素數量。
      skip(n)———跳過元素，傳回一個扔掉了前n個元素的流。若流中元素不足n個，則傳回一個空流。與limit(n)互補
      distinct———篩選，通過流所産生成的元素的hashCode()和equals()去除重複元素
     */

      //内部疊代：疊代操作由Stream API 完成
    @Test
    public void test(){
        //中間操作：不會執行任何操作
        Stream<User> stream = users.stream()
                .filter((e) -> {
                    System.out.println("Stream API 的中間操作");
                    return e.getAge()>35;
                });
        //終止操作：一次性執行全部内容，即“惰性求值”
        stream.forEach(System.out::println);
    }

    //外部疊代
    @Test
    public void test2(){
        Iterator<User> it=users.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

    @Test
    public void test3(){
        users.stream().filter((e)->{
            System.out.println("短路!"); //&& ||
            return e.getMoney()>5000;})
                .limit(2)
                .forEach(System.out::println);
    }

    @Test
    public void test4(){
        users.stream()
                .filter((e)->e.getMoney()>5000)
                .skip(2)  //去掉前面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("---------------------------------------");

          users.stream().map(User::getName)
                  .forEach(System.out::println);

          System.out.println("----------------------------------------");

          Stream<Stream<Character>> stream = list.stream()
                  .map(TestStreamAPI2::filterCharacter);

          stream.forEach((sm)->{
              sm.forEach(System.out::println);
          });

          System.out.println("---------------------------------------");

          Stream<Character> sm = list.stream()
                  .flatMap(TestStreamAPI2::filterCharacter);
          sm.forEach(System.out::println);

      }
           

排序

/*
       排序
       sorted()———自然排序（Comparable）
       sorted(Comparator com) ———定制排序（Comparator）
     */
    @Test
    public void test7() {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");

        list.stream()
                .sorted()
                .forEach(System.out::println);

        System.out.println("---------------------------");
        users.stream()
                .sorted((e1, e2) -> {
                    if (e1.getAge()==e2.getAge()){
                        return  e1.getName().compareTo(e2.getName());
                    }else {
                        return -e1.getAge().compareTo(e2.getAge());
                    }
                }).forEach(System.out::println);
    }
           

終止操作

找查與比對

allMaech——檢查是否比對所有元素

anyMatch——檢查訴訟費至少比對一個元素

noneMatch——檢查是否沒有比對所有元素

findFirst——傳回第一個元素

findAny——傳回目前流中的任意元素

count——傳回目前流中的總個數

max———傳回流中的最大值

min——傳回流中的最小值

多級分組

分組

分區

并行流串行流