Stream流

Stream流

stream流,是在java8中,由lambda表達式所帶來的一種新的函數是編程模式,能夠用來解決一些已有的集合類型的弊端。java

1.stream流與傳統集合的便利方式的區別

傳統遍歷方式編程

 1 public static void main(String[] args) {
 2         //遍歷輸出名字中含有七的而且名字長度爲3的人
 3         List<String> list = List.of("喬七七","韓七歲","零零七","魯班七號","上官婉兒");
 4  5         List<String> newList = new ArrayList<>();
 6         //遍歷list挑選出名字中帶有七的
 7             for (String s : list) {
 8                 if (s.contains("七")){
 9                    newList.add(s);
10                 }
11             }
12 13             //遍歷出名字長度爲3的
14             for (String s : newList) {
15                 if (s.length()==3){
16                     System.out.println(s);
17                 }
18             }
19         }

 

stream方式app

1 public static void main(String[] args) {
2         List<String> list = List.of("喬七七","韓七歲","零零七","魯班七號","上官婉兒");
3         //篩選帶七的且名字長度爲3的人
4         list.stream().filter(s -> s.contains("七"))
5                      .filter(s -> s.length()==3)
6                      .forEach(System.out::println);
7     }

 

emmm,是否是很簡單明瞭。函數

2.stream流思想原理

當對集合中的元素須要進行一系列的操做,咱們可已按照須要的規則來進行處理這些集合中的數據。ui

在這個圖中顯示了過濾,映射,跳過,計數等多個環節,將這些步驟都放在一塊兒進行一個流水線同樣的操做,整個過程在一個管道中完成,將數據又由原始狀態轉變爲須要的狀態。spa

filtermapskip都是在對函數模型進行操做,集合元素並無真正被處理。只有當終結方法count執行的時候,整個數據纔會按照指定要求執行操做。code

3.stream流中經常使用的方法

stream流中方法可分爲兩類,一種爲終結方法,另一種爲非終結方法。blog

  • 終結方法:返回值類型再也不是Stream接口自身類型的方法。接口

  • 非終結方法:返回值仍然是stream接口的方法,支持鏈式調用。ip

方法名稱 做用 方法種類 是否支持鏈式調用
count 統計個數 終結
forEach 遍歷逐一處理 終結
filter 過濾 函數拼接 支持
limit 取前幾個 函數拼接 支持
skip 跳過幾個 函數拼接 支持
map 映射 函數拼接 支持
concat 組合 函數拼接 支持

過濾:filter

filter方法將一個流轉換爲另一個子集流。

Stream<T> filter(Predicate<? super T> predicate);

該接口接收一個Predicate函數式接口參數(能夠是一個Lambda或方法引用)做爲篩選條件。

1  public static void main(String[] args) {
2         Stream<String> stream = Stream.of("魯班七號", "老夫子", "公孫離", "南宮", "甄姬");
3         stream.filter(s -> s.length() == 2).forEach(System.out::println);
4 5     }

截取:limit

limit方法能夠對流進行截取,只取用前n個。

Stream<T> limit(long maxSize);

參數是一個long型,若是集合當前長度大於參數則進行截取;不然不進行操做

1 public class StreamLimit {
2     public static void main(String[] args) {
3         Stream<String> stream = Stream.of("魯班七號", "老夫子", "公孫離", "南宮", "甄姬");
4         //limit截取前幾個元素
5         stream.limit(3).forEach(System.out::println);
6     }
7 }

 

 

跳過:skip

skip方法能夠跳過前幾個元素,從而獲取以後的元素做爲一個新的流。

Stream<T> skip(long n);

若是流的當前長度大於n,則跳過前n個;不然將會獲得一個長度爲0的空流。


1 public class StreamSkip {
2     public static void main(String[] args) {
3         //skip跳過幾個元素
4         Stream<String> stream = Stream.of("魯班七號", "老夫子", "公孫離", "南宮", "甄姬");
5         stream.skip(2).forEach(System.out::println);
6     }
7 }

 

映射:map

map方法能夠將須要的元素映射到另一個集合中。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

該接口須要一個Function函數式接口參數,能夠將當前流中的T類型數據轉換爲另外一種R類型的流。

1 public class StreamMap {
2     public static void main(String[] args){
3         Stream<String> oldStream = Stream.of("1.2", "1.3", "3.5", "12.5", "65.8");
4         Stream<Double> newStream = oldStream.map(Double::parseDouble);
5         newStream.forEach(System.out::println);
6     }
7 }

 

 

聯合concat

若是有兩個流,但願合併成爲一個流,那麼可使用Stream接口的靜態方法concat

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

基本使用:

1 public static void main(String[] args) {
2         //concat,合併流
3         Stream<String> wurenxiaofendui = Stream.of("孫悟空", "豬八戒", "沙和尚", "小白龍", "唐僧");
4         Stream<String> yaojingwurenzu = Stream.of("紫霞","嫦娥","小侍女","四公主","女兒國國王");
5         Stream<String> stringStream = Stream.concat(wurenxiaofendui, yaojingwurenzu);
6         stringStream.forEach(System.out::println);
7     }

 

 

計數:count

count方法用來統計個數

long count();

使用:

 1 public class ListDemo {
 2     public static void main(String[] args) {
 3  4         List<String> list = List.of("喬七七","韓七歲","零零七","魯班七號","上官婉兒");
 5         //篩選帶七的且名字長度爲3的人,統計個數
 6         long count = list.stream().
 7                 filter(s -> s.contains("七")).
 8                 filter(s -> s.length() == 3).count();
 9         System.out.println(count);
10     }
11 }

 

遍歷處理forEach

forEach,可是與for循環中的「for-each」暱稱不一樣,該方法並不保證元素的逐一消費動做在流中是被有序執行的

void forEach(Consumer<? super T> action);

該方法接收一個Consumer接口函數,會將每個流元素交給該函數進行處理。


1 import java.util.stream.Stream;
2 3 public class StreamForEach {
4     public static void main(String[] args) {
5 6         Stream<String>  stream = Stream.of("孫悟空", "豬八戒", "沙和尚", "小白龍", "唐僧");
7         stream.forEach(System.out::println);
8      }
9 }
相關文章
相關標籤/搜索