同じタイプを含む2つのHashMapオブジェクトを組み合わせるにはどうすればよいですか？

241

HashMap次のように定義された2つのオブジェクトがあります。

HashMap<String, Integer> map1 = new HashMap<String, Integer>();
HashMap<String, Integer> map2 = new HashMap<String, Integer>();

また、3番目のHashMapオブジェクトがあります。

HashMap<String, Integer> map3;

どうすればマージmap1してmap2一緒にできmap3ますか？

java  hashmap 
— マヴィン
ソース
16
両方のマップにキーが存在する場合に何をしたいかを述べていません。
— Michael Scheper 2013

回答:

344 
map3 = new HashMap<>();

map3.putAll(map1);
map3.putAll(map2);
— 名のない馬
ソース
1
ありがとう、私はforループでマップをマージしています。このループは、メソッドを使用してマップを返し、それを別のマップにマージして、同じメソッドアジャンを適用する必要があります。このため、putAllメソッドでnullポインタ例外が発生します。try / catchブロックの使用には役立ちません。私は何をすべきか？私は....ように条件ならばサイズは== O、その後のputAllを適用しない場合は、他のそれを適用することを、適用されていますと
— Mavin
1
NPEを取得した場合は、オブジェクトの1つを正しく初期化していないようです。スタックトレースをキャッチブロックに出力しますか？したがって、問題が発生する場所を知っています。ただし、スタックトレースを含む完全で正確なコードを投稿しない限り、自分で追跡する必要があります。
— a_horse_with_no_name 2010年
95
このソリューションでは、両方のマップにキーが存在する場合、map2の値は保持され、map1の値は失われることに注意してください。
— Michael Scheper 2013
5
@MichaelScheper：他に何を期待していますか？aのキーはMap定義上一意です
— a_horse_with_no_name 2013
42
OPerが何を期待しているのかわかりません。たぶん、彼はmap1の値が優先されるか、例外がスローされるか、交差する整数で「マージ」操作が実行されることを期待しています。あるいは、これは初心者の質問なので、これはOPerが考慮していなかったケースです。その場合、私のコメントが参考になれば幸いです。
— Michael Scheper 2013
109

重複するキーがないことがわかっている場合、または重複したキーの値map2を上書きして値を取得したい場合はmap1、次のように書くことができます

map3 = new HashMap<>(map1);
map3.putAll(map2);

値の組み合わせ方法をより詳細に制御する必要がある場合はMap.merge、Java 8で追加されたを使用できます。Java8では、ユーザー提供のBiFunctionキーを使用して、重複するキーの値をマージします。 mergeは個々のキーと値を操作するため、ループまたはを使用する必要がありますMap.forEach。ここでは、重複するキーの文字列を連結します。

map3 = new HashMap<>(map1);
for (Map.Entry<String, String> e : map2.entrySet())
    map3.merge(e.getKey(), e.getValue(), String::concat);
//or instead of the above loop
map2.forEach((k, v) -> map3.merge(k, v, String::concat));

重複するキーがないことがわかっていて、それを強制したい場合は、AssertionError：をスローするマージ関数を使用できます。

