腳本之家服務器常用軟件

快捷導航

Java?Stream流語法示例詳解

更新時間：2022年04月07日 10:08:57 作者：liangshitian

這篇文章主要為大家詳細介紹了Java的Stream流，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助

如何使用Stream?

聚合操作是Java 8針對集合類，使編程更為便利的方式，可以與Lambda表達式一起使用，達到更加簡潔的目的。

前面例子中，對聚合操作的使用可以歸結為3個部分：

1) 創(chuàng)建Stream:通過stream()方法，取得集合對象的數(shù)據(jù)集。

2) Intermediate:通過一系列中間（Intermediate）方法，對數(shù)據(jù)集進行過濾、檢索等數(shù)據(jù)集的再次處理。如上例中，使用filter()方法來對數(shù)據(jù)集進行過濾。

3) Terminal通過最終（terminal）方法完成對數(shù)據(jù)集中元素的處理。如上例中，使用forEach()完成對過濾后元素的打印。

在一次聚合操作中，可以有多個Intermediate，但是有且只有一個Terminal。也就是說，在對一個Stream可以進行多次轉換操作，并不是每次都對Stream的每個元素執(zhí)行轉換。并不像for循環(huán)中，循環(huán)N次，其時間復雜度就是N。轉換操作是lazy(惰性求值)的，只有在Terminal操作執(zhí)行時，才會一次性執(zhí)行。可以這么認為，Stream 里有個操作函數(shù)的集合，每次轉換操作就是把轉換函數(shù)放入這個集合中，在 Terminal 操作的時候循環(huán) Stream 對應的集合，然后對每個元素執(zhí)行所有的函數(shù)。

Stream的操作分類

剛才提到的Stream的操作有Intermediate、Terminal和Short-circuiting：

Intermediate：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 skip、 parallel、 sequential、 unordered

Terminal：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、iterator

Short-circuiting： anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

1、創(chuàng)建流

如果是數(shù)組的話，可以使用 Arrays.stream() 或者 Stream.of() 創(chuàng)建流；如果是集合的話，可以直接使用 stream() 方法創(chuàng)建流，因為該方法已經(jīng)添加到 Collection 接口中。

public class CreateStreamDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"武漢加油", "中國加油", "世界加油"};
        Stream<String> stream = Arrays.stream(arr);
        stream = Stream.of("武漢加油", "中國加油", "世界加油");
        List<String> list = new ArrayList<>();
        list.add("武漢加油");
        list.add("中國加油");
        list.add("世界加油");
        stream = list.stream();
    }
}

查看 Stream 源碼的話，你會發(fā)現(xiàn) of() 方法內部其實調用了 Arrays.stream() 方法。

public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

另外，集合還可以調用 parallelStream() 方法創(chuàng)建并發(fā)流，默認使用的是 ForkJoinPool.commonPool()線程池。

List<Long> aList = new ArrayList<>();
Stream<Long> parallelStream = aList.parallelStream();

2、操作流

Stream 類提供了很多有用的操作流的方法，我來挑一些常用的給你介紹一下。

1）過濾

通過 filter() 方法可以從流中篩選出我們想要的元素。

public class FilterStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰倫");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<String> stream = list.stream().filter(element -> element.contains("王"));
        stream.forEach(System.out::println);
    }
}

filter() 方法接收的是一個 Predicate（Java 8 新增的一個函數(shù)式接口，接受一個輸入?yún)?shù)返回一個布爾值結果）類型的參數(shù)，因此，我們可以直接將一個 Lambda 表達式傳遞給該方法，比如說 element -> element.contains("王") 就是篩選出帶有“王”的字符串。

forEach() 方法接收的是一個 Consumer（Java 8 新增的一個函數(shù)式接口，接受一個輸入?yún)?shù)并且無返回的操作）類型的參數(shù)，類名 :: 方法名是 Java 8 引入的新語法，System.out 返回 PrintStream 類，println 方法你應該知道是打印的。

stream.forEach(System.out::println); 相當于在 for 循環(huán)中打印，類似于下面的代碼：

for (String s : strs) {
    System.out.println(s);
}

很明顯，一行代碼看起來更簡潔一些。來看一下程序的輸出結果：

王力宏

2）映射

