計算機程式的思維邏輯 (93) - 函式式資料處理 (下)

swiftma發表於2017-08-22

本系列文章經補充和完善,已修訂整理成書《Java程式設計的邏輯》(馬俊昌著),由機械工業出版社華章分社出版,於2018年1月上市熱銷,讀者好評如潮!各大網店和書店有售,歡迎購買:京東自營連結

計算機程式的思維邏輯 (93) - 函式式資料處理 (下)

上節初步介紹了Java 8中的函式式資料處理,對於collect方法,我們只是演示了其最基本的應用,它還有很多強大的功能,比如,可以分組統計彙總,實現類似資料庫查詢語言SQL中的group by功能。

具體都有哪些功能?有什麼用?如何使用?基本原理是什麼?本節進行詳細討論,我們先來進一步理解下collect方法。

理解collect

在上節中,過濾得到90分以上的學生列表,程式碼是這樣的:

List<Student> above90List = students.stream()
        .filter(t->t.getScore()>90)
        .collect(Collectors.toList());
複製程式碼

最後的collect呼叫看上去很神奇,它到底是怎麼把Stream轉換為List<Student>的呢?先看下collect方法的定義:

<R, A> R collect(Collector<? super T, A, R> collector)
複製程式碼

它接受一個收集器collector作為引數,型別是Collector,這是一個介面,它的定義基本是:

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}
複製程式碼

在順序流中,collect方法與這些介面方法的互動大概是這樣的:

//首先呼叫工廠方法supplier建立一個存放處理狀態的容器container,型別為A
A container = collector.supplier().get();

//然後對流中的每一個元素t,呼叫累加器accumulator,引數為累計狀態container和當前元素t
for (T t : data)
   collector.accumulator().accept(container, t);

//最後呼叫finisher對累計狀態container進行可能的調整,型別轉換(A轉換為R),並返回結果
return collector.finisher().apply(container);
複製程式碼

combiner只在並行流中有用,用於合併部分結果。characteristics用於標示收集器的特徵,Collector介面的呼叫者可以利用這些特徵進行一些優化,Characteristics是一個列舉,有三個值:CONCURRENT, UNORDERED和IDENTITY_FINISH,它們的含義我們後面通過例子簡要說明,目前可以忽略。

Collectors.toList()具體是什麼呢?看下程式碼:

public static <T>
Collector<T, ?, List<T>> toList() {
    return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                               (left, right) -> { left.addAll(right); return left; },
                               CH_ID);
}
複製程式碼

它的實現類是CollectorImpl,這是Collectors內部的一個私有類,實現很簡單,主要就是定義了兩個構造方法,接受函式式引數並賦值給內部變數。對toList來說:

  • supplier的實現是ArrayList::new,也就是建立一個ArrayList作為容器
  • accumulator的實現是List::add,也就是將碰到的每一個元素加到列表中,
  • 第三個引數是combiner,表示合併結果
  • 第四個引數CH_ID是一個靜態變數,只有一個特徵IDENTITY_FINISH,表示finisher沒有什麼事情可以做,就是把累計狀態container直接返回

也就是說,collect(Collectors.toList())背後的虛擬碼如下所示:

List<T> container = new ArrayList<>();
for (T t : data)
   container.add(t);
return container;
複製程式碼

與toList類似的容器收集器還有toSet, toCollection, toMap等,我們來看下。

容器收集器

toSet

toSet的使用與toList類似,只是它可以排重,就不舉例了。toList背後的容器是ArrayList,toSet背後的容器是HashSet,其程式碼為:

public static <T>
Collector<T, ?, Set<T>> toSet() {
    return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,
                               (left, right) -> { left.addAll(right); return left; },
                               CH_UNORDERED_ID);
}
複製程式碼

CH_UNORDERED_ID是一個靜態變數,它的特徵有兩個,一個是IDENTITY_FINISH,表示返回結果即為Supplier建立的HashSet,另一個是UNORDERED,表示收集器不會保留順序,這也容易理解,因為背後容器是HashSet。