map2.forEach((k, v) ->
    map3.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

この具体的な質問から、ステップバックを取ると、Javaの8が提供するライブラリをストリーミングtoMapし、groupingBy コレクター。ループ内でマップを繰り返しマージしている場合、ストリームを使用するように計算を再構築できる可能性があります。これにより、コードが明確になり、並列ストリームと並行コレクターを使用して簡単に並列化できるようになります。

— ジェフリー・ボスブーム
ソース
46

Java 8 Stream APIを使用したワンライナー：

map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
       .collect(Collectors.toMap(Entry::getKey, Entry::getValue))

このメソッドの利点の中には、同じキーを持つ値を処理するマージ関数を渡す機能があります。次に例を示します。

map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
       .collect(Collectors.toMap(Entry::getKey, Entry::getValue, Math::max))
— ヴィタリー・フェドレンコ
ソース
1
これにより、重複したキーに対してIllegalStateExceptionがスローされます
— Arpit J.
1
@ArpitJ。これが2番目のバリエーションの要点です。例外が必要な場合もあれば、そうでない場合もあります。
— Alex R
36

2つのマップをマージするためのJava 8の代替ワンライナー：

defaultMap.forEach((k, v) -> destMap.putIfAbsent(k, v));

メソッド参照についても同じです。

defaultMap.forEach(destMap::putIfAbsent);

または、3番目のマップを含む元のマップソリューションのidemponent：

Map<String, Integer> map3 = new HashMap<String, Integer>(map2);
map1.forEach(map3::putIfAbsent);

そして、これは可能な限り最小限の中間コピー操作を行うGuavaで2つのマップを高速不変マップにマージする方法です：

ImmutableMap.Builder<String, Integer> builder = ImmutableMap.<String, Integer>builder();
builder.putAll(map1);
map2.forEach((k, v) -> {if (!map1.containsKey(k)) builder.put(k, v);});
ImmutableMap<String, Integer> map3 = builder.build();

両方のマップに存在する値をマッピング関数と組み合わせる必要がある場合については、Java 8で2つのマップをマージするも参照してください。

— ヴァジム
ソース
32

最終的なマップに可変性が必要ない場合は、Javaのインターフェースメソッドとは対照的に、そのand メソッドを備えたGuava がチェーンできます。ImmutableMapBuilderputAllMap

使用例：

Map<String, Integer> mergeMyTwoMaps(Map<String, Integer> map1, Map<String, Integer> map2) {
  return ImmutableMap.<String, Integer>builder()
      .putAll(map1)
      .putAll(map2)
      .build();
}

もちろん、この方法はより一般的で、varargsを使用して引数をループするputAll Mapsなどの方法がありますが、私は概念を示したかったのです。

また、ImmutableMapそれにBuilderはいくつかの制限があります（または機能ですか？）：

  • それらはnull敵対的です（スローNullPointerException-マップ内のキーまたは値がnullの場合）
  • Builderは重複キーを受け入れません（IllegalArgumentException重複キーが追加された場合はスローされます）。
— Xaerxess
ソース
11

一般的なキーを共有できる2つのマップを組み合わせるための一般的なソリューション：

所定の位置に：

public static <K, V> void mergeInPlace(Map<K, V> map1, Map<K, V> map2,
        BinaryOperator<V> combiner) {
    map2.forEach((k, v) -> map1.merge(k, v, combiner::apply));
}

新しいマップを返す：

public static <K, V> Map<K, V> merge(Map<K, V> map1, Map<K, V> map2,
        BinaryOperator<V> combiner) {
    Map<K, V> map3 = new HashMap<>(map1);
    map2.forEach((k, v) -> map3.merge(k, v, combiner::apply));
    return map3;
}
— ゼカコズロフ
ソース
2

他のマップからマップを作成するために頻繁に使用する小さなスニペット：

static public <K, V> Map<K, V> merge(Map<K, V>... args) {
    final Map<K, V> buffer = new HashMap<>();

    for (Map m : args) {
        buffer.putAll(m);
    }

    return buffer;
}
— トーマスデコー
ソース
2

を使用HashMap<String, List<Integer>>して両方のハッシュマップをマージし、同じキーとペアになっている要素が失われるのを回避できます。

HashMap<String, Integer> map1 = new HashMap<>();
HashMap<String, Integer> map2 = new HashMap<>();
map1.put("key1", 1);
map1.put("key2", 2);
map1.put("key3", 3);
map2.put("key1", 4);
map2.put("key2", 5);
map2.put("key3", 6);
HashMap<String, List<Integer>> map3 = new HashMap<>();
map1.forEach((str, num) -> map3.put(str, new ArrayList<>(Arrays.asList(num))));
//checking for each key if its already in the map, and if so, you just add the integer to the list paired with this key
for (Map.Entry<String, Integer> entry : map2.entrySet()) {
    Integer value = entry.getValue();
    String key = entry.getKey();
    if (map3.containsKey(key)) {
        map3.get(key).add(value);
    } else {
        map3.put(key, new ArrayList<>(Arrays.asList(value)));
    }
}
map3.forEach((str, list) -> System.out.println("{" + str + ": " + list + "}"));

出力：

{key1: [1, 4]}
{key2: [2, 5]}
{key3: [3, 6]}
— オメルヴィシュリツキー
ソース
2

非常に遅いですが、同じ問題があったときに私がしたことを共有させてください。

Map<String, List<String>> map1 = new HashMap<>();
map1.put("India", Arrays.asList("Virat", "Mahi", "Rohit"));
map1.put("NZ", Arrays.asList("P1","P2","P3"));

Map<String, List<String>> map2 = new HashMap<>();
map2.put("India", Arrays.asList("Virat", "Mahi", "Rohit"));
map2.put("NZ", Arrays.asList("P1","P2","P4"));

Map<String, List<String>> collect4 = Stream.of(map1, map2)
                .flatMap(map -> map.entrySet().stream())
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (strings, strings2) -> {
                                    List<String> newList = new ArrayList<>();
                                    newList.addAll(strings);
                                    newList.addAll(strings2);
                                    return newList;
                                }
                        )
                );
