我們一起實戰學習Java8 Stream新特性

作者：九止 2024-10-09 08:42:03

sorted方法的入參是一個比較器Comparator，這里我們直接使用Comparator.comparing方法構建一個根據價格排序的比較器，并使用reversed方法返回一個降序的比較器。最后我們使用終結方法collect(Collectors.toList())將結果收集到集合當中。

引言

大家好，我是了不起。剛剛不久Java23如期發布，但目前國內市場Java8還是占據著主導地位。今天我將模擬實際工作中的需求，帶領大家學習Java8中的Stream新特性，大家可以收藏起來以防在需要的時候找不到。

實體類聲明

@Getter
@Setter
public class ComputerDTO {
    /**
     * 計算機編號
     */
    private String computerNo;
    /**
     * 品牌
     */
    private String brand;
    /**
     * 價格
     */
    private BigDecimal price;
    /**
     * cpu核數
     */
    private Integer coreQuantity;
    /**
     * 內存GB
     */
    private Integer memory;
    /**
     * 硬盤信息，包含容量和類型，如 "500GB HDD" 或 "256GB SSD"
     */
    private String hardDisk;
    /**
     * 產地
     */
    private String place;
}

場景描述

我暫且充當一下產品經理，現在羅列出了下列需求，基本上覆蓋了日常使用Stream流的大多場景，各位小伙伴可以先行看一看有沒有思路。

經典場景

篩選出所有品牌為“abc”的電腦，并按價格降序排序。
計算所有電腦的價格總和。
找出內存最大的電腦的信息。
統計硬盤類型為SSD的電腦數量。
將所有電腦的產地轉換成一個不重復的集合。
創建一個Map，鍵為品牌，值為該品牌的電腦列表。
獲取每個品牌的平均價格。
獲取一個Map，鍵為計算機編號，值為該計算機信息。

組合應用

篩選出價格低于5000元且CPU核數大于等于4的電腦。
找出每個品牌中最貴的電腦，并返回一個包含這些電腦的列表。
統計每個品牌的電腦數量，并按數量降序排序。
找出所有品牌為“abc”且內存大于等于8GB的電腦，并按CPU核數降序排序。
統計每個品牌的平均價格，并找出平均價格最高的品牌。
創建一個Map，鍵為品牌，值為該品牌所有電腦的總價。

經典場景實戰攻克

下面我來帶大家一道一道攻克，并在這個過程中帶大家梳理一下Stream流使用過程中的一些注意事項。

我們假設需要處理的數據是一個ComputerDTO的List，如下：

List<ComputerDTO> computers=getComputers();

Stream流模型的操作很豐富，我們今天將使用到一些常用的方法，這些方法可以被分成兩種。

終結方法：返回值類型不再是Stream類型的方法，不再支持鏈式調用。如count、forEach、collect方法等。

非終結方法：返回值類型仍然是Stream類型的方法，支持鏈式調用。如map、filter、sorted方法等。

場景1

篩選出所有品牌為“abc”的電腦，并按價格降序排序。

List<ComputerDTO> abcComputers = computers.stream()
       .filter(computer -> "abc".equals(computer.getBrand()))
       .sorted(Comparator.comparing(ComputerDTO::getPrice).reversed())
       .collect(Collectors.toList());

首先我們將這個場景拆解成兩個過程，第一個過程是將列表中的所有品牌不為“abc”的電腦過濾掉，這里我們需要使用到filter方法。

filter方法的入參是含一個參數返回結果為boolean類型的函數式接口，這里我們直接使用lambda表達式實現。

需要注意的是filter方法將會保留符合表達式的數據，這里可以和集合的removeIf方法進行對比記憶，并且我們使用stream處理數據并不會改變原集合computers。

第二個過程是將過濾后的結果按照價格降序排序，這里我們使用sorted方法實現。

sorted方法的入參是一個比較器Comparator，這里我們直接使用Comparator.comparing方法構建一個根據價格排序的比較器，并使用reversed方法返回一個降序的比較器。