toCollection

toCollection是一個通用的容器收集器,可以用於任何Collection介面的實現類,它接受一個工廠方法Supplier作為引數,具體程式碼為:

public static <T, C extends Collection<T>>
Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
    return new CollectorImpl<>(collectionFactory, Collection<T>::add,
                               (r1, r2) -> { r1.addAll(r2); return r1; },
                               CH_ID);
}
複製程式碼

比如,如果希望排重但又希望保留出現的順序,可以使用LinkedHashSet,Collector可以這麼建立:

Collectors.toCollection(LinkedHashSet::new)
複製程式碼

toMap

toMap將元素流轉換為一個Map,我們知道,Map有鍵和值兩部分,toMap至少需要兩個函式引數,一個將元素轉換為鍵,另一個將元素轉換為值,其基本定義為:

public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper)
複製程式碼

返回結果為Map<K,U>,keyMapper將元素轉換為鍵,valueMapper將元素轉換為值。比如,將學生流轉換為學生名稱和分數的Map,程式碼可以為:

Map<String,Double> nameScoreMap = students.stream().collect(
        Collectors.toMap(Student::getName, Student::getScore));
複製程式碼

這裡,Student::getName是keyMapper,Student::getScore是valueMapper。

實踐中,經常需要將一個物件列表按主鍵轉換為一個Map,以便以後按照主鍵進行快速查詢,比如,假定Student的主鍵是id,希望轉換學生流為學生id和學生物件的Map,程式碼可以為:

Map<String, Student> byIdMap = students.stream().collect(
        Collectors.toMap(Student::getId, t -> t));
複製程式碼

t->t是valueMapper,表示值就是元素本身,這個函式用的比較多,介面Function定義了一個靜態函式identity表示它,也就是說,上面的程式碼可以替換為:

Map<String, Student> byIdMap = students.stream().collect(
        Collectors.toMap(Student::getId, Function.identity()));
複製程式碼

上面的toMap假定元素的鍵不能重複,如果有重複的,會丟擲異常,比如:

Map<String,Integer> strLenMap = Stream.of("abc","hello","abc").collect(
        Collectors.toMap(Function.identity(), t->t.length()));
複製程式碼

希望得到字串與其長度的Map,但由於包含重複字串"abc",程式會丟擲異常。這種情況下,我們希望的是程式忽略後面重複出現的元素,這時,可以使用另一個toMap函式:

public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper,
    BinaryOperator<U> mergeFunction)    
複製程式碼

相比前面的toMap,它接受一個額外的引數mergeFunction,它用於處理衝突,在收集一個新元素時,如果新元素的鍵已經存在了,系統會將新元素的值與鍵對應的舊值一起傳遞給mergeFunction得到一個值,然後用這個值給鍵賦值。

對於前面字串長度的例子,新值與舊值其實是一樣的,我們可以用任意一個值,程式碼可以為:

Map<String,Integer> strLenMap = Stream.of("abc","hello","abc").collect(
        Collectors.toMap(Function.identity(),
                t->t.length(), (oldValue,value)->value));
複製程式碼

有時,我們可能希望合併新值與舊值,比如一個聯絡人列表,對於相同的聯絡人,我們希望合併電話號碼,mergeFunction可以定義為:

BinaryOperator<String> mergeFunction = (oldPhone,phone)->oldPhone+","+phone;
複製程式碼

toMap還有一個更為通用的形式:

public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper,
    BinaryOperator<U> mergeFunction,
    Supplier<M> mapSupplier) 
複製程式碼

相比前面的toMap,多了一個mapSupplier,它是Map的工廠方法,對於前面兩個toMap,其mapSupplier其實是HashMap::new。我們知道,HashMap是沒有任何順序的,如果希望保持元素出現的順序,可以替換為LinkedHashMap,如果希望收集的結果排序,可以使用TreeMap。

