Java8: HashMap <X, Y> sang HashMap <X, Z> bằng cách sử dụng Stream / Map-Giảm / Collector

Tôi biết cách "biến đổi" một Java đơn giản Listtừ Y-> Z, tức là:

List<String> x;
List<Integer> y = x.stream()
        .map(s -> Integer.parseInt(s))
        .collect(Collectors.toList());

Bây giờ tôi muốn làm về cơ bản giống với Bản đồ, nghĩa là:

INPUT:
{
  "key1" -> "41",    // "41" and "42"
  "key2" -> "42      // are Strings
}

OUTPUT:
{
  "key1" -> 41,      // 41 and 42
  "key2" -> 42       // are Integers
}

Giải pháp không nên giới hạn ở String-> Integer. Giống như trong Liství dụ trên, tôi muốn gọi bất kỳ phương thức (hoặc hàm tạo) nào.

Map<String, String> x;
Map<String, Integer> y =
    x.entrySet().stream()
        .collect(Collectors.toMap(
            e -> e.getKey(),
            e -> Integer.parseInt(e.getValue())
        ));

Nó không đẹp như mã danh sách. Bạn không thể tạo các Map.Entrys mới trong một map()cuộc gọi để công việc được trộn vào collect()cuộc gọi.

Dưới đây là một số biến thể về câu trả lời của Sotirios Delimanolis , khá hay khi bắt đầu bằng (+1). Hãy xem xét những điều sau đây:

static <X, Y, Z> Map<X, Z> transform(Map<? extends X, ? extends Y> input,
                                     Function<Y, Z> function) {
    return input.keySet().stream()
        .collect(Collectors.toMap(Function.identity(),
                                  key -> function.apply(input.get(key))));
}

Một vài điểm ở đây. Đầu tiên là việc sử dụng các ký tự đại diện trong các tổng quát; Điều này làm cho chức năng có phần linh hoạt hơn. Ví dụ, một ký tự đại diện sẽ là cần thiết nếu bạn muốn bản đồ đầu ra có một khóa đó là siêu lớp của khóa bản đồ đầu vào:

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<CharSequence, Integer> output = transform(input, Integer::parseInt);

(Ngoài ra còn có một ví dụ cho các giá trị của bản đồ, nhưng nó thực sự bị chiếm đoạt và tôi thừa nhận rằng việc có ký tự đại diện giới hạn cho Y chỉ giúp ích trong các trường hợp cạnh.)

Điểm thứ hai là thay vì chạy luồng trên bản đồ đầu vào entrySet, tôi đã chạy nó qua keySet. Điều này làm cho mã sạch hơn một chút, tôi nghĩ, với chi phí phải lấy các giá trị ra khỏi bản đồ thay vì từ mục nhập bản đồ. Ngẫu nhiên, ban đầu tôi đã có key -> keyđối số đầu tiên toMap()và điều này đã thất bại với một lỗi suy luận kiểu vì một số lý do. Thay đổi nó để (X key) -> keylàm việc, như đã làm Function.identity().

Một biến thể khác như sau:

static <X, Y, Z> Map<X, Z> transform1(Map<? extends X, ? extends Y> input,
                                      Function<Y, Z> function) {
    Map<X, Z> result = new HashMap<>();
    input.forEach((k, v) -> result.put(k, function.apply(v)));
    return result;
}

Điều này sử dụng Map.forEach()thay vì các luồng. Điều này thậm chí còn đơn giản hơn, tôi nghĩ, bởi vì nó phân phối với các nhà sưu tập, có phần vụng về để sử dụng với bản đồ. Lý do là Map.forEach()cung cấp khóa và giá trị dưới dạng tham số riêng biệt, trong khi luồng chỉ có một giá trị - và bạn phải chọn sử dụng khóa hoặc mục nhập bản đồ làm giá trị đó. Về mặt trừ, điều này thiếu đi sự tốt đẹp, phong phú của các phương pháp khác. :-)

Một giải pháp chung chung như vậy

public static <X, Y, Z> Map<X, Z> transform(Map<X, Y> input,
        Function<Y, Z> function) {
    return input
            .entrySet()
            .stream()
            .collect(
                    Collectors.toMap((entry) -> entry.getKey(),
                            (entry) -> function.apply(entry.getValue())));
}

Thí dụ

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<String, Integer> output = transform(input,
            (val) -> Integer.parseInt(val));

Chức năng của ổi Maps.transformValueslà những gì bạn đang tìm kiếm và nó hoạt động độc đáo với các biểu thức lambda:

Maps.transformValues(originalMap, val -> ...)

Nó hoàn toàn phải có 100% chức năng và thông thạo? Nếu không, làm thế nào về điều này, đó là khoảng ngắn như nó được:

Map<String, Integer> output = new HashMap<>();
input.forEach((k, v) -> output.put(k, Integer.valueOf(v));

( nếu bạn có thể sống với sự xấu hổ và cảm giác tội lỗi khi kết hợp các luồng với tác dụng phụ )

Thư viện StreamEx của tôi giúp tăng cường API luồng tiêu chuẩn cung cấp một EntryStreamlớp phù hợp hơn để chuyển đổi bản đồ:

Map<String, Integer> output = EntryStream.of(input).mapValues(Integer::valueOf).toMap();

Một giải pháp thay thế luôn tồn tại cho mục đích học tập là xây dựng trình thu thập tùy chỉnh của bạn thông qua Collector.of () mặc dù trình thu thập JDK của toMap () ở đây ngắn gọn (+1 ở đây ).

Map<String,Integer> newMap = givenMap.
                entrySet().
                stream().collect(Collector.of
               ( ()-> new HashMap<String,Integer>(),
                       (mutableMap,entryItem)-> mutableMap.put(entryItem.getKey(),Integer.parseInt(entryItem.getValue())),
                       (map1,map2)->{ map1.putAll(map2); return map1;}
               ));

Nếu bạn không phiền khi sử dụng các thư viện của bên thứ 3, lib phản ứng cyclops của tôi có các phần mở rộng cho tất cả các loại Bộ sưu tập JDK , bao gồm cả Bản đồ . Chúng ta chỉ có thể chuyển đổi bản đồ trực tiếp bằng toán tử 'bản đồ' (theo mặc định bản đồ tác động lên các giá trị trong bản đồ).

   MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                                .map(Integer::parseInt);

bimap có thể được sử dụng để chuyển đổi các khóa và giá trị cùng một lúc

  MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                               .bimap(this::newKey,Integer::parseInt);

Giải pháp khai báo và đơn giản hơn sẽ là:

yourMutableMap.replaceAll ((key, val) -> return_value_of_bi_your_feft); Nb. lưu ý sửa đổi trạng thái bản đồ của bạn. Vì vậy, đây có thể không phải là những gì bạn muốn.

Chúc mừng: http://www.deadcoderising.com/2017-02-14-java-8-declarative-ways-of-modifying-a-map-USE-compute-merge-and-replace/