是的，当前在您的代码中创建乘积和整数的不可变Map，因此您不能为客户机添加新产品。此外，还可以覆盖客户机的Map项，例如，索引为4的客户机具有 Map.of(products.get(1),9) 作为值，因为它是最后一个并覆盖以前的所有赋值
如果希望每个客户机有多个产品，可以重构为：

customersWithTheirShopping.put(clients.get(0), new HashMap<>(Map.of(products.get(0), 5)));
        customersWithTheirShopping.put(clients.get(1), new HashMap<>(Map.of(products.get(1), 6)));
        customersWithTheirShopping.put(clients.get(2), new HashMap<>(Map.of(products.get(6), 16)));
        customersWithTheirShopping.put(clients.get(3), new HashMap<>(Map.of(products.get(5), 11)));
        customersWithTheirShopping.put(clients.get(4), new HashMap<>(Map.of(products.get(4), 5)));
        customersWithTheirShopping.get(clients.get(4)).put(products.get(3), 6);
        customersWithTheirShopping.get(clients.get(2)).put(products.get(2), 8);
        customersWithTheirShopping.get(clients.get(4)).put(products.get(1), 9);

然后可以使用流来获得正确的客户机

Client clientWithMostExpense = customersWithTheirShopping
                .entrySet()
                .stream()
                .max(
                        // check all clients and compare their mostExpensiveProducts
                        Comparator.comparing(
                        client -> {
                            Map.Entry<Product, Integer> mostExpensiveProductForClient = client.getValue().entrySet()
                                    .stream().max(
                                            //Find most expensive product of all for client
                                            Comparator.comparing(product ->
                                                    product.getKey().getPrice().multiply(BigDecimal.valueOf(product.getValue())))
                                    ).get();
                            // return the full price of the most expensive product for comparison
                            return mostExpensiveProductForClient.getKey().getPrice().multiply(BigDecimal.valueOf(mostExpensiveProductForClient.getValue()));
                        }
                )).get().getKey();

另一个解决方案是将quantity和product重构为一个新的类，称为boughtproduct或类似的类，在这个类中您可以计算出它的价格

public class BoughtProduct {
        Product product;
        Integer quantity;

        public BoughtProduct(Product product, Integer quantity) {
            this.quantity = quantity;
            this.product = product;
        }

        public Integer getQuantity() {
            return quantity;
        }

        public void setQuantity(Integer quantity) {
            this.quantity = quantity;
        }

        public Product getProduct() {
            return product;
        }

        public void setProduct(Product product) {
            this.product = product;
        }

        public BigDecimal getTotalPrice(){
            return this.product.getPrice().multiply(BigDecimal.valueOf(quantity));
        }
    }

然后可以使用列表而不是Map：

Map<Client, List<BoughtProduct>> customersWithTheirShopping = new HashMap<>();
        customersWithTheirShopping.put(clients.get(0), new ArrayList<>(List.of(new BoughtProduct(products.get(0), 5))));
        customersWithTheirShopping.put(clients.get(1), new ArrayList<>(List.of(new BoughtProduct(products.get(1), 6))));
        customersWithTheirShopping.put(clients.get(2), new ArrayList<>(List.of(new BoughtProduct(products.get(6), 16))));
        customersWithTheirShopping.put(clients.get(3), new ArrayList<>(List.of(new BoughtProduct(products.get(5), 11))));
        customersWithTheirShopping.put(clients.get(4), new ArrayList<>(List.of(new BoughtProduct(products.get(4), 5))));
        customersWithTheirShopping.get(clients.get(4)).add(new BoughtProduct((products.get(3)), 6)); //could use a check whether product exists, then you could increase quantity
        customersWithTheirShopping.get(clients.get(2)).add(new BoughtProduct(products.get(2),8));
        customersWithTheirShopping.get(clients.get(4)).add(new BoughtProduct(products.get(1),9));

使流的可读性更强：

Client clientWithMostExpense = customersWithTheirShopping
                .entrySet()
                .stream()
                .max(
                        // check all clients and compare their mostExpensive BoughtProduct in their list
                        Comparator.comparing(
                                //For each client get their most expensive product
                                client -> client.getValue()
                                        .stream().max(Comparator.comparing(BoughtProduct::getTotalPrice)).get()
                                        .getTotalPrice()
                        )).get().getKey();