最后我們使用終結方法collect(Collectors.toList())將結果收集到集合當中。

場景2

計算所有電腦的價格總和。

BigDecimal totalCost = computers.stream()
       .map(ComputerDTO::getPrice)
       .reduce(BigDecimal.ZERO, BigDecimal::add);

這個場景我們需要先將集合中的ComputerDTO對象轉換為價格，因為我們需要的最終結果是一個BigDecimal類型，所以需要先使用map方法對數據進行轉換。

map方法的入參是一個Function函數式接口，下面貼出一張圖幫助大家理解map方法的作用。

圖片

map方法在工作中常常被使用，例如需要根據一個實體類集合獲取一個屬性值集合，通常先使用map方法獲取屬性值，看情況需要可以使用distinct方法去重、filter過濾、sorted方法排序，最后使用collect方法收集起來。

在當前場景中我們需要計算所有電腦的價格總和，所以可以使用reduce終結方法進行匯總。

圖片

場景3

找出內存最大的電腦的信息。

Optional<ComputerDTO> maxMemoryComputer = computers.stream()
       .max(Comparator.comparingInt(ComputerDTO::getMemory));

這個場景簡單粗暴，直接將待處理數據轉成流，然后使用max方法就可以解決，不過需要注意的是max方法返回的數據使用Optional包了一層。

Optional類同樣是Java8提供的，使用isPresent方法可以判斷包含值是否為null，通過get方法可以獲取包含值，如果包含值為null會拋出一個NoSuchElementException異常，所以通常搭配isPresent方法使用。

場景4

統計硬盤類型為SSD的電腦數量。

long ssdCount = computers.stream()
       .filter(computer -> computer.getHardDisk().contains("SSD"))
       .count();

這個場景使用了一個新的終結方法count，count方法用于統計流中元素個數，返回值類型為long類型。

場景5

將所有電腦的產地轉換成一個不重復的集合。

Set<String> places = computers.stream()
       .map(ComputerDTO::getPlace)
       .collect(Collectors.toSet());

這個場景在工作中常常會用到，也是上面提到的map的經典用法，只不過這里將流中數據通過collect(Collectors.toSet())收集到了Set中，利用了Set的特性進行去重，而沒有使用distinct方法進行去重。

這里引申一下，上點難度，如果這里最終需要獲取的是根據產地去重后的ComputerDTO集合呢，使用流的方式又該怎樣實現。

這是工作中另外的一個經典場景，List集合按照對象屬性去重，其實最終也是利用了Set的特性，在Set的構造函數中傳入了自定義比較器！

List<ComputerDTO> newList = computers.stream().collect(Collectors
                .collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(ComputerDTO::getPlace)))
                        , ArrayList::new));

這里使用的Collectors.collectingAndThen方法只是將返回結果Set轉化為了List，核心處理就是Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(ComputerDTO::getPlace)))。

場景6

創建一個Map，鍵為品牌，值為該品牌的電腦列表。

Map<String, List<ComputerDTO>> computersByBrand = computers.stream()
       .collect(Collectors.groupingBy(ComputerDTO::getBrand));

這個場景也是工作中常常會遇到的場景，對原有數據根據某一個緯度進行分組，然后不同組的數據使用不同的邏輯進行處理。Stream為這個需求也提供了專門的方法Collectors.groupingBy。

場景7

獲取每個品牌的平均價格。

Map<String, Double> averagePrices = computers.stream()
       .collect(Collectors.groupingBy(ComputerDTO::getBrand, Collectors.averagingDouble(c -> c.getPrice().doubleValue())));

這個場景是場景6的進階玩法，根據某一個緯度進行分組，分組后再對數據進行處理。

這里使用的是Collectors.groupingBy兩個參數的重載方法。

場景8

獲取一個Map，鍵為計算機編號，值為該計算機信息。

