java有两个数组map比较 通过id关联，number可能数量变化 比较他们之间增加修改删除

在Java中，如果你有两个数组，每个数组中的元素都包含一个ID和一个可能变化的数量（number），并且你想比较这两个数组以找出增加、修改和删除的元素，你可以采取以下步骤：

创建数据类：首先，定义一个类来表示数组中的元素，这个类应该包含ID和数量作为属性。
转换为Map：然后，将这两个数组转换为以ID为键、元素对象为值的Map集合。
比较Map：遍历这两个Map集合，比较它们的键和值，以确定哪些元素是增加的、哪些是被修改的、哪些是被删除的。

import java.util.*;

class Element {
    private int id;
    private int number;

    public Element(int id, int number) {
        this.id = id;
        this.number = number;
    }

    public int getId() {
        return id;
    }

    public int getNumber() {
        return number;
    }

    @Override
    public String toString() {
        return "Element{id=" + id + ", number=" + number + '}';
    }
}

public class ArrayComparison {
    public static void main(String[] args) {
        // 示例数据
        Element[] oldArray = {
            new Element(1, 10),
            new Element(2, 20),
            new Element(3, 30)
        };

        Element[] newArray = {
            new Element(1, 15), // 修改
            new Element(2, 20), // 无变化
            new Element(4, 40), // 增加
        };

        // 将数组转换为Map
        Map<Integer, Element> oldMap = new HashMap<>();
        for (Element e : oldArray) {
            oldMap.put(e.getId(), e);
        }

        Map<Integer, Element> newMap = new HashMap<>();
        for (Element e : newArray) {
            newMap.put(e.getId(), e);
        }

        // 初始化比较结果
        Set<Integer> addedIds = new HashSet<>(newMap.keySet());
        addedIds.removeAll(oldMap.keySet());

        Set<Integer> deletedIds = new HashSet<>(oldMap.keySet());
        deletedIds.removeAll(newMap.keySet());

        Map<Integer, Element> modifiedElements = new HashMap<>();
        for (Integer id : newMap.keySet()) {
            if (oldMap.containsKey(id)) {
                Element oldElement = oldMap.get(id);
                Element newElement = newMap.get(id);
                if (!oldElement.getNumber().equals(newElement.getNumber())) {
                    modifiedElements.put(id, new Element(id, newElement.getNumber())); // 只存储修改后的number，不存储整个对象以减少内存使用（或者根据需要存储整个对象）
                } else {
                    // 如果数量没变化，则从addedIds中移除（虽然在这个例子中它本来就不会在addedIds里）
                    addedIds.remove(id);
                }
            }
        }

        // 输出结果
        System.out.println("Added:");
        for (Integer id : addedIds) {
            System.out.println(newMap.get(id));
        }

        System.out.println("\nModified:");
        for (Map.Entry<Integer, Element> entry : modifiedElements.entrySet()) {
            System.out.println("Old: Element{id=" + entry.getKey() + ", number=" + oldMap.get(entry.getKey()).getNumber() + '}');
            System.out.println("New: " + entry.getValue());
        }

        System.out.println("\nDeleted:");
        for (Integer id : deletedIds) {
            System.out.println(oldMap.get(id));
        }
    }
}

注意：

在上面的代码中，modifiedElements Map实际上存储的是修改后的Element对象的一个简化版本，只包含ID和新的数量。这是为了节省内存，因为完整的旧对象已经存在于oldMap中。如果你需要完整的旧对象和新对象进行比较，你可以存储整个对象。
另外，请注意，在输出修改的元素时，我同时输出了旧的和新的元素以便比较。在实际应用中，你可能只需要输出修改后的新元素。
这个示例代码没有处理可能的异常，比如数组中的元素可能有重复的ID，这在实际应用中是需要考虑的。如果ID是唯一的，那么上面的代码是有效的。如果ID可能重复，你需要决定如何处理这种情况。