Java8中創建Stream 流的四種方式以及 Stream 中間操作

0xE7A38A 發布于2019-08-16 18:28 / 1274人閱讀

摘要：一創建里流的四種方式第一種通過得方法串行流或者方法并行流創建。終止操作時一次性全部處理，稱為延遲加載篩選切片過濾中建操作。終止操作只有執行終止操作才會執行全部。即延遲加載結果中建操作。截斷流，使其元素不超過給定數量。返回流中最大值。

Stream api

**Stream api 是java8 中提供的對集合處理的api ， 對數據進行一系列的中間操作，元數據不會發生改變
                集合講的是數據， 流 講的是計算（用于操作數據源，集合，數組）所生成的元素序列。**
                
         Stream API位于 java.util.stream.* 包下。

1 Stream 自己不會存儲元素

                   2 Stream 不會改變源對象。相反，他們會返回一個持有結果的性Sstream 。
                  3 Stream 操作是延遲執行的。這以為這他們會等到需要結果的時候才執行（延遲加載）。

一創建里Stream 流的四種方式

### 1 第一種通過Collection得Stream（）方法（串行流）或者 parallelStream（）方法（并行流）創建Stream。

         List list = Arrays.asList("1","2","3","4","0","222","33");
        Stream stream = list.stream();
         Stream stream1 = list.parallelStream();

### 2 通過Arrays中得靜態方法stream（）獲取數組流

        IntStream stream = Arrays.stream(new int[]{1,2,3});

### 3 通過Stream類中得 of（）靜態方法獲取流

       Stream stream = Stream.of("a","b","c");

### 4 創建無限流(迭代、生成)

//迭代（需要傳入一個種子，也就是起始值，然后傳入一個一元操作）
     Stream stream1 = Stream.iterate(2, (x) -> x * 2);

     //生成(無限產生對象)
     Stream stream2 = Stream.generate(() -> Math.random());

二 Stream 中間操作

多個中間操作可以連接起來形成一個流水線，除非流水線終止操作，否則中間操作不會執行任何處理。
終止操作時一次性全部處理，稱為“延遲加載”

1 篩選切片

1 過濾

List list = Arrays.asList("1","2","3","4","0","222","33");
Stream stream = list.stream().filter((x) -> {
            System.out.println(" api  中建操作。");
            return x.equals("3");
        });
        //終止操作：只有執行終止操作才會執行全部。即：延遲加載
        stream.forEach(System.out::println);

結果

 api  中建操作。
 api  中建操作。
 api  中建操作。
3
 api  中建操作。
 api  中建操作。
 api  中建操作。
 api  中建操作。

2 limit() 截斷流，使其元素不超過給定數量。

List list = Arrays.asList("1","2","3","4","0","222","33","3","3");
 Stream stream = list.stream().filter((x) -> {
            System.out.println(" api  中建操作。");
            return x.equals("3");
        });
        //取兩個 ， 可以配合其他得中間操作，并截斷流，取到相應的元素個數，這不會往下執行，可以提高效率
        stream.limit(2).forEach(System.out::println);

3 skip(n) 跳過元素

skip（n），返回一個扔掉了前n個元素的流。若流中元素不足n個，則返回一個空，與limit（n）互補。

List list = Arrays.asList("1","2","3","4","0","222","33","3","3");
        Stream stream = list.stream().filter((x) -> {
            System.out.println(" api  中建操作。");
            return x.equals("3");
        });
        //skip（n），返回一個扔掉了前n個元素的流。若流中元素不足n個，則返回一個空，與limit（n）互補。
        stream.skip(3).limit(1).forEach(System.out::println);

4 篩選

　　　　distinct 通過流所生成元素的hashCode（）和equals（）去除重復元素

List list = Arrays.asList("1","2","3","4","0","222","33","3","3");
 Stream stream = list.stream();
        stream.distinct().forEach(System.out::println);

5 映射