如果想通過某種操作把一個流中的元素轉化成新的流中的元素，可以使用 map() 方法。

public class MapStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰倫");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);
    }
}

map() 方法接收的是一個 Function（Java 8 新增的一個函數(shù)式接口，接受一個輸入?yún)?shù) T，返回一個結果 R）類型的參數(shù)，此時參數(shù) 為 String 類的 length 方法，也就是把 Stream<String> 的流轉成一個 Stream<Integer> 的流。

程序輸出的結果如下所示：

3
3
2
3

3）匹配

Stream 類提供了三個方法可供進行元素匹配，它們分別是：

anyMatch()，只要有一個元素匹配傳入的條件，就返回 true。

allMatch()，只有有一個元素不匹配傳入的條件，就返回 false；如果全部匹配，則返回 true。

noneMatch()，只要有一個元素匹配傳入的條件，就返回 false；如果全部匹配，則返回 true。

public class MatchStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰倫");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }
}

因為“王力宏”以“王”字開頭，所以 anyMatchFlag 應該為 true；因為“周杰倫”、“王力宏”、“陶喆”、“林俊杰”的字符串長度都大于 1，所以 allMatchFlag 為 true；因為 4 個字符串結尾都不是“沉”，所以 noneMatchFlag 為 true。

程序輸出的結果如下所示：

true
true
true

4）組合

reduce() 方法的主要作用是把 Stream 中的元素組合起來，它有兩種用法：

Optional<T> reduce(BinaryOperator<T> accumulator)

沒有起始值，只有一個參數(shù)，就是運算規(guī)則，此時返回 Optional。

T reduce(T identity, BinaryOperator<T> accumulator)

有起始值，有運算規(guī)則，兩個參數(shù)，此時返回的類型和起始值類型一致。

來看下面這個例子。

public class ReduceStreamDemo {
    public static void main(String[] args) {
        Integer[] ints = {0, 1, 2, 3};
        List<Integer> list = Arrays.asList(ints);
        Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
        Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
        System.out.println(optional.orElse(0));
        System.out.println(optional1.orElse(0));
        int reduce = list.stream().reduce(6, (a, b) -> a + b);
        System.out.println(reduce);
        int reduce1 = list.stream().reduce(6, Integer::sum);
        System.out.println(reduce1);
    }
}

運算規(guī)則可以是 Lambda 表達式（比如 (a, b) -> a + b），也可以是類名::方法名（比如 Integer::sum）。

程序運行的結果如下所示：

6
6
12
12

0、1、2、3 在沒有起始值相加的時候結果為 6；有起始值 6 的時候結果為 12。

3、轉換流

既然可以把集合或者數(shù)組轉成流，那么也應該有對應的方法，將流轉換回去——collect() 方法就滿足了這種需求。

public class CollectStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰倫");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        String[] strArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));
        List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
        List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(list1);
        System.out.println(list2);
        String str = list.stream().collect(Collectors.joining(", ")).toString();
        System.out.println(str);
    }
}

toArray() 方法可以將流轉換成數(shù)組，你可能比較好奇的是 String[]::new，它是什么東東呢？來看一下 toArray() 方法的源碼。

<A> A[] toArray(IntFunction<A[]> generator);

也就是說 String[]::new 是一個 IntFunction，一個可以產生所需的新數(shù)組的函數(shù)，可以通過反編譯字節(jié)碼看看它到底是什么：

String[] strArray = (String[])list.stream().toArray((x$0) -> {
    return new String[x$0];
});
System.out.println(Arrays.toString(strArray));

也就是相當于返回了一個指定長度的字符串數(shù)組。

當我們需要把一個集合按照某種規(guī)則轉成另外一個集合的時候，就可以配套使用 map() 方法和 collect() 方法。

List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());

通過 stream() 方法創(chuàng)建集合的流后，再通過 map(String:length) 將其映射為字符串長度的一個新流，最后通過 collect() 方法將其轉換成新的集合。

Collectors 是一個收集器的工具類，內置了一系列收集器實現(xiàn)，比如說 toList() 方法將元素收集到一個新的 java.util.List 中；比如說 toCollection() 方法將元素收集到一個新的 java.util.ArrayList 中；比如說 joining() 方法將元素收集到一個可以用分隔符指定的字符串中。

來看一下程序的輸出結果：