Map<String, ComputerDTO> computerInfoMap = computers.stream().collect(Collectors.toMap(ComputerDTO::getComputerNo, item -> item));

Map<String, ComputerDTO> computerInfoMap = computers.stream().collect(HashMap::new, (m, v) -> m.put(v.getComputerNo(), v), HashMap::putAll);

這個場景在工作中出現的頻率很高，通常有兩種方法去實現，其中Collectors.toMap方法有一個小坑，大家在使用時需要注意一下。

java8的Collectors.toMap的value不能為null。

如果待處理的數據中value值存在null，則會出現莫名其妙的空指針異常，所以我在工作中往往會使用第二種方式。

組合應用代碼參考

通過上面經典場景的講解，其實我們可以注意到，基本上絕大多數的應用都離不開collect方法，這個方法在流的使用中極為重要，在后續的文章中我也會為大家進一步的講解collect方法，敬請期待！

組合場景就是對經典場景中的一些常用API進行組合應用，所以就不在這里一一贅述，僅為大家提供了參考代碼。

篩選出價格低于5000元且CPU核數大于等于4的電腦。

List<ComputerDTO> affordableAndPowerful = computers.stream()
       .filter(computer -> computer.getPrice().compareTo(new BigDecimal("5000")) < 0 && computer.getCoreQuantity() >= 4)
       .collect(Collectors.toList());

找出每個品牌中最貴的電腦，并返回一個包含這些電腦的列表。

Map<String, ComputerDTO> mostExpensivePerBrand = computers.stream()
            .collect(Collectors.groupingBy(ComputerDTO::getBrand,
                    Collectors.collectingAndThen(
                            Collectors.maxBy(Comparator.comparing(ComputerDTO::getPrice)),
                            optional -> optional.orElseThrow(() -> new NoSuchElementException("No computers found for this brand"))
       )
   ));

    List<ComputerDTO> mostExpensiveComputers = new ArrayList<>(mostExpensivePerBrand.values());

統計每個品牌的電腦數量，并按數量降序排序。

Map<String, Long> brandCounts = computers.stream()
       .collect(Collectors.groupingBy(ComputerDTO::getBrand, Collectors.counting()));

   List<Map.Entry<String, Long>> sortedBrandCounts = brandCounts.entrySet().stream()
       .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
       .collect(Collectors.toList());

找出所有品牌為“abc”且內存大于等于8GB的電腦，并按CPU核數降序排序。

List<ComputerDTO> abcHighMemoryComputers = computers.stream()
       .filter(computer -> "abc".equals(computer.getBrand()) && computer.getMemory() >= 8)
       .sorted(Comparator.comparingInt(ComputerDTO::getCoreQuantity).reversed())
       .collect(Collectors.toList());

統計每個品牌的平均價格，并找出平均價格最高的品牌。

Optional<Map.Entry<String, Double>> highestAveragePrice = computers.stream()
       .collect(Collectors.groupingBy(
           ComputerDTO::getBrand,
           Collectors.averagingDouble(c -> c.getPrice().doubleValue())
       ))
       .entrySet().stream()
       .max(Map.Entry.comparingByValue());

   String highestBrand = highestAveragePrice.map(Map.Entry::getKey).orElse(null);
   double highestAverage = highestAveragePrice.map(Map.Entry::getValue).orElse(0.0);

創建一個Map，鍵為品牌，值為該品牌所有電腦的總價。

Map<String, BigDecimal> totalPricesByBrand = computers.stream()
       .collect(Collectors.groupingBy(
           ComputerDTO::getBrand,
           Collectors.reducing(BigDecimal.ZERO, ComputerDTO::getPrice, BigDecimal::add)
       ));

結語

學會使用java8的Stream新特性，可以極大的減少工作中的代碼量，可以使自己的代碼看起來更整潔，同時很多框架源碼中也大量使用Stream，掌握了它也可以為我們閱讀源碼提供幫助，希望這篇文章可以給大家帶來幫助。

責任編輯：武曉燕來源： Java極客技術