Java8: HashMap <X, Y> ke HashMap <X, Z> menggunakan Stream / Map-Reduce / Collector

Saya tahu cara "mengubah" Java sederhana Listdari Y-> Z, yaitu:

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

Sekarang pada dasarnya saya ingin melakukan hal yang sama dengan Peta, yaitu:

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

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

Solusinya tidak terbatas pada String-> Integer. Sama seperti pada Listcontoh di atas, saya ingin memanggil metode apa pun (atau konstruktor).

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

Ini tidak sebagus kode daftar. Anda tidak dapat membuat baru Map.Entrydalam map()panggilan sehingga pekerjaan itu dicampur ke dalam collect()panggilan.

Berikut adalah beberapa variasi jawaban Sotirios Delimanolis , yang cukup baik untuk memulai dengan (+1). Pertimbangkan yang berikut ini:

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))));
}

Beberapa poin di sini. Pertama adalah penggunaan wildcard dalam obat generik; ini membuat fungsinya agak lebih fleksibel. Wildcard akan diperlukan jika, misalnya, Anda ingin peta keluaran memiliki kunci yang merupakan superclass dari kunci peta input:

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

(Ada juga contoh untuk nilai-nilai peta, tetapi ini benar-benar dibuat-buat, dan saya akui bahwa memiliki wildcard terbatas untuk Y hanya membantu dalam kasus tepi.)

Poin kedua adalah bahwa alih-alih menjalankan streaming di atas peta input entrySet, saya malah menjalankannya di atas keySet. Ini membuat kode sedikit lebih bersih, saya pikir, dengan biaya harus mengambil nilai dari peta alih-alih dari entri peta. Kebetulan, saya awalnya memiliki key -> keyargumen pertama toMap()dan ini gagal dengan kesalahan inferensi jenis karena beberapa alasan. Mengubahnya (X key) -> keyberfungsi, seperti yang terjadi Function.identity().

Variasi lain adalah sebagai berikut:

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;
}

Ini menggunakan Map.forEach()bukannya stream. Ini bahkan lebih sederhana, saya pikir, karena itu dibagikan kepada kolektor, yang agak canggung untuk digunakan dengan peta. Alasannya adalah bahwa Map.forEach()memberikan kunci dan nilai sebagai parameter terpisah, sedangkan aliran hanya memiliki satu nilai - dan Anda harus memilih apakah akan menggunakan kunci atau entri peta sebagai nilai itu. Di sisi minusnya, ini tidak memiliki kekayaan, aliran kebaikan dari pendekatan lain. :-)

Solusi generik seperti itu

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())));
}

Contoh

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));

Fungsi Guava Maps.transformValuesadalah apa yang Anda cari, dan berfungsi baik dengan ekspresi lambda:

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

Apakah benar-benar harus 100% fungsional dan lancar? Jika tidak, bagaimana dengan ini, yang singkatnya:

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

( jika Anda dapat hidup dengan rasa malu dan bersalah karena menggabungkan aliran dengan efek samping )

Pustaka StreamEx saya yang meningkatkan API aliran standar menyediakan EntryStreamkelas yang lebih sesuai untuk mengubah peta:

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

Alternatif yang selalu ada untuk tujuan pembelajaran adalah membangun kolektor khusus Anda melalui Collector.of () toMap () JDK kolektor di sini singkat (+1 di sini ).

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;}
               ));

Jika Anda tidak keberatan menggunakan perpustakaan pihak ketiga, lib -siklop-reaksi saya memiliki ekstensi untuk semua jenis Koleksi JDK , termasuk Peta . Kami hanya dapat mengubah peta secara langsung menggunakan operator 'peta' (secara default peta bertindak berdasarkan nilai-nilai di peta).

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

bimap dapat digunakan untuk mengubah kunci dan nilai pada saat yang sama

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

Solusi deklaratif dan sederhana adalah:

yourMutableMap.replaceAll ((key, val) -> return_value_of_bi_your_function); Nb. Ketahuilah bahwa Anda memodifikasi kondisi peta Anda. Jadi ini mungkin bukan yang Anda inginkan.

Ceria untuk: http://www.deadcoderising.com/2017-02-14-java-8-declarative-ways-of-modifying-a-map-using-compute-merge-and-replace/