Java 地图<&燃气轮机；在地图中<&燃气轮机；作为价值->；如何从地图创建对象<&燃气轮机；其中value是另一个Map<>；？

这里的任务是练习地图和收藏

我们有两个类，其属性在括号中

第一类：客户端（字符串名称、字符串姓氏、整数年龄、BigDecimal现金）

下面是主服务器中随机客户端的列表

List<Client> clients = List.of(
            new Client("Ola", "Chrzaszcz", 34, new BigDecimal("200")),
            new Client("Ala", "Kowalsky", 24, new BigDecimal("4000")),
            new Client("Olaf", "Chrzaszcz", 19, new BigDecimal("3999")),
            new Client("Piotr", "Nowak", 21, new BigDecimal("2099")),
            new Client("Ola", "Szwed", 45, new BigDecimal("3000"))
);

List clients=List.of(
新客户（“Ola”，“Chrzaszcz”，34岁，新BigDecimal（“200”），
新客户（“Ala”，“Kowalsky”，24，新BigDecimal（“4000”），
新客户（“Olaf”、“Chrzaszcz”、19、新BigDecimal（“3999”），
新客户（“Piotr”、“Nowak”、21、新BigDecimal（“2099”），
新客户（“Ola”、“Szwed”、45、新BigDecimal（“3000”））
);

第二类：产品（字符串名称、枚举类别、BigDecimal价格）

List products=List.of(
新产品（“Szynka”，A类，新BigDecimal（29）），
新产品（“Ser”，B类，新BigDecimal（22）），
新产品（“Chleb”，C类，新BigDecimal（6）），
新产品（“Maslo”，D类，新BigDecimal（4）），
新产品（“Kielbasa”，A类，新BigDecimal（25）），
新产品（“Jajka”，类别A，新BigDecimal（8）），
新产品（“Szynka”，C类，新BigDecimal（25））
);

目标->预期结果： 在类Main中创建购物类的实例，其中属性是具有 当前行为：

创建独立类购物：

代码

