Java 两个映射值的求和

如何将两个不同地图中的所有值相加

Map<String, List<String>> map = new HashMap<String, List<String>>();
List<String> totalValOne= new ArrayList<String>();
List<String> totalValTwo= new ArrayList<String>();
map1.put("totalPriceSet1", totalValOne);     
map2.put("totalPriceSet2", totalValTwo);

我想把这两个加起来

Sum {3,5,7,9}

您可以做的是：

 public static void main( String[] args ){
        Map<String, Integer> map = new TreeMap<>();
        map.put( "total1", 2 );
        map.put( "total2", 3 );

        Map<String, Integer> map2 = new TreeMap<>();
        map2.put( "otherTotal1", 1 );
        map2.put( "otherTotal2", 2 );

        System.out.println( sumMaps( map, map2 ) );
    }

    private static List<Integer> sumMaps( Map<String, Integer>... maps ){
        List<Integer> result = new ArrayList<>();
        for( Map<String, Integer> map : maps ){
            List<Integer> list = new ArrayList<Integer>( map.values() );

            for( int i = 0; i < list.size(); i++ ){
                if( indexExists( result, i ) ){
                    // sums up existing and new value
                    Integer oldValue = result.get( i );
                    Integer newValue = oldValue + list.get( i );
                    result.remove( i );
                    result.add( i, newValue );
                }
                else{
                    // no existing value
                    result.add( list.get( i ) );
                }
            }
        }

        return result;
    }

    private static boolean indexExists( List<Integer> list, int index ){
        return index >= 0 && index < list.size();
    }

---

请注意，如果值位于

HashMap

中，则排序实际上是随机的<虽然code>LinkedHashMap和

TreeMap

具有定义良好的顺序

如果地图大小不同怎么办？我在这里假设您也只需要单个值

最好的方法是并行迭代这两个映射。这样就不会复制任何内容，并且每个映射只迭代一次

private static List<Integer> sumMapValues(Map<?, Integer> map1, Map<?, Integer> map2) {
    Iterator<Integer> iter1 = map1.values().iterator();
    Iterator<Integer> iter2 = map2.values().iterator();
    List<Integer> sum = new ArrayList<>();
    while (iter1.hasNext() || iter2.hasNext()) {
        if (! iter2.hasNext())
            sum.add(iter1.next());
        else if (! iter1.hasNext())
            sum.add(iter2.next());
        else
            sum.add(iter1.next() + iter2.next());
    }
    return sum;
}

---

问题在于列表，而不是地图。要合并两个列表，例如：

public static void main(String... args) {

    // Example
    List<Integer> listA = new ArrayList<>();
    listA.add(1);
    listA.add(2);
    listA.add(3);
    listA.add(4);

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

    map1.put("totalPriceSet1", listA);

    List<Integer> listB = new ArrayList<>();
    listB.add(2);
    listB.add(3);
    listB.add(4);
    listB.add(5);

    Map<String, List<Integer>> map2 = new HashMap<>();
    map2.put("totalPriceSet2", listB);

    // Sum
    List<Integer> sum = sum(map1.get("totalPriceSet1"), map2.get("totalPriceSet2"));

    // Put in third map if you want
    Map<String, List<Integer>> map3 = new HashMap<>();
    map3.put("sum", sum);

    // Output
    System.out.println(map3.get("sum").stream().map(Object::toString).collect(Collectors.joining(",", "{", "}")));

}

public static List<Integer> sum(List<Integer> listA, List<Integer> listB) {
    List<Integer> result = new ArrayList<>();

    Iterator<Integer> iteratorA = listA.iterator();
    Iterator<Integer> iteratorB = listB.iterator();

    while (iteratorA.hasNext() && iteratorB.hasNext()) {
        result.add(iteratorA.next() + iteratorB.next());
    }

    return result;
}

publicstaticvoidmain（字符串…参数）{
//范例
List listA=new ArrayList（）；
增加（1）；
增加（2）；
增加（3）；
增加（4）；
Map map1=新的HashMap（）；
map1.put（“totalPriceSet1”，列表a）；
List listB=新的ArrayList（）；
清单b.添加（2）；
清单b.添加（3）；
清单b.添加（4）；
清单b.添加（5）；
Map map2=新的HashMap（）；
map2.put（“totalPriceSet2”，列表B）；
//总数
List sum=sum（map1.get（“totalPriceSet1”）、map2.get（“totalPriceSet2”）；
//如果你愿意的话，把第三张地图放进去
Map map3=新的HashMap（）；
map3.put（“总和”，总和）；
//输出
System.out.println（map3.get（“sum”）.stream（）；
}
公共静态列表总和（列表A、列表B）{
列表结果=新建ArrayList（）；
迭代器Iterator=listA.Iterator（）；
迭代器iteratorB=listB.Iterator（）；
while（iteratorA.hasNext（）&&iteratorB.hasNext（））{
add（iteratorA.next（）+iteratorB.next（））；
}
返回结果；
}

我所做的是

    private static List<Integer> sumValue(Map<String, List<Integer>> map1,
                                 Map<String, List<Integer>> map2) 
{
        List<Integer> priceValues1Int = new ArrayList<Integer>();
        List<Integer> priceValues2Int = new ArrayList<Integer>();
        List<Integer> sum = new ArrayList<Integer>();
        for (List<Integer> integer : map1.values()) {
            priceValues1Int = integer;
        }
        for (List<Integer> integer2 : map2.values()) {
            priceValues2Int = integer2;
        }
        for(int i=0; i<priceValues1Int .size(); i++){
            int sum1 =  priceValues1Int .get(i)+priceValues2Int .get(i);
            sum.add(sum1);
        }
    return sum;
}