map - 接受lambda 將元素轉換為其他形式或提取信息。

接受一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新元素

flatMap 接受一個函數作為參數，將流中的每個值都轉成另一個流，然后把所有流連成一個流。

List stuList = Arrays.asList(new Stu("a",1),new Stu("ab",3),new Stu("c",11),new Stu("f",12));
 
   Stream stream = stuList.stream();
        //去除list中所有的年齡
        stream.map(Stu::getAge).forEach(System.out::println);
        //把所有年齡再返回一個集合
        List collect = stream.map(Stu::getAge).collect(Collectors.toList());

        stream.flatMap(stu -> test1.filterCharacter(stu.getName())).forEach(System.out::println);

6 排序

sorted有兩種方法，一種是不傳任何參數，叫自然排序，還有一種需要傳Comparator 接口參數，叫做定制排序。

 //自然排序
        List collect = list.stream().sorted().collect(Collectors.toList());
        
        List collect2 = list.stream().sorted((o1, o2) -> {
            if(o1.length()>o2.length()){
                return 1;
            }else 
            if(o1.length()
三  Stream 終止操作
實體類
public class Person {
    String name ;
    String sex ;
    int age;
    Status statusEnum;

    public Person(String name, String sex, int age, Status statusEnum) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.statusEnum = statusEnum;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Status getStatusEnum() {
        return statusEnum;
    }

    public void setStatusEnum(Status statusEnum) {
        this.statusEnum = statusEnum;

}

    @Override
    public String toString() {
        return "Person{" +
                "name="" + name + """ +
                ", sex="" + sex + """ +
                ", age=" + age +
                ", statusEnum=" + statusEnum +
                "}";
    }
}

操作
 List persons = Arrays.asList(
                          new Person("張三", "男", 76, Status.FREE),
              new Person("李四", "女", 12, Status.BUSY),
               new Person("王五", "男", 35, Status.BUSY),
               new Person("趙六", "男", 3, Status.FREE),
               new Person("錢七", "男", 56, Status.BUSY),
               new Person("翠花", "女", 34, Status.VOCATION),
               new Person("翠花", "女", 34, Status.FREE),
               new Person("翠花", "女", 34, Status.VOCATION)
              );
1 查找與匹配
##### 1  allMatch —— 檢查是否匹配所有元素。
    public void test1(){
        boolean allMatch = persons.stream().allMatch((x) -> {
            return x.getStatusEnum().equals(Status.FREE);
        });

        System.out.println(allMatch);
    }
2 anyMatch —— 檢查是否至少匹配一個元素。
    public void test2(){
        boolean allMatch = persons.stream().anyMatch((x) -> {
            return x.getStatusEnum().equals(Status.FREE);
        });

        System.out.println(allMatch);
    }
3 noneMatch —— 檢查是否沒有匹配所有元素。
  檢查 所有的是否都是 FREE  ----- 結果是false

    public void test3(){
        boolean allMatch = persons.stream().noneMatch((x) -> {
            return x.getStatusEnum().equals(Status.FREE);
        });

        System.out.println(allMatch);
    }
4 findFirst —— 返回第一個元素。
 public void test4(){
      Optional first = persons.stream().findFirst();

      System.out.println(first.get());
  }
##### 5 findAny —— 返回當前流中任意元素。
public void test5(){
     Optional first = persons.stream().findAny();
     //first.orElse(new Person());  如果沒空 可以穿一個新的對象去代替它
     System.out.println(first.get());
 }
##### 6  count —— 返回流中元素總個數。
  public void test6(){
      long first = persons.stream().count();
      System.out.println(first);
  }
##### 7   max —— 返回流中最大值。
public void test7(){
     Optional person = persons.stream().max((x,y) ->  Integer.compare(x.age, y.age));
     System.out.println(person.get());
 }
##### 8   min —— 返回流中最小值。
public void test8(){
      Optional person = persons.stream().min((x,y) ->  Integer.compare(x.age, y.age));
      System.out.println(person.get());
  }
2 歸約  :  可以將流中元素反復結合在一起，得到一個值
1  reduce（T identitty，BinaryOperator）首先，需要傳一個起始值，然后，傳入的是一個二元運算。
  public void test9(){
       List list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
               // identitty 起始值 0  然后與集合中的值進行 相應的運算，再次賦值給 identity 然后 在進行運算。
                Integer sum = list.stream().reduce(0, (x, y) -> x + y);
       System.out.println(sum);
   }
##### 2 reduce（BinaryOperator）此方法相對于上面方法來說，沒有起始值，則有可能結果為空，所以返回的值會被封裝到Optional中。
map和reduce的連接通常稱為map-reduce模式，因Google用它來進行網絡搜索而出名。

用map 來提取 對象中某個屬性，然后再用reduce 進行歸約。
    public void test10() {
        Optional reduce = persons.stream().map(Person::getAge).reduce(Integer::sum);
        System.out.println(reduce.get());
    }
3 收集 ： 收集collect（將流轉換為其他形式。接收一個Collector接口得實現，用于給其他Stream中元素做匯總的方法）
 
       Collector接口中方法得實現決定了如何對流執行收集操作（如收集到List，Set，Map）。
       但是Collectors實用類提供了很多靜態方法，可以方便地創建常見得收集器實例。
 

1 Collectors.toList（） 將流轉換成List
 public void test11() {
     List collect = persons.stream().collect(Collectors.toList());
     collect.forEach(System.out::println);
 }
###### 2 將流轉換成HashSet
     public void test12() {
      //hashset會去重復
          Set collect = persons.stream().map(Person::getName).collect(Collectors.toSet());
          collect.forEach(System.out::println);
      }
###### 3 將流轉換成其他集合
public void test13() {

      Set collect = persons.stream().map(Person::getAge).collect(Collectors.toCollection(LinkedHashSet::new));
      collect.forEach(System.out::println);
  }
##### 4  Collectors.counting()  元素個數
 public void test14() {

      Long collect = persons.stream().map(Person::getAge).collect(Collectors.counting());
      System.out.println(collect);
  }
#####  5   將流轉換為其他形式 ， 接受一個conllectors接口的實現，用于給Stream中元素做匯總的方法
public void test14s() {
        // 1 對元素進行匯總方法
        DoubleSummaryStatistics collect = persons.stream().collect(Collectors.summarizingDouble(Person::getAge));
        IntSummaryStatistics collect2 = persons.stream().collect(Collectors.summarizingInt(Person::getAge));
        System.out.println(collect.getMax());
        System.out.println(collect.getAverage());
        System.out.println(collect.getCount());
        System.out.println(collect.getMin());
        System.out.println(collect.getSum());
###### 2 講元素轉換為其他形式
       String collect1 = persons.stream().map(Person::getName).collect(Collectors.joining("，","頭","尾"));
        String collect3 = persons.stream().map(Person::getName).collect(Collectors.joining());
        System.out.println(collect1); //頭張三，李四，王五，趙六，錢七，翠花，翠花，翠花尾
        System.out.println(collect3); // 張三李四王五趙六錢七翠花翠花翠花
    }
    1. Collectors.averagingDouble（）
    2  Collectors.averagingDouble()
    3 Collectors.averagingLong()

    平均數，這三個方法都可以求平均數，不同之處在于傳入得參數類型不同，返回值都為Double

    public void test15() {

        Double s = persons.stream().collect(Collectors.averagingDouble(Person::getAge));
        System.out.println(s);
    }
#####  8 Collectors.maxBy（） 求最大值
      public void test16() {

          Optional collect = persons.stream().collect(Collectors.maxBy((o1, o2) -> Integer.compare(o1.age, o2.age)));
          System.out.println(collect.get().age);
      }
##### 9 Collectors.minBy（） 求最小值
 public void test17() {

     Optional collect = persons.stream().collect(Collectors.minBy((o1, o2) -> Integer.compare(o1.age, o2.age)));
     System.out.println(collect.get().age);
 }
10 Collectors.groupingBy（）分組 ，返回一個map
按照 Status 分組
  public void test18() {

      Map> collect = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum));
      collect.forEach((status, people) -> {
          System.out.println(" status === " + status);
          people.forEach(System.out::println);
      });
  }
###### 11 多級分組
  Collectors.groupingBy（）還可以實現多級分組
 public void test19() {

     Map>> collect = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum,Collectors.groupingBy(Person::getSex)));
     Map>> collect2 = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum,Collectors.groupingBy(
             e->{
                 if (e.getAge()>10){
                     return "小孩";
                 }else {
                     return "大人";
                 }
             }
     )));
     System.out.println(collect);
     System.out.println(collect2);
 }
