Java 更新地图值的有效方法
我们拥有一个包含超过1000万条记录的交易详细信息的阵列Java 更新地图值的有效方法,java,optimization,collections,Java,Optimization,Collections,我们拥有一个包含超过1000万条记录的交易详细信息的阵列 Key1 Key2 Value ----------------------- A B <value> B C <value> D A <value> ... ... //map1和map2是您现有的两个地图 映射结果映射=新映射（）； 对于（Map.Entry:map1.entrySet（））{ resultMap.
Key1 Key2 Value
-----------------------
A B <value>
B C <value>
D A <value>
...
...
//map1和map2是您现有的两个地图
映射结果映射=新映射（）；
对于（Map.Entry:map1.entrySet（））{
resultMap.put（entry.getKey（）、entry.getValue（）+map2.get（entry.getKey（））；
}
//map1和map2是您现有的两个地图
映射结果映射=新映射（）；
对于（Map.Entry:map1.entrySet（））{
resultMap.put（entry.getKey（）、entry.getValue（）+map2.get（entry.getKey（））；
}
public class Transaction {
private String target;
private String source;
private String operation;
private int amount;
public Transaction(String target, String source, String operation, int amount) {
this.target = target;
this.source = source;
this.operation = operation;
this.amount = amount;
}
// + getters
}
sourcetarget“Add”金额推断，目标将根据金额增加。如果操作是“Subtract”
，则事务被反转
public static void main(String[] args) {
// set-up sample data
Map<String, Integer> map = new HashMap<>();
for (String s : Arrays.asList("A", "B", "C", "D", "X")) {
map.put(s, 1000);
}
List<Transaction> transactions = Arrays.asList(
new Transaction("A","B","Add",10),
new Transaction("C","D","Subtract",20),
new Transaction("D","B","Add",50),
new Transaction("B","X","Subtract",30)
);
// implement the transactions
for (Transaction t : transactions) {
final int amount = t.getOperation().equals("Add") ? t.getAmount() : -t.getAmount();
map.put(t.getSource(), map.get(t.getSource()) - amount);
map.put(t.getTarget(), map.get(t.getTarget()) + amount);
}
System.out.println(map); // prints "{A=1010, B=910, C=980, D=1070, X=1030}"
}
然后，给定一个保存初始值的Map
，我们可以循环这些事务并进行计算。在每一次交易中，我们只需要从源代码中减去金额，然后将其添加到目标代码中（在“subtract”
的情况下，金额为负数，因此交易实际上是反向的）
publicstaticvoidmain（字符串[]args）{
//设置样本数据
Map Map=newhashmap（）；
对于（字符串s:Arrays.asList（“A”、“B”、“C”、“D”、“X”））{
地图.put(s,1000);；
}
列表事务=Arrays.asList(
新交易（“A”、“B”、“添加”10），
新交易（“C”、“D”、“减法”、20），
新交易（“D”、“B”、“Add”、50），
新交易（“B”、“X”、“减法”、30）
);
//执行事务
对于（事务t：事务）{
最终整数金额=t.getOperation（）.等于（“添加”）？t.getAmount（）：-t.getAmount（）；
map.put（t.getSource（），map.get（t.getSource（））-amount）；
map.put（t.getTarget（），map.get（t.getTarget（））+金额）；
}
System.out.println（map）；//打印“{A=1010，B=910，C=980，D=1070，X=1030}”
}
您有一个事务列表。让我们用一个名为
public class Transaction {
private String target;
private String source;
private String operation;
private int amount;
public Transaction(String target, String source, String operation, int amount) {
this.target = target;
this.source = source;
this.operation = operation;
this.amount = amount;
}
// + getters
}
source
将表示事务的源，而target
将表示目标。在执行“Add”
操作的情况下，源将根据金额推断，目标将根据金额增加。如果操作是“Subtract”
，则事务被反转
public static void main(String[] args) {
// set-up sample data
Map<String, Integer> map = new HashMap<>();
for (String s : Arrays.asList("A", "B", "C", "D", "X")) {
map.put(s, 1000);
}
List<Transaction> transactions = Arrays.asList(
new Transaction("A","B","Add",10),
new Transaction("C","D","Subtract",20),
new Transaction("D","B","Add",50),
new Transaction("B","X","Subtract",30)
);
// implement the transactions
for (Transaction t : transactions) {
final int amount = t.getOperation().equals("Add") ? t.getAmount() : -t.getAmount();
map.put(t.getSource(), map.get(t.getSource()) - amount);
map.put(t.getTarget(), map.get(t.getTarget()) + amount);
}
System.out.println(map); // prints "{A=1010, B=910, C=980, D=1070, X=1030}"
}
然后，给定一个保存初始值的Map
，我们可以循环这些事务并进行计算。在每一次交易中，我们只需要从源代码中减去金额，然后将其添加到目标代码中（在“subtract”
的情况下，金额为负数，因此交易实际上是反向的）
publicstaticvoidmain（字符串[]args）{
//设置样本数据
Map Map=newhashmap（）；
对于（字符串s:Arrays.asList（“A”、“B”、“C”、“D”、“X”））{
地图.put(s,1000);；
}
列表事务=Arrays.asList(
新交易（“A”、“B”、“添加”10），
新交易（“C”、“D”、“减法”、20），
新交易（“D”、“B”、“Add”、50），
新交易（“B”、“X”、“减法”、30）
);
//执行事务
对于（事务t：事务）{
最终整数金额=t.getOperation（）.等于（“添加”）？t.getAmount（）：-t.getAmount（）；
map.put（t.getSource（），map.get（t.getSource（））-amount）；
map.put（t.getTarget（），map.get（t.getTarget（））+金额）；
}
System.out.println（map）；//打印“{A=1010，B=910，C=980，D=1070，X=1030}”
}
由于输入由3个值组成（Key1
、Key2
和Value
），因此似乎缺少此答案。我理解此问题是两个地图的关键相加。也许我误解了？你的map1
只有Key
和Value
，所以当OP需要result[Key]=result[Key]+Value
时，你总是在做result[Key2]=result[Key1]+Value
。另外，您的resultMap
最初是空的，因此您将使用该代码获得NullPointerException
。啊，对不起，我现在看到了您的两个映射，但这仍然不起作用，因为问题中的前两个示例行是B=A+value
和C=B+value
，这意味着第二个B
是第一个的结果，否则“应维持交易顺序”的陈述没有任何意义。请解释此代码的作用以及它如何回答问题。因为输入由3个值组成（Key1
、Key2
和Value
），这个答案似乎缺乏。我理解这个问题是两张地图的关键。也许我误解了？你的map1
只有Key
和Value
，所以当OP需要result[Key]=result[Key]+Value
时，你总是在做result[Key2]=result[Key1]+Value
。另外，您的resultMap
最初是空的，因此您将使用该代码获得NullPointerException
。啊，对不起，我现在看到了您的两个映射，但这仍然不起作用，因为问题中的前两个示例行是B=A+value
和C=B+value
，这意味着第二个B
是第一个的结果，否则“应维持交易顺序”的说法没有任何意义。请解释此代码的作用以及它如何回答问题。谢谢。我将使用大数据集运行一些测试，但是这个解决方案很有帮助。我想知道是否有可能通过以多线程方式分块处理“事务”来提高性能（忽略原始映射值，但在所有事务结束时添加值）。我将进一步探讨这一点。再次感谢你
public static void main(String[] args) {
// set-up sample data
Map<String, Integer> map = new HashMap<>();
for (String s : Arrays.asList("A", "B", "C", "D", "X")) {
map.put(s, 1000);
}
List<Transaction> transactions = Arrays.asList(
new Transaction("A","B","Add",10),
new Transaction("C","D","Subtract",20),
new Transaction("D","B","Add",50),
new Transaction("B","X","Subtract",30)
);
// implement the transactions
for (Transaction t : transactions) {
final int amount = t.getOperation().equals("Add") ? t.getAmount() : -t.getAmount();
map.put(t.getSource(), map.get(t.getSource()) - amount);
map.put(t.getTarget(), map.get(t.getTarget()) + amount);
}
System.out.println(map); // prints "{A=1010, B=910, C=980, D=1070, X=1030}"
}