toMap主要用於順序流,對於併發流,Collectors有專門的名稱為toConcurrentMap的收集器,它內部使用ConcurrentHashMap,用法類似,具體我們就不討論了。

字串收集器

除了將元素流收集到容器中,另一個常見的操作是收集為一個字串。比如,獲取所有的學生名稱,用逗號連線起來,傳統上,程式碼看上去像這樣:

StringBuilder sb = new StringBuilder();
for(Student t : students){
    if(sb.length()>0){
        sb.append(",");
    }
    sb.append(t.getName());
}
return sb.toString();
複製程式碼

針對這種常見的需求,Collectors提供了joining收集器:

public static Collector<CharSequence, ?, String> joining()
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)
public static Collector<CharSequence, ?, String> joining(
    CharSequence delimiter, CharSequence prefix, CharSequence suffix) 
複製程式碼

第一個就是簡單的把元素連線起來,第二個支援一個分隔符,第三個更為通用,可以給整個結果字串加個字首和字尾。比如:

String result = Stream.of("abc","老馬","hello")
        .collect(Collectors.joining(",", "[", "]"));
System.out.println(result);                                        ```        
輸出為:
```java
[abc,老馬,hello]
複製程式碼

joining的內部也利用了StringBuilder,比如,第一個joining函式的程式碼為:

public static Collector<CharSequence, ?, String> joining() {
    return new CollectorImpl<CharSequence, StringBuilder, String>(
            StringBuilder::new, StringBuilder::append,
            (r1, r2) -> { r1.append(r2); return r1; },
            StringBuilder::toString, CH_NOID);
}
複製程式碼

supplier是StringBuilder::new,accumulator是StringBuilder::append,finisher是StringBuilder::toString,CH_NOID表示特徵集為空。

分組

分組類似於資料庫查詢語言SQL中的group by語句,它將元素流中的每個元素分到一個組,可以針對分組再進行處理和收集,分組的功能比較強大,我們逐步來說明。

為便於舉例,我們先修改下學生類Student,增加一個欄位grade,表示年級,改下構造方法:

public Student(String name, String grade, double score) {
    this.name = name;
    this.grade = grade;
    this.score = score;
}
複製程式碼

示例學生列表students改為:

static List<Student> students = Arrays.asList(new Student[] {
        new Student("zhangsan", "1", 91d),
        new Student("lisi", "2", 89d),
        new Student("wangwu", "1", 50d),
        new Student("zhaoliu", "2", 78d),
        new Student("sunqi", "1", 59d)});            
複製程式碼

基本用法

最基本的分組收集器為:

public static <T, K> Collector<T, ?, Map<K, List<T>>>
    groupingBy(Function<? super T, ? extends K> classifier)
複製程式碼

引數是一個型別為Function的分組器classifier,它將型別為T的元素轉換為型別為K的一個值,這個值表示分組值,所有分組值一樣的元素會被歸為同一個組,放到一個列表中,所以返回值型別是Map<K, List>。 比如,將學生流按照年級進行分組,程式碼為:

Map<String, List<Student>> groups = students.stream()
        .collect(Collectors.groupingBy(Student::getGrade));
複製程式碼

學生會分為兩組,第一組鍵為"1",分組學生包括"zhangsan", "wangwu"和"sunqi",第二組鍵為"2",分組學生包括"lisi", "zhaoliu"。

這段程式碼基本等同於如下程式碼:

Map<String, List<Student>> groups = new HashMap<>();
for (Student t : students) {
    String key = t.getGrade();
    List<Student> container = groups.get(key);
    if (container == null) {
        container = new ArrayList<>();
        groups.put(key, container);
    }
    container.add(t);
}
System.out.println(groups);
複製程式碼

顯然,使用groupingBy要簡潔清晰的多,但它到底是怎麼實現的呢?

基本原理

groupingBy的程式碼為:

public static <T, K> Collector<T, ?, Map<K, List<T>>>
groupingBy(Function<? super T, ? extends K> classifier) {
    return groupingBy(classifier, toList());
}
複製程式碼