##### 12 分區
Collectors.partitioningBy（） 分區，參數中傳一個函數，返回true，和false 分成兩個區
public void test20() {
    年齡大于39的分區  不滿足再的分區
      Map> collect = persons.stream().collect(Collectors.groupingBy(e -> e.getAge() > 30));

      System.out.println(collect);
  }

GPU云服務器云服務器對數據倉庫分析的四種方式 Stream webrtc stream stream sql

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/75143.html

Java 8 數據流教程

摘要：數據流教程原文譯者飛龍協議這個示例驅動的教程是數據流的深入總結。但是的數據流是完全不同的東西。數據流是單體，并且在函數式編程中起到重要作用。列表上的所有流式操作請見數據流的。基本的數據流使用特殊的表達式，例如，而不是，而不是。 Java 8 數據流教程原文：Java 8 Stream Tutorial 譯者：飛龍協議：CC BY-NC-SA 4.0 這個示例驅動的教程是J...

XUI 2019-08-14 14:20 評論0 收藏0
《Java8實戰》-第四章讀書筆記（引入流Stream）

摘要：內部迭代與使用迭代器顯式迭代的集合不同，流的迭代操作是在背后進行的。流只能遍歷一次請注意，和迭代器類似，流只能遍歷一次。流（Stream）流是什么流是Java API的新成員，它允許你以聲明性方式處理數據集合（通過查詢語句來表達，而不是臨時編寫一個實現）。就現在來說，你可以把它們看成遍歷數據集的高級迭代器。此外，流還可以透明地并行處理，你無需寫任何多線程代碼了！我會在后面的筆記中...