collect4.forEach((s, strings) -> System.out.println(s+"->"+strings));

次の出力が得られます

NZ->[P1, P2, P3, P1, P2, P4]
India->[Virat, Mahi, Rohit, Virat, Mahi, Rohit]
— イシャン・バット
ソース
0 
    HashMap<Integer,String> hs1 = new HashMap<>();
    hs1.put(1,"ram");
    hs1.put(2,"sita");
    hs1.put(3,"laxman");
    hs1.put(4,"hanuman");
    hs1.put(5,"geeta");

    HashMap<Integer,String> hs2 = new HashMap<>();
    hs2.put(5,"rat");
    hs2.put(6,"lion");
    hs2.put(7,"tiger");
    hs2.put(8,"fish");
    hs2.put(9,"hen");

    HashMap<Integer,String> hs3 = new HashMap<>();//Map is which we add

    hs3.putAll(hs1);
    hs3.putAll(hs2);

    System.out.println(" hs1 : " + hs1);
    System.out.println(" hs2 : " + hs2);
    System.out.println(" hs3 : " + hs3);

重複する項目は追加されません（つまり、重複したキーです）。hs3を印刷すると、キー5の値が1つだけ取得されます。これは最後に追加された値であり、ラットになります。** [セットには重複キーを許可しないというプロパティがありますが、値は重複する可能性があります]

— カルネシュ
ソース
0

方法1：マップをリストに入れてから結合する

public class Test15 {
public static void main(String[] args) {

    Map<String, List<String>> map1 = new HashMap<>();
    map1.put("London", Arrays.asList("A", "B", "C"));
    map1.put("Wales", Arrays.asList("P1", "P2", "P3"));

    Map<String, List<String>> map2 = new HashMap<>();
    map2.put("Calcutta", Arrays.asList("Protijayi", "Gina", "Gini"));
    map2.put("London", Arrays.asList( "P4", "P5", "P6"));
    map2.put("Wales", Arrays.asList( "P111", "P5555", "P677666"));

    System.out.println(map1);System.out.println(map2);



    // put the maps in an ArrayList

    List<Map<String, List<String>>> maplist = new ArrayList<Map<String,List<String>>>();
    maplist.add(map1);
    maplist.add(map2);
    /*
<T,K,U> Collector<T,?,Map<K,U>> toMap(

                                  Function<? super T,? extends K> keyMapper,

                                  Function<? super T,? extends U> valueMapper,

                                  BinaryOperator<U> mergeFunction)
    */

 Map<String, List<String>> collect = maplist.stream()
    .flatMap(ch -> ch.entrySet().stream())
    .collect(
            Collectors.toMap(

            //keyMapper,

            Entry::getKey,

            //valueMapper
            Entry::getValue,

            // mergeFunction
     (list_a,list_b) -> Stream.concat(list_a.stream(), list_b.stream()).collect(Collectors.toList())

            ));



    System.out.println("Final Result(Map after join) => " + collect);
    /*
    {Wales=[P1, P2, P3], London=[A, B, C]}
{Calcutta=[Protijayi, Gina, Gini], Wales=[P111, P5555, P677666], London=[P4, P5, P6]}
Final Result(Map after join) => {Calcutta=[Protijayi, Gina, Gini], Wales=[P1, P2, P3, P111, P5555, P677666], London=[A, B, C, P4, P5, P6]}
*/

}//main


}