它呼叫了第二個groupingBy方法,傳遞了toList收集器,其程式碼為:

public static <T, K, A, D>
Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                      Collector<? super T, A, D> downstream) {
    return groupingBy(classifier, HashMap::new, downstream);
}
複製程式碼

這個方法接受一個下游收集器downstream作為引數,然後傳遞給下面更通用的函式:

public static <T, K, D, A, M extends Map<K, D>>
Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                              Supplier<M> mapFactory,
                              Collector<? super T, A, D> downstream)
複製程式碼

classifier還是分組器,mapFactory是返回Map的工廠方法,預設是HashMap::new,downstream表示下游收集器,下游收集器負責收集同一個分組內元素的結果

對最通用的groupingBy函式返回的收集器,其收集元素的基本過程和虛擬碼為:

//先建立一個存放結果的Map
Map map = mapFactory.get();
for (T t : data) {
    // 對每一個元素,先分組
    K key = classifier.apply(t);
    // 找存放分組結果的容器,如果沒有,讓下游收集器建立,並放到Map中
    A container = map.get(key);
    if (container == null) {
        container = downstream.supplier().get();
        map.put(key, container);
    }
    // 將元素交給下游收集器(即分組收集器)收集
    downstream.accumulator().accept(container, t);
}
// 呼叫分組收集器的finisher方法,轉換結果
for (Map.Entry entry : map.entrySet()) {
    entry.setValue(downstream.finisher().apply(entry.getValue()));
}
return map;
複製程式碼

在最基本的groupingBy函式中,下游收集器是toList,但下游收集器還可以是其他收集器,甚至是groupingBy,以構成多級分組,下面我們來看更多的示例。

分組計數、找最大/最小元素

將元素按一定標準分為多組,然後計算每組的個數,按一定標準找最大或最小元素,這是一個常見的需求,Collectors提供了一些對應的收集器,一般用作下游收集器,比如:

//計數
public static <T> Collector<T, ?, Long> counting()
//計算最大值
public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
//計算最小值
public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
複製程式碼

還有更為通用的名為reducing的歸約收集器,我們就不介紹了,下面,看一些例子。

為了便於使用Collectors中的方法,我們將其中的方法靜態匯入,即加入如下程式碼:

import static java.util.stream.Collectors.*;
複製程式碼

統計每個年級的學生個數,程式碼可以為:

Map<String, Long> gradeCountMap = students.stream().collect(
        groupingBy(Student::getGrade, counting()));
複製程式碼

統計一個單詞流中每個單詞的個數,按出現順序排序,程式碼示例為:

Map<String, Long> wordCountMap =
        Stream.of("hello","world","abc","hello").collect(
            groupingBy(Function.identity(), LinkedHashMap::new, counting()));
複製程式碼

獲取每個年級分數最高的一個學生,程式碼可以為:

Map<String, Optional<Student>> topStudentMap = students.stream().collect(
        groupingBy(Student::getGrade,
                maxBy(Comparator.comparing(Student::getScore))));
複製程式碼

需要說明的是,這個分組收集結果是Optional,而不是Student,這是因為maxBy處理的流可能是空流,但對我們的例子,這是不可能的,為了直接得到Student,可以使用Collectors的另一個收集器collectingAndThen,在得到Optional後呼叫Optional的get方法,如下所示:

Map<String, Student> topStudentMap = students.stream().collect(
        groupingBy(Student::getGrade,
                collectingAndThen(
                        maxBy(Comparator.comparing(Student::getScore)),
                        Optional::get)));

關於collectingAndThen,我們待會再進一步討論。                   
複製程式碼

分組數值統計

除了基本的分組計數,還經常需要進行一些分組數值統計,比如求學生分數的和、平均分、最高分/最低分等,針對int,long和double型別,Collectors提供了專門的收集器,比如:

//求平均值,int和long也有類似方法
public static <T> Collector<T, ?, Double>
    averagingDouble(ToDoubleFunction<? super T> mapper)
//求和,long和double也有類似方法
public static <T> Collector<T, ?, Integer>
    summingInt(ToIntFunction<? super T> mapper)    
//求多種彙總資訊,int和double也有類似方法
//LongSummaryStatistics包括個數、最大值、最小值、和、平均值等多種資訊
public static <T> Collector<T, ?, LongSummaryStatistics>
    summarizingLong(ToLongFunction<? super T> mapper)
複製程式碼

比如,按年級統計學生分數資訊,程式碼可以為:

Map<String, DoubleSummaryStatistics> gradeScoreStat =
    students.stream().collect(
            groupingBy(Student::getGrade,
                    summarizingDouble(Student::getScore)));
複製程式碼

分組內的map

對於每個分組內的元素,我們感興趣的可能不是元素本身,而是它的某部分資訊,在上節介紹的Stream API中,Stream有map方法,可以將元素進行轉換,Collectors也為分組元素提供了函式mapping,如下所示:

public static <T, U, A, R>
Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper,
    Collector<? super U, A, R> downstream)
複製程式碼

交給下游收集器downstream的不再是元素本身,而是應用轉換函式mapper之後的結果。比如,對學生按年級分組,得到學生名稱列表,程式碼可以為:

Map<String, List<String>> gradeNameMap =
        students.stream().collect(
                groupingBy(Student::getGrade,
                        mapping(Student::getName, toList())));
System.out.println(gradeNameMap);      
複製程式碼

輸出為:

{1=[zhangsan, wangwu, sunqi], 2=[lisi, zhaoliu]}
複製程式碼

分組結果處理(filter/sort/skip/limit)

對分組後的元素,我們可以計數,找最大/最小元素,計算一些數值特徵,還可以轉換後(map)再收集,那可不可以像上節介紹的Stream API一樣,進行排序(sort)、過濾(filter)、限制返回元素(skip/limit)呢?Collector沒有專門的收集器,但有一個通用的方法:

public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(
    Collector<T,A,R> downstream, Function<R,RR> finisher)
複製程式碼

這個方法接受一個下游收集器downstream和一個finisher,返回一個收集器,它的主要程式碼為:

return new CollectorImpl<>(downstream.supplier(),
    downstream.accumulator(),
    downstream.combiner(),
    downstream.finisher().andThen(finisher),
    characteristics);
複製程式碼

也就是說,它在下游收集器的結果上又呼叫了finisher。利用這個finisher,我們可以實現多種功能,下面看一些例子。

收集完再排序,可以定義如下方法:

public static <T> Collector<T, ?, List<T>> collectingAndSort(
        Collector<T, ?, List<T>> downstream,
        Comparator<? super T> comparator) {
    return Collectors.collectingAndThen(downstream, (r) -> {
        r.sort(comparator);
        return r;
    });
}
複製程式碼

比如,將學生按年級分組,分組內學生按照分數由高到低進行排序,利用這個方法,程式碼可以為:

Map<String, List<Student>> gradeStudentMap =
    students.stream().collect(
            groupingBy(Student::getGrade,
                    collectingAndSort(toList(),
                            Comparator.comparing(Student::getScore).reversed())));
複製程式碼

針對這個需求,也可以先對流進行排序,然後再分組。

收集完再過濾,可以定義如下方法:

public static <T> Collector<T, ?, List<T>> collectingAndFilter(
        Collector<T, ?, List<T>> downstream,
        Predicate<T> predicate) {
    return Collectors.collectingAndThen(downstream, (r) -> {
        return r.stream().filter(predicate).collect(Collectors.toList());
    });
}
複製程式碼

比如,將學生按年級分組,分組後,每個分組只保留不及格的學生(低於60分),利用這個方法,程式碼可以為:

Map<String, List<Student>> gradeStudentMap =
    students.stream().collect(
            groupingBy(Student::getGrade,
                    collectingAndFilter(toList(), t->t.getScore()<60)));