公共类购物{
通过Cyclient，产品的私有映射数量；

Main中从Shopping class->创建随机对象的代码正在尝试差异组合，但仍然失败

代码

Map s1=newhashmap（）；
s1.put（clients.indexOf（0），newmap（products.indexOf（1），5））；
List productsBoughtByClient=List.of(
新映射（clients.indexOf（0），新映射（products.indexOf（0），5）），
);

---

顺便说一句，我试图找到类似的问题，但没有找到任何，

这里有一个例子作为起点，其中有一个方法

randomProductMap

，它接受一个产品列表，shuffel这个列表，获取一个随机数目的产品，并生成一个带有随机数目的产品的映射如果不需要，请将其删除

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;


public class Test {

    public static void main(String[] args) {
        List<Client> clients = List.of(
                new Client("Ola", "Chrzaszcz", 34, new BigDecimal("200")),
                new Client("Ala", "Kowalsky", 24, new BigDecimal("4000")),
                new Client("Olaf", "Chrzaszcz", 19, new BigDecimal("3999")),
                new Client("Piotr", "Nowak", 21, new BigDecimal("2099")),
                new Client("Ola", "Szwed", 45, new BigDecimal("3000"))
        );
        List<Product> products = List.of(
                new Product("Szynka", Category.A, new BigDecimal(29)),
                new Product("Ser", Category.B, new BigDecimal(22)),
                new Product("Chleb", Category.C, new BigDecimal(6)),
                new Product("Maslo", Category.D, new BigDecimal(4)),
                new Product("Kielbasa", Category.A, new BigDecimal(25)),
                new Product("Jajka", Category.A, new BigDecimal(8)),
                new Product("Szynka", Category.C, new BigDecimal(25))
        );
        Map<Client,Map<Product,Integer>> myMap = 
                clients.stream().collect(Collectors.toMap(
                        Function.identity(), c -> randomProductMap(products)));

        Shopping sh = new Shopping(myMap);

        sh.getQuantitiesOfProductsBoughtByClient()
                .forEach((client, prodMap) -> {
                    System.out.println(client.getName() + " " + client.getLastName() + " bought below products");
                    prodMap.forEach((key,value) -> {
                        System.out.println("\t" + value + " x " + key.getName());
                    });
                    //Edited
                    BigDecimal total = prodMap.entrySet().stream()
                        .map(e -> e.getKey().getPrice().multiply(BigDecimal.valueOf(e.getValue())))
                        .reduce(BigDecimal.ZERO, (p,q)-> p.add(q), BigDecimal::add);
                    System.out.println("and spent total amount of: " + total);
                    //Edited
                });
    }

    public static Map<Product,Integer> randomProductMap(List<Product> products){
        List<Product> copy = new ArrayList<>(products);
        Collections.shuffle(copy);
        Random r = new Random();
        List<Product> randomSizeList = copy.subList(0, r.nextInt(products.size()) + 1);
        return randomSizeList.stream()
                .collect(Collectors.toMap(Function.identity(), p -> r.nextInt(10)+1));
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Client {
        String name;
        String lastName;
        Integer age;
        BigDecimal cash;
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Product {
        String name;
        Enum category;
        BigDecimal Price;
    }

    public static enum Category {
        A, B, C, D;
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Shopping{
        private Map<Client, Map<Product,Integer>> quantitiesOfProductsBoughtByClient;
        
    }
}

上面的方法应该会给你提供花费最多的客户。简要总结一下那里发生了什么：通过Cycle客户端迭代产品的map

Quantities of Products
collect to map，以客户为键，将每个产品的价格乘以quantity和总和，最后通过迭代得到花费最多的客户使用
Stream.max
在生成的地图上进行搜索

虽然上面的方法会根据请求返回一个客户机，但您不会得到其他信息，例如他到底花了多少钱。因此，我建议您将该方法的返回值更改为
Map.Entry
，以获取客户机和总支出。为此，只需省去最后一个
.getKey（）；

或者更简单的方法是将一个映射客户端返回到total Expension Map，并将客户端的高、低、平均值或其他值的确定留给方法的调用方：

public Map<Client, BigDecimal> totalSpendingsByClient() {
         return quantitiesOfProductsBoughtByClient.entrySet()
                 .stream()
                 .collect(Collectors.toMap(
                         Map.Entry::getKey,  
                         entry -> entry.getValue().entrySet().stream()
                                 .map(prodMap -> prodMap.getKey().getPrice().multiply(BigDecimal.valueOf(prodMap.getValue())))
                                 .reduce(BigDecimal.ZERO, (prod1,prod2)-> prod1.add(prod2), BigDecimal::add)
                 ));                            
     }

publicmap totalSpendingsByClient（）{
通过Cycle.entrySet（）返回产品的数量
.stream（）
.collect（collector.toMap）(
Map.Entry:：getKey，
entry->entry.getValue（）.entrySet（）.stream（）
.map（prodMap->prodMap.getKey（）.getPrice（）.multiply（BigDecimal.valueOf（prodMap.getValue（）））
.reduce（BigDecimal.ZERO，（prod1，prod2）->prod1.add（prod2），BigDecimal:：add）
));                            
}

然后，您可以使用获取具有最大或最小支出的客户端，例如：

Map<Client, BigDecimal> clientsTotal = totalSpendingsByClient();
Client cliWithMaxTotal = clientsTotal.entrySet().stream().max(Comparator.comparing(Map.Entry::getValue)).get().getKey();     
Client cliWithMinTotal = //the same as above just change max to min     
       

Map clientsTotal=totalSpendingsByClient（）；
Client cliWithMaxTotal=clientsTotal.entrySet（）.stream（）.max（Comparator.comparing（Map.Entry:：getValue））.get（）.getKey（）；
Client cliWithMinTotal=//与上面相同，只需将max更改为min
这里有一个例子作为起点，这里有一个方法
randomProductMap
，它接受一个产品列表，关闭这个列表，获取一个随机数的产品，并生成一个带有随机数的产品的映射。注意：我使用lombok来保存一些代码行，如果不需要，将其删除

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;


public class Test {

    public static void main(String[] args) {
        List<Client> clients = List.of(
                new Client("Ola", "Chrzaszcz", 34, new BigDecimal("200")),
                new Client("Ala", "Kowalsky", 24, new BigDecimal("4000")),
                new Client("Olaf", "Chrzaszcz", 19, new BigDecimal("3999")),
                new Client("Piotr", "Nowak", 21, new BigDecimal("2099")),
                new Client("Ola", "Szwed", 45, new BigDecimal("3000"))
        );
        List<Product> products = List.of(
                new Product("Szynka", Category.A, new BigDecimal(29)),
                new Product("Ser", Category.B, new BigDecimal(22)),
                new Product("Chleb", Category.C, new BigDecimal(6)),
                new Product("Maslo", Category.D, new BigDecimal(4)),
                new Product("Kielbasa", Category.A, new BigDecimal(25)),
                new Product("Jajka", Category.A, new BigDecimal(8)),
                new Product("Szynka", Category.C, new BigDecimal(25))
        );
        Map<Client,Map<Product,Integer>> myMap = 
                clients.stream().collect(Collectors.toMap(
                        Function.identity(), c -> randomProductMap(products)));

        Shopping sh = new Shopping(myMap);

        sh.getQuantitiesOfProductsBoughtByClient()
                .forEach((client, prodMap) -> {
                    System.out.println(client.getName() + " " + client.getLastName() + " bought below products");
                    prodMap.forEach((key,value) -> {
                        System.out.println("\t" + value + " x " + key.getName());
                    });
                    //Edited
                    BigDecimal total = prodMap.entrySet().stream()
                        .map(e -> e.getKey().getPrice().multiply(BigDecimal.valueOf(e.getValue())))
                        .reduce(BigDecimal.ZERO, (p,q)-> p.add(q), BigDecimal::add);
                    System.out.println("and spent total amount of: " + total);
                    //Edited
                });
    }

    public static Map<Product,Integer> randomProductMap(List<Product> products){
        List<Product> copy = new ArrayList<>(products);
        Collections.shuffle(copy);
        Random r = new Random();
        List<Product> randomSizeList = copy.subList(0, r.nextInt(products.size()) + 1);
        return randomSizeList.stream()
                .collect(Collectors.toMap(Function.identity(), p -> r.nextInt(10)+1));
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Client {
        String name;
        String lastName;
        Integer age;
        BigDecimal cash;
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Product {
        String name;
        Enum category;
        BigDecimal Price;
    }

    public static enum Category {
        A, B, C, D;
    }

    @Getter
    @Setter
    @AllArgsConstructor
    @ToString
    public static class Shopping{
        private Map<Client, Map<Product,Integer>> quantitiesOfProductsBoughtByClient;
        
    }
}

上面的方法应该会给你提供花费最多的客户。简要总结一下那里发生了什么：通过Cycle客户端迭代产品的map
Quantities of Products
collect to map，以客户为键，将每个产品的价格乘以quantity和总和，最后通过迭代得到花费最多的客户使用
Stream.max
在生成的地图上进行搜索

虽然上面的方法会根据请求返回一个客户机，但您不会得到其他信息，例如他到底花了多少钱。因此，我建议您将该方法的返回值更改为
Map.Entry
，以获取客户机和总支出。为此，只需省去最后一个
.getKey（）；

或者更简单的方法是将一个映射客户端返回到total Expension Map，并将客户端的高、低、平均值或其他值的确定留给方法的调用方：

public Map<Client, BigDecimal> totalSpendingsByClient() {
         return quantitiesOfProductsBoughtByClient.entrySet()
                 .stream()
                 .collect(Collectors.toMap(
                         Map.Entry::getKey,  
                         entry -> entry.getValue().entrySet().stream()
                                 .map(prodMap -> prodMap.getKey().getPrice().multiply(BigDecimal.valueOf(prodMap.getValue())))
                                 .reduce(BigDecimal.ZERO, (prod1,prod2)-> prod1.add(prod2), BigDecimal::add)
                 ));                            
     }

publicmap totalSpendingsByClient（）{
通过Cycle.entrySet（）返回产品的数量
.stream（）
.collect（collector.toMap）(
Map.Entry:：getKey，
entry->entry.getValue（）.entrySet（）.stream（）
.map（prodMap->prodMap.getKey（）.getPrice（）.multiply（BigDecimal.valueOf（prodMap.getValue（）））
.reduce（BigDecimal.ZERO，（prod1，prod2）->prod1.add（prod2），BigDecimal:：add）
...
.max(Comparator.comparing(Map.Entry::getValue))
             .get();

public Map<Client, BigDecimal> totalSpendingsByClient() {
         return quantitiesOfProductsBoughtByClient.entrySet()
                 .stream()
                 .collect(Collectors.toMap(
                         Map.Entry::getKey,  
                         entry -> entry.getValue().entrySet().stream()
                                 .map(prodMap -> prodMap.getKey().getPrice().multiply(BigDecimal.valueOf(prodMap.getValue())))
                                 .reduce(BigDecimal.ZERO, (prod1,prod2)-> prod1.add(prod2), BigDecimal::add)
                 ));                            
     }

Map<Client, BigDecimal> clientsTotal = totalSpendingsByClient();
Client cliWithMaxTotal = clientsTotal.entrySet().stream().max(Comparator.comparing(Map.Entry::getValue)).get().getKey();     
Client cliWithMinTotal = //the same as above just change max to min