方法2：法線マップのマージ 

public class Test15 {
public static void main(String[] args) {

    Map<String, List<String>> map1 = new HashMap<>();
    map1.put("London", Arrays.asList("A", "B", "C"));
    map1.put("Wales", Arrays.asList("P1", "P2", "P3"));

    Map<String, List<String>> map2 = new HashMap<>();
    map2.put("Calcutta", Arrays.asList("Protijayi", "Gina", "Gini"));
    map2.put("London", Arrays.asList( "P4", "P5", "P6"));
    map2.put("Wales", Arrays.asList( "P111", "P5555", "P677666"));

    System.out.println(map1);System.out.println(map2);




    /*
<T,K,U> Collector<T,?,Map<K,U>> toMap(

                                  Function<? super T,? extends K> keyMapper,

                                  Function<? super T,? extends U> valueMapper,

                                  BinaryOperator<U> mergeFunction)
    */


Map<String, List<String>> collect = Stream.of(map1,map2)
    .flatMap(ch -> ch.entrySet().stream())
    .collect(
            Collectors.toMap(

            //keyMapper,

            Entry::getKey,

            //valueMapper
            Entry::getValue,

            // mergeFunction
     (list_a,list_b) -> Stream.concat(list_a.stream(), list_b.stream()).collect(Collectors.toList())

            ));



    System.out.println("Final Result(Map after join) => " + collect);
    /*
    {Wales=[P1, P2, P3], London=[A, B, C]}
{Calcutta=[Protijayi, Gina, Gini], Wales=[P111, P5555, P677666], London=[P4, P5, P6]}
Final Result(Map after join) => {Calcutta=[Protijayi, Gina, Gini], Wales=[P1, P2, P3, P111, P5555, P677666], London=[A, B, C, P4, P5, P6]}

*/

}//main


}
— スディプタドゥッタ
ソース
0

以下のコードで説明されているように、Mapに対してputAll関数を使用できます

HashMap<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("a", 1);
map1.put("b", 2);
map1.put("c", 3);
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
map1.put("aa", 11);
map1.put("bb", 12);
HashMap<String, Integer> map3 = new HashMap<String, Integer>();
map3.putAll(map1);
map3.putAll(map2);
map3.keySet().stream().forEach(System.out::println);
map3.values().stream().forEach(System.out::println);
— Pミタル
ソース
0

以下のスニペットは、複数のマップを取り、それらを組み合わせます。

 private static <K, V> Map<K, V> combineMaps(Map<K, V>... maps) {
        if (maps == null || maps.length == 0) {
            return Collections.EMPTY_MAP;
        }

        Map<K, V> result = new HashMap<>();

        for (Map<K, V> map : maps) {
            result.putAll(map);
        }
        return result;
    }

デモ例リンク。

— ハリ・クリシュナ
ソース
-1

使用できます-addAllメソッド

http://download.oracle.com/javase/6/docs/api/java/util/HashMap.html

ただし、この問題は常に存在します。2つのハッシュマップに同じキーがある場合、最初のハッシュマップのキーの値が2番目のハッシュマップのキーの値で上書きされます。

安全のために-キーの値を変更します-キーにプレフィックスまたはサフィックスを使用できます-（最初のハッシュマップには異なるプレフィックス/サフィックス、2番目のハッシュマップには異なるプレフィックス/サフィックス）

— アシッシュ・シェトカー
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.