複製程式碼

針對這個需求,也可以先對流進行過濾,然後再分組。

收集完,只返回特定區間的結果,可以定義如下方法:

public static <T> Collector<T, ?, List<T>> collectingAndSkipLimit(
        Collector<T, ?, List<T>> downstream, long skip, long limit) {
    return Collectors.collectingAndThen(downstream, (r) -> {
        return r.stream().skip(skip).limit(limit).collect(Collectors.toList());
    });
}
複製程式碼

比如,將學生按年級分組,分組後,每個分組只保留前兩名的學生,程式碼可以為:

Map<String, List<Student>> gradeStudentMap =
    students.stream()
        .sorted(Comparator.comparing(Student::getScore).reversed())
        .collect(groupingBy(Student::getGrade,
                    collectingAndSkipLimit(toList(), 0, 2)));
複製程式碼

這次,我們先對學生流進行了排序,然後再進行了分組。

分割槽

分組的一個特殊情況是分割槽,就是將流按true/false分為兩個組,Collectors有專門的分割槽函式:

public static <T> Collector<T, ?, Map<Boolean, List<T>>>
    partitioningBy(Predicate<? super T> predicate)
public static <T, D, A> Collector<T, ?, Map<Boolean, D>>
    partitioningBy(Predicate<? super T> predicate,
    Collector<? super T, A, D> downstream)    
複製程式碼

第一個的下游收集器為toList(),第二個可以指定一個下游收集器。

比如,將學生按照是否及格(大於等於60分)分為兩組,程式碼可以為:

Map<Boolean, List<Student>> byPass = students.stream().collect(
    partitioningBy(t->t.getScore()>=60));
複製程式碼

按是否及格分組後,計算每個分組的平均分,程式碼可以為:

Map<Boolean, Double> avgScoreMap = students.stream().collect(
        partitioningBy(t->t.getScore()>=60,
            averagingDouble(Student::getScore)));    
複製程式碼

多級分組

groupingBy和partitioningBy都可以接受一個下游收集器,而下游收集器又可以是分組或分割槽。

比如,按年級對學生分組,分組後,再按照是否及格對學生進行分割槽,程式碼可以為:

Map<String, Map<Boolean, List<Student>>> multiGroup =
        students.stream().collect(
                groupingBy(Student::getGrade,
                        partitioningBy(t->t.getScore()>=60)));    
複製程式碼

小結

本節主要討論了各種收集器,包括容器收集器、字串收集器、分組和分割槽收集器等。

對於分組和分割槽,它們接受一個下游收集器,對同一個分組或分割槽內的元素進行進一步收集,下游收集器還可以是分組或分割槽,以構建多級分組,有一些收集器主要用於分組,比如counting, maxBy, minBy, summarizingDouble等。

mapping和collectingAndThen也都接受一個下游收集器,mapping在把元素交給下游收集器之前先進行轉換,而collectingAndThen對下游收集器的結果進行轉換,組合利用它們,可以構造更為靈活強大的收集器。

至此,關於Java 8中的函式式資料處理Stream API,我們就介紹完了,Stream API提供了集合資料處理的常用函式,利用它們,可以簡潔地實現大部分常見需求,大大減少程式碼,提高可讀性

對於併發程式設計,Java 8也提供了一個新的類CompletableFuture,類似於Stream API對集合資料的流水線式操作,使用CompletableFuture,可以實現對多個非同步任務進行流水線式操作,它具體是什麼呢?

(與其他章節一樣,本節所有程式碼位於 github.com/swiftma/pro…,位於包shuo.laoma.java8.c93下)


未完待續,檢視最新文章,敬請關注微信公眾號“老馬說程式設計”(掃描下方二維碼),從入門到高階,深入淺出,老馬和你一起探索Java程式設計及計算機技術的本質。用心原創,保留所有版權。

計算機程式的思維邏輯 (93) - 函式式資料處理 (下)

相關文章