作者個人研發的在高并發場景下，提供的簡單、穩定、可擴展的延遲消息隊列框架，具有精準的定時任務和延遲隊列處理功能。自開源半年多以來，已成功為十幾家中小型企業提供了精準定時調度方案，經受住了生產環境的考驗。為使更多童鞋受益，現給出開源框架地址：

https://github.com/sunshinelyz/mykit-delay

Stream的中間操作

多個中間操作可以連接起來形成一個流水線，除非流水線上觸發終止操作，否則中間操作不會執行任何的處理!而在終止操作時一次性全部處理，稱為“惰性求值” 。Stream的中間操作是不會有任何結果數據輸出的。

Stream的中間操作在整體上可以分為：篩選與切片、映射、排序。接下來，我們就分別對這些中間操作進行簡要的說明。

篩選與切片

這里，我將與篩選和切片有關的操作整理成如下表格。

接下來，我們列舉幾個簡單的示例，以便加深理解。

為了更好的測試程序，我先構造了一個對象數組，如下所示。

protected List<Employee> list = Arrays.asList( 
    new Employee("張三", 18, 9999.99), 
    new Employee("李四", 38, 5555.55), 
    new Employee("王五", 60, 6666.66), 
    new Employee("趙六", 8, 7777.77), 
    new Employee("田七", 58, 3333.33) 
); 

其中，Employee類的定義如下所示。

@Data 
@Builder 
@ToString 
@NoArgsConstructor 
@AllArgsConstructor 
public class Employee implements Serializable { 
    private static final long serialVersionUID = -9079722457749166858L; 
    private String name; 
    private Integer age; 
    private Double salary; 
} 

Employee類的定義比較簡單，這里，我就不贅述了。之后的示例中，我們都是使用的Employee對象的集合進行操作。好了，我們開始具體的操作案例。

1.filter()方法

filter()方法主要是用于接收Lambda表達式，從流中排除某些元素，其在Stream接口中的源碼如下所示。

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

可以看到，在filter()方法中，需要傳遞Predicate接口的對象，Predicate接口又是個什么鬼呢?點進去看下源碼。

@FunctionalInterface 
public interface Predicate<T> { 
 
    boolean test(T t); 
 
    default Predicate<T> and(Predicate<? super T> other) { 
        Objects.requireNonNull(other); 
        return (t) -> test(t) && other.test(t); 
    } 
 
    default Predicate<T> negate() { 
        return (t) -> !test(t); 
    } 
 
    default Predicate<T> or(Predicate<? super T> other) { 
        Objects.requireNonNull(other); 
        return (t) -> test(t) || other.test(t); 
    } 
 
    static <T> Predicate<T> isEqual(Object targetRef) { 
        return (null == targetRef) 
                ? Objects::isNull 
                : object -> targetRef.equals(object); 
    } 
} 

可以看到，Predicate是一個函數式接口，其中接口中定義的主要方法為test()方法，test()方法會接收一個泛型對象t，返回一個boolean類型的數據。

看到這里，相信大家明白了：filter()方法是根據Predicate接口的test()方法的返回結果來過濾數據的，如果test()方法的返回結果為true，符合規則;如果test()方法的返回結果為false，則不符合規則。

這里，我們可以使用下面的示例來簡單的說明filter()方法的使用方式。

//內部迭代：在此過程中沒有進行過迭代，由Stream api進行迭代 
//中間操作：不會執行任何操作 
Stream<Person> stream = list.stream().filter((e) -> { 
    System.out.println("Stream API 中間操作"); 
    return e.getAge() > 30; 
}); 

我們，在執行終止語句之后，一邊迭代，一邊打印，而我們并沒有去迭代上面集合，其實這是內部迭代，由Stream API 完成。

下面我們來看看外部迭代，也就是我們人為得迭代。

//外部迭代 
Iterator<Person> it = list.iterator(); 
while (it.hasNext()) { 
    System.out.println(it.next()); 
} 

2.limit()方法

主要作用為：截斷流，使其元素不超過給定數量。

先來看limit方法的定義，如下所示。

Stream<T> limit(long maxSize); 

limit()方法在Stream接口中的定義比較簡單，只需要傳入一個long類型的數字即可。

我們可以按照如下所示的代碼來使用limit()方法。

//過濾之后取2個值 
list.stream().filter((e) -> e.getAge() >30 ).limit(2).forEach(System.out :: println); 