_ivan 2019-08-19 11:01 評論0 收藏0
Java8特性②Stream簡介

摘要：元素序列流也提供了一個接口，可以訪問特定元素類型的一組有序值。因為集合是數據結構，所以它的主要目的是以特定的時間空間復雜度存儲和訪問元素如與。請注意，從有序集合生成流時會保留原有的順序。由列表生成的流，其元素順序與列表一致。流是什么流是Java API的新成員，它允許你以聲明性方式處理數據集合（通過查詢語句來表達，而不是臨時編寫一個實現）。可以把它們看成遍歷數據集的高級迭代器。此外...

EasonTyler 2019-08-16 10:31 評論0 收藏0
樂字節-Java8新特性之Stream流（上）

摘要：需要注意的是很多流操作本身就會返回一個流，所以多個操作可以直接連接起來，如下圖這樣，操作可以進行鏈式調用，并且并行流還可以實現數據流并行處理操作。為集合創建并行流。上一篇文章，小樂給大家介紹了《Java8新特性之方法引用》，下面接下來小樂將會給大家介紹Java8新特性之Stream，稱之為流，本篇文章為上半部分。 1、什么是流? Java Se中對于流的操作有輸入輸出IO流,而Jav...

dingda 2019-08-19 11:35 評論0 收藏0
樂字節-Java8核心特性實戰之Stream（流）

