1. 創(chuàng)建映射來緩存實體

在 Map 中緩存實體可以通過減少從數(shù)據(jù)庫或其他數(shù)據(jù)源重復獲取數(shù)據(jù)的需要來提高性能。使用Java Streams，您可以輕松創(chuàng)建這樣的緩存。

示例代碼

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<Integer, User> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}

在上面的代碼中，我們使用 Collectors.toMap() 將 User 對象列表轉換為 Map，其中鍵是用戶的 ID，值是 User 對象本身。這有效地創(chuàng)建了用戶實體的緩存。

演示結果

{1=User{id=1, name='Alice'}, 2=User{id=2, name='Bob'}, 3=User{id=3, name='Charlie'}}

2. 創(chuàng)建嵌套映射

當您需要將數(shù)據(jù)分類為多個級別時，嵌套映射非常有用。例如，您可能希望按部門然后按角色對用戶進行分組。

示例代碼

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String role;
    private String name;

    // Constructors, getters, setters
}

public class NestedMapExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("HR", "Manager", "Alice"),
            new User("IT", "Developer", "Bob"),
            new User("IT", "Manager", "Charlie")
        );

        Map<String, Map<String, List<User>>> nestedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.groupingBy(User::getRole)));

        System.out.println(nestedMap);
    }
}

此代碼演示了如何使用 Collectors.groupingBy() 創(chuàng)建嵌套 Map。外部 Map 按部門對用戶進行分組，而內部 Map 進一步按角色對用戶進行分組。

演示結果

{HR={Manager=[User{name='Alice'}]}, IT={Developer=[User{name='Bob'}], Manager=[User{name='Charlie'}]}}

3. 創(chuàng)建具有兩個值的映射

有時，您可能希望在 Map 中存儲單個鍵的多個屬性。使用地圖
>
可能是一個有效的解決方案。

示例代碼

import java.util.List;
import java.util.Map;
import java.util.AbstractMap.SimpleEntry;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;
    private int age;

    // Constructors, getters, setters
}

public class MapWithTwoValuesExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice", 30),
            new User(2, "Bob", 25),
            new User(3, "Charlie", 35)
        );

        Map<Integer, Map.Entry<String, Integer>> userMap = users.stream()
            .collect(Collectors.toMap(User::getId, user -> 
                new SimpleEntry<>(user.getName(), user.getAge())));

        System.out.println(userMap);
    }
}

在這里，我們使用 SimpleEntry 創(chuàng)建一個 Map，其中包含與每個用戶 ID 關聯(lián)的兩個值（姓名和年齡）。

演示結果

{1=Alice=30, 2=Bob=25, 3=Charlie=35}

4. 分組依據(jù)和映射

分組和映射在一起可以簡化復雜的數(shù)據(jù)轉換，例如將對象列表轉換為分組的Map，其中每個組包含特定屬性。

示例代碼

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String name;

    // Constructors, getters, setters
}

public class GroupingByMappingExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("HR", "Alice"),
            new User("IT", "Bob"),
            new User("HR", "Charlie")
        );

        Map<String, List<String>> groupedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.mapping(User::getName, Collectors.toList())));

        System.out.println(groupedMap);
    }
}

在此示例中，我們按部門對用戶進行分組，然后將 User 對象映射到他們的名稱，創(chuàng)建一個 Map，其中每個部門與名稱列表相關聯(lián)。

演示結果

{HR=[Alice, Charlie], IT=[Bob]}

5. 分組依據(jù)、映射和歸約

結合分組、映射和歸約可以讓您有效地聚合數(shù)據(jù)，例如對值求和或查找每個組中的最大值。

示例代碼

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Transaction {
    private String type;
    private int amount;

    // Constructors, getters, setters
}

public class GroupingByMappingReducingExample {
    public static void main(String[] args) {
        List<Transaction> transactions = List.of(
            new Transaction("Deposit", 100),
            new Transaction("Deposit", 200),
            new Transaction("Withdrawal", 50),
            new Transaction("Withdrawal", 30)
        );

        Map<String, Integer> transactionSums = transactions.stream()
            .collect(Collectors.groupingBy(Transaction::getType,
                Collectors.reducing(0, Transaction::getAmount, Integer::sum)));

        System.out.println(transactionSums);
    }
}

在此代碼中，我們按類型對交易進行分組，將它們映射到其金額，然后通過求和來減少金額。結果是一個顯示每種交易類型總金額的地圖。

演示結果

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<Integer, User> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}

六、結論

這些高級 Java Stream 技巧可以顯著提高您的編碼效率和可讀性。通過掌握這些技術，您可以輕松處理復雜的數(shù)據(jù)處理任務。如果您有任何疑問或需要進一步說明，請隨時在下面發(fā)表評論！

閱讀更多帖子：您需要了解的 5 個高級 Java 流技巧

以上是您需要了解的高級 Java Stream 技巧的詳細內容。更多信息請關注PHP中文網(wǎng)其他相關文章！