private static List sumValue（映射映射1，
地图（地图2）
{
ListPriceValues1int=new ArrayList（）；
List priceValues2Int=new ArrayList（）；
列表总和=新的ArrayList（）；
对于（列表整数：map1.values（））{
priceValues1Int=整数；
}
对于（列表整数2:map2.values（））{
priceValues2Int=整数2；
}
对于（int i=0；iIs有什么理由将值存储为字符串而不是整数？是的，因为我正在为所有值添加符号。@sam有一个模式，您应该研究一下，这里有一个相关的@sam。您可以始终将值存储为整数，进行数字处理，然后在需要显示/附加时显示/附加该值。）e$符号您可以简单地使用整数。使用
HashMap
的toString（num）或'$“+num'不能保证排序，事实恰恰相反，因此结果可能很容易得到
[4,4]
或
[5,3]
。我无法添加值，因为我将其视为Java 8版本上的
映射
糟糕的性能，对元素进行顺序搜索以找到其索引，如果有多个相同值的元素，则会得到错误的索引，从而得到错误的和。--经典版本假设
列表
，其中索引为okup是可以的，但问题是关于
Map
值的，所以这里有点离题了。@Andreas：我删除了java 8版本，但不认为问题是关于
Map
，提问者从不使用键。换句话说，问题是关于
Map
值的，而Map值是
集合的。正确，但a
Collection
不是一个
列表
集合
甚至没有一个按索引获取的方法，尽管所有列表都有，但像
LinkedList这样的列表必须按顺序搜索索引。对数组备份列表以外的任何对象执行按索引获取对性能都非常有害，而且对于这个特定的pr来说没有必要问题。问题是关于
集合
中元素一个接一个的总和（基于它们的索引）。如果该
集合
不能保证排序，则该问题是不确定的，没有意义，因此该问题与
集合
无关，而是与
列表
（或任何其他排序集合）有关。我的第一句话。对于“按索引获取性能”方面，我更改了我的示例并使用了
迭代器
。谢谢。我无法添加值，因为我将其视为
映射
private static List<Integer> sumMapValues(Map<?, Integer> map1, Map<?, Integer> map2) {
    Iterator<Integer> iter1 = map1.values().iterator();
    Iterator<Integer> iter2 = map2.values().iterator();
    List<Integer> sum = new ArrayList<>();
    while (iter1.hasNext() || iter2.hasNext()) {
        if (! iter2.hasNext())
            sum.add(iter1.next());
        else if (! iter1.hasNext())
            sum.add(iter2.next());
        else
            sum.add(iter1.next() + iter2.next());
    }
    return sum;
}

Map<String, Integer> map1 = new LinkedHashMap<>();
map1.put("a", 1);
map1.put("b", 2);
map1.put("c", 3);
map1.put("d", 4);
Map<String, Integer> map2 = new LinkedHashMap<>();
map2.put("x", 2);
map2.put("y", 3);
map2.put("z", 4);
System.out.println(map1);
System.out.println(map2);
System.out.println(sumMapValues(map1, map2));

public static void main(String... args) {

    // Example
    List<Integer> listA = new ArrayList<>();
    listA.add(1);
    listA.add(2);
    listA.add(3);
    listA.add(4);

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

    map1.put("totalPriceSet1", listA);

    List<Integer> listB = new ArrayList<>();
    listB.add(2);
    listB.add(3);
    listB.add(4);
    listB.add(5);

    Map<String, List<Integer>> map2 = new HashMap<>();
    map2.put("totalPriceSet2", listB);

    // Sum
    List<Integer> sum = sum(map1.get("totalPriceSet1"), map2.get("totalPriceSet2"));

    // Put in third map if you want
    Map<String, List<Integer>> map3 = new HashMap<>();
    map3.put("sum", sum);

    // Output
    System.out.println(map3.get("sum").stream().map(Object::toString).collect(Collectors.joining(",", "{", "}")));

}

public static List<Integer> sum(List<Integer> listA, List<Integer> listB) {
    List<Integer> result = new ArrayList<>();

    Iterator<Integer> iteratorA = listA.iterator();
    Iterator<Integer> iteratorB = listB.iterator();

    while (iteratorA.hasNext() && iteratorB.hasNext()) {
        result.add(iteratorA.next() + iteratorB.next());
    }

    return result;
}

    private static List<Integer> sumValue(Map<String, List<Integer>> map1,
                                 Map<String, List<Integer>> map2) 
{
        List<Integer> priceValues1Int = new ArrayList<Integer>();
        List<Integer> priceValues2Int = new ArrayList<Integer>();
        List<Integer> sum = new ArrayList<Integer>();
        for (List<Integer> integer : map1.values()) {
            priceValues1Int = integer;
        }
        for (List<Integer> integer2 : map2.values()) {
            priceValues2Int = integer2;
        }
        for(int i=0; i<priceValues1Int .size(); i++){
            int sum1 =  priceValues1Int .get(i)+priceValues2Int .get(i);
            sum.add(sum1);
        }
    return sum;
}