摘要：大家好，我是樂字節的小樂。需要注意的是很多流操作本身就會返回一個流，所以多個操作可以直接連接起來，如下圖這樣，操作可以進行鏈式調用，并且并行流還可以實現數據流并行處理操作。為集合創建并行流。大家好，我是樂字節的小樂。說起流，我們會聯想到手機、電腦組裝流水線,物流倉庫商品包裝流水線等等,如果把手機 ,電腦,包裹看做最終結果的話,那么加工商品前的各種零部件就可以看做數據源，而中間一系列的...

wenshi11019 2019-08-16 17:59 評論0 收藏0

發表評論

登陸后可評論

0條評論

0xE7A38A

男|高級講師

我要關注我要私信

TA的文章

如何徹底卸載刪除Google Update服務?

閱讀 3815·2021-11-18 13:19
??國慶七天的總結

閱讀 1168·2021-10-11 10:58
移動端用戶體驗（UE）優化歷程

閱讀 3278·2019-08-29 16:39
網絡操作回調函數 http

閱讀 3129·2019-08-26 12:08
js異步解決方案 --- 回調函數 vs promise vs generater/yield vs

閱讀 2026·2019-08-26 11:33
Undefined和Null

閱讀 2452·2019-08-23 18:30
【10】JavaScript 面向對象高級——繼承模式

閱讀 1297·2019-08-23 18:21
【js】what is 繼承

閱讀 2515·2019-08-23 18:18

国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務器低至59元/年，更有多臺、長期優惠，快來選購！

Java8中創建Stream 流的四種方式以及 Stream 中間操作

1 過濾

2 limit() 截斷流，使其元素不超過給定數量。

2 anyMatch —— 檢查是否至少匹配一個元素。

3 noneMatch —— 檢查是否沒有匹配所有元素。

4 findFirst —— 返回第一個元素。

1 reduce（T identitty，BinaryOperator）首先，需要傳一個起始值，然后，傳入的是一個二元運算。

3 收集：收集collect（將流轉換為其他形式。接收一個Collector接口得實現，用于給其他Stream中元素做匯總的方法）

1 Collectors.toList（）將流轉換成List

10 Collectors.groupingBy（）分組，返回一個map

相關文章

Java 8 數據流教程

**《Java8實戰》-第四章讀書筆記（引入流Stream）**

Java8特性②Stream簡介

**樂字節-Java8新特性之Stream流（上）**

**樂字節-Java8核心特性實戰之Stream（流）**

發表評論

0條評論

0xE7A38A

男|高級講師

TA的文章

如何徹底卸載刪除Google Update服務?

??國慶七天的總結

移動端用戶體驗（UE）優化歷程

網絡操作回調函數 http

js異步解決方案 --- 回調函數 vs promise vs generater/yield vs

Undefined和Null

【10】JavaScript 面向對象高級——繼承模式

【js】what is 繼承

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務器低至59元/年，更有多臺、長期優惠，快來選購！

Java8中創建Stream 流的四種方式以及 Stream 中間操作

1 過濾

2 limit() 截斷流，使其元素不超過給定數量。

2 anyMatch —— 檢查是否至少匹配一個元素。

3 noneMatch —— 檢查是否沒有匹配所有元素。

4 findFirst —— 返回第一個元素。

1 reduce（T identitty，BinaryOperator）首先，需要傳一個起始值，然后，傳入的是一個二元運算。

3 收集 ： 收集collect（將流轉換為其他形式。接收一個Collector接口得實現，用于給其他Stream中元素做匯總的方法）

1 Collectors.toList（） 將流轉換成List

10 Collectors.groupingBy（）分組 ，返回一個map

相關文章

發表評論

0條評論

男|高級講師

TA的文章

最新活動

3 收集：收集collect（將流轉換為其他形式。接收一個Collector接口得實現，用于給其他Stream中元素做匯總的方法）

1 Collectors.toList（）將流轉換成List

10 Collectors.groupingBy（）分組，返回一個map