在這里，我們可以配合其他得中間操作，并截斷流，使我們可以取得相應個數得元素。而且在上面計算中，只要發現有2條符合條件得元素，則不會繼續往下迭代數據，可以提高效率。

3.skip()方法

跳過元素，返回一個扔掉了前 n 個元素的流。若流中元素 不足 n 個，則返回一個空流。與 limit(n) 互補。

源碼定義如下所示。

Stream<T> skip(long n); 

源碼定義比較簡單，同樣只需要傳入一個long類型的數字即可。其含義是跳過n個元素。

簡單示例如下所示。

//跳過前2個值 
list.stream().skip(2).forEach(System.out :: println); 

4.distinct()方法

篩選，通過流所生成元素的 hashCode() 和 equals() 去 除重復元素。

源碼定義如下所示。

Stream<T> distinct(); 

旨在對流中的元素進行去重。

我們可以如下面的方式來使用disinct()方法。

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

這里有一個需要注意的地方：distinct 需要實體中重寫hashCode()和 equals()方法才可以使用。

映射

關于映射相關的方法如下表所示。

1.map()方法

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

先來看Java8中Stream接口對于map()方法的聲明，如下所示。

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

我們可以按照如下方式使用map()方法。

//將流中每一個元素都映射到map的函數中，每個元素執行這個函數，再返回 
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd"); 
list.stream().map((e) -> e.toUpperCase()).forEach(System.out::printf); 
 
//獲取Person中的每一個人得名字name，再返回一個集合 
List<String> names = this.list.stream().map(Person :: getName).collect(Collectors.toList()); 

2.flatMap()

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

先來看Java8中Stream接口對于flatMap()方法的聲明，如下所示。

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

我們可以使用如下方式使用flatMap()方法，為了便于大家理解，這里，我就貼出了測試flatMap()方法的所有代碼。

/** 
     * flatMap —— 接收一個函數作為參數，將流中的每個值都換成一個流，然后把所有流連接成一個流 
     */ 
    @Test 
    public void testFlatMap () { 
        StreamAPI_Test s = new StreamAPI_Test(); 
        List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd"); 
        list.stream().flatMap((e) -> s.filterCharacter(e)).forEach(System.out::println); 
 
        //如果使用map則需要這樣寫 
        list.stream().map((e) -> s.filterCharacter(e)).forEach((e) -> { 
            e.forEach(System.out::println); 
        }); 
    } 
 
    /** 
     * 將一個字符串轉換為流 
     */ 
    public Stream<Character> filterCharacter(String str){ 
        List<Character> list = new ArrayList<>(); 
        for (Character ch : str.toCharArray()) { 
            list.add(ch); 
        } 
        return list.stream(); 
    } 

其實map方法就相當于Collaction的add方法，如果add的是個集合得話就會變成二維數組，而flatMap 的話就相當于Collaction的addAll方法，參數如果是集合得話，只是將2個集合合并，而不是變成二維數組。

排序

關于排序相關的方法如下表所示。

從上述表格可以看出：sorted有兩種方法，一種是不傳任何參數，叫自然排序，還有一種需要傳Comparator 接口參數，叫做定制排序。

先來看Java8中Stream接口對于sorted()方法的聲明，如下所示。

Stream<T> sorted(); 
Stream<T> sorted(Comparator<? super T> comparator); 

sorted()方法的定義比較簡單，我就不再贅述了。

我們也可以按照如下方式來使用Stream的sorted()方法。

/ 自然排序 
List<Employee> persons = list.stream().sorted().collect(Collectors.toList()); 
 
//定制排序 
List<Employee> persons1 = list.stream().sorted((e1, e2) -> { 
    if (e1.getAge() == e2.getAge()) { 
        return 0; 
    } else if (e1.getAge() > e2.getAge()) { 
        return 1; 
    } else { 
        return -1; 
    } 
}).collect(Collectors.toList()); 

寫在最后

如果覺得文章對你有點幫助，請微信搜索并關注「 冰河技術 」微信公眾號，跟冰河學習Java8新特性。

最后，附上Java8新特性核心知識圖，祝大家在學習Java8新特性時少走彎路。

本文轉載自微信公眾號「冰河技術」，可以通過以下二維碼關注。轉載本文請聯系冰河技術公眾號。