> Stream簡化元素計算；

# 一、介面設計

從Java1.8開始提出了Stream流的概念，側重對於源資料計算能力的封裝，並且支援序列與並行兩種操作方式；依舊先看核心介面的設計:

![](http://img.blog.itpub.net/blog/2022/08/08/8dac4f3627ee8661.png?x-oss-process=style/bb)

- BaseStream：基礎介面，宣告瞭流管理的核心方法；
- Stream：核心介面，宣告瞭流操作的核心方法，其他介面為指定型別的適配；

基礎案例：透過指定元素的值，返回一個序列流，元素的內容是字串，並轉換為Long型別，最終計算求和結果並返回；

```java
System.out.println("sum1="+IntStream.of(1,2,3).sum());
System.out.println("sum2="+Stream.of("1", "2", "3").mapToLong(Long::parseLong).sum());
```

整個Stream處理過程上看可以分為三段：建立流、中間操作、最終操作，即多個元素值透過流計算最終獲取到求和的結果；

# 二、建立操作

除了Stream提供的建立方法之外，在Java1.8中，很多容器類的方法都進行的擴充套件，提供了集合元素轉流的能力；

- Stream建立

```java
Stream<integer> intStream = Stream.of(1, 2) ;
```

- Collection建立

```java
List<string> getList = Arrays.asList("hello","copy") ;
Stream<string> strStream = getList.stream() ;
```

- Array建立

```java
Double[] getArray = new Double[]{1.1,2.2};
Stream<double> douStream = Arrays.stream(getArray) ;
```

上述方式建立的Stream流預設都是序列序列，可以透過`Stream.isParallel`進行判斷；執行`Stream.parallel`方法可以轉為並行流；

# 三、中間操作

通常對於Stream的中間操作，可以視為是源的查詢，並且是懶惰式的設計，對於源資料進行的計算只有在需要時才會被執行，與資料庫中檢視的原理相似；

Stream流的強大之處便是在於提供了豐富的中間操作，相比集合或陣列這類容器，極大的簡化源資料的計算複雜度，案例中使用的資料結構如下；

```java
public class TesStream {
    public static void main(String[] args)  {
        List<user> userList = getUserList () ;
    }
    private static List<user> getUserList (){
        List<user> userList = new ArrayList<>() ;
        userList.add(new User(1,"張三","上海")) ;
        userList.add(new User(2,"李四","北京")) ;
        userList.add(new User(3,"王五","北京")) ;
        userList.add(new User(4,"順六","上海,杭州")) ;
        return userList ;
    }
}
```

- filter：過濾，輸出id大於1的使用者；

```java
userList.stream().filter(user -> user.getId()>1).forEach(System.out::println);
```

- map：將現有的元素轉換對映到對應的結果，輸出使用者所在城市；

```java
userList.stream().map(user -> user.getName()+" 在 "+user.getCity()).forEach(System.out::println);
```

- peek：對元素進行遍歷處理，每個使用者ID加1輸出；

```java
userList.stream().peek(user -> user.setId(user.getId()+1)).forEach(System.out::println);
```

- flatMap：資料拆分一對多對映，使用者所在多個城市；

```java
userList.stream().flatMap(user -> Arrays.stream(user.getCity().split(","))).forEach(System.out::println);
```

- sorted：指定屬性排序，根據使用者ID倒序輸出；

```java
userList.stream().sorted(Comparator.comparingInt(User::getId).reversed()).forEach(System.out::println);
```

- distinct：去重，使用者所在城市去重後輸出；

```java
userList.stream().map(User::getCity).distinct().forEach(System.out::println);
```

- skip & limit：擷取，過濾後的資料跳過，擷取第一條；

```java
userList.stream().filter(user -> user.getId()>1).skip(1).limit(1).forEach(System.out::println);
```

相比於集合與陣列在Java1.8之前的處理邏輯，透過Stream流的方法簡化對資料改、查、過濾、排序等一系列操作，上面對於最終方法只涉及了foreach遍歷；

# 四、最終操作

Stream流執行完最終操作之後，無法再執行其他動作，否則會報狀態異常，提示該流已經被執行操作或者被關閉，想要再次執行操作必須重新建立Stream流；

- min：最小值，獲取使用者最小的id值；

```java
int min = userList.stream().min(Comparator.comparingInt(User::getId)).get().getId();
```

- max：最大值，獲取使用者最大的id值；

```java
int max = userList.stream().max(Comparator.comparingInt(User::getId)).get().getId();
```

- sum：求和，對使用者ID進行累計求和；

```java
int sum = userList.stream().mapToInt(User::getId).sum() ;
```

- count：總數，id小於2的使用者總數；

```java
long count = userList.stream().filter(user -> user.getId()<2).count();
```

- foreach：遍歷，輸出北京相關的使用者；

```java
userList.stream().filter(user -> "北京".equals(user.getCity())).forEach(System.out::println);
```

- findAny：查詢符合條件的任意一個元素，獲取一個北京使用者；

```
User getUser = userList.stream().filter(user -> "北京".equals(user.getCity())).findAny().get();
```

- findFirst：獲取符合條件的第一個元素；

```
User getUser = userList.stream().filter(user -> "北京".equals(user.getCity())).findFirst().get();
```

- anyMatch：匹配判斷，判斷是否存在深圳的使用者；

```
boolean matchFlag = userList.stream().anyMatch(user -> "深圳".equals(user.getCity()));
```

- allMatch：全部匹配，判斷所有使用者的城市不為空；

```
boolean matchFlag = userList.stream().allMatch(user -> StrUtil.isNotEmpty(user.getCity()));
```

- noneMatch：全不匹配，判斷沒有使用者的城市為空；

```
boolean matchFlag = userList.stream().noneMatch(user -> StrUtil.isEmpty(user.getCity()));
```

這裡只是演示一些簡單的最終方法，主要涉及Stream流的一些統計和判斷相關的能力，在一些實際的業務應用中，顯然這些功能還遠遠不夠；

# 五、Collect收集

Collector：結果收集策略的核心介面，具備將指定元素累加存放到結果容器中的能力；並在Collectors工具中提供了Collector介面的實現類；

- toList：將使用者ID存放到List集合中；

```java
List<integer> idList = userList.stream().map(User::getId).collect(Collectors.toList()) ;
```

- toMap：將使用者ID和Name以Key-Value形式存放到Map集合中；

```java
Map<integer> userMap = userList.stream().collect(Collectors.toMap(User::getId,User::getName));
```

- toSet：將使用者所在城市存放到Set集合中；

```java
Set<string> citySet = userList.stream().map(User::getCity).collect(Collectors.toSet());
```

- counting：符合條件的使用者總數；

```java
long count = userList.stream().filter(user -> user.getId()>1).collect(Collectors.counting());
```

- summingInt：對結果元素即使用者ID求和；

```java
Integer sumInt = userList.stream().filter(user -> user.getId()>2).collect(Collectors.summingInt(User::getId)) ;
```

- minBy：篩選元素中ID最小的使用者

```java
User maxId = userList.stream().collect(Collectors.minBy(Comparator.comparingInt(User::getId))).get() ;
```

- joining：將使用者所在城市，以指定分隔符連結成字串；

```java
String joinCity = userList.stream().map(User::getCity).collect(Collectors.joining("||"));
```

- groupingBy：按條件分組，以城市對使用者進行分組；

```java
Map<string>> groupCity = userList.stream().collect(Collectors.groupingBy(User::getCity));
```

在程式碼工程中會涉及到諸多的集合資料計算的邏輯，尤其在微服務場景中，VO資料模型需要對多個服務的資料進行組裝，透過Collector可以極大精簡組裝過程；

$$End$$</string></string></integer></integer></user></user></user></double></string></string></integer>

Java基礎 | Stream流原理與用法總結

相關文章