在 Java 中复制 HashMap

Question

我正在尝试保留一个包含成员的类的临时容器：

HashMap<Integer,myObject> myobjectHashMap

一个名为 myobjectsList 的类

那我做

myobjectsListA = new myobjectsList();
myobjectsListB = new myobjectsList();

然后：将一些 hashmap 项添加到 A（如 2）

然后：

myobjectListB = myobjectListA; //B has 2

然后：将 hashmap 项添加到 A（比如另外 4 个）

然后：将A返回到B中存储的项目

myobjectListA = myobjectListb;

但是当我这样做时，当我向 A 添加哈希图项时，B 会随着 A 增长。 A 现在有 6 个项目，因为 B 有 6 个。

我希望 A 在最后一次分配后仍然保留原来的 2。 在 C++ 中我会使用对象的复制，java 的等价物是什么？

补充：好的，我遗漏了一些东西来解释这一点。 MyObjectsList 不包含 HashMap，它派生自类 MyBaseOjbectsList，该类具有 HashMap 成员和 MyObjectsList 扩展 MyBaseOjbectsList。这有什么不同吗？

Answer 1

Java 支持浅（不深）复制概念

您可以使用以下方法对其进行归档：

• 构造函数
• clone()
• putAll()

Answer 2

从 Java 10 开始可以使用

Map.copyOf

用于创建一个浅拷贝，它也是不可变的。 （这是它的Javadoc）。对于深拷贝，正如answer you 中所述，需要某种值映射器来制作值的安全拷贝。您不需要复制 keys，因为它们必须是 不可变的。

Answer 3

如果我们想在 Java 中复制一个对象，我们需要考虑两种可能性：浅复制和深复制。

浅拷贝是我们只拷贝字段值的方法。因此，副本可能依赖于原始对象。在深度复制方法中，我们确保树中的所有对象都被深度复制，因此副本不依赖于任何可能会更改的早期现有对象。

这个问题是应用深拷贝方法的完美定义。

首先，如果您有一个简单的HashMap<Integer, List<T>> 映射，那么我们只需创建一个这样的解决方法。创建List<T> 的新实例。

public static <T> HashMap<Integer, List<T>> deepCopyWorkAround(HashMap<Integer, List<T>> original)
{
    HashMap<Integer, List<T>> copy = new HashMap<>();
    for (Map.Entry<Integer, List<T>> entry : original.entrySet()) {
        copy.put(entry.getKey(), new ArrayList<>(entry.getValue()));
    }
    return copy;
}

这个使用Stream.collect()的方法来创建克隆地图，但是和上一个方法的思路是一样的。

public static <T> Map<Integer, List<T>> deepCopyStreamWorkAround(Map<Integer, List<T>> original)
{
    return original
            .entrySet()
            .stream()
            .collect(Collectors.toMap(Map.Entry::getKey, valueMapper -> new ArrayList<>(valueMapper.getValue())));
}   

但是，如果T 中的实例也是可变对象，我们就有大问题了。在这种情况下，真正的深拷贝是解决此问题的替代方案。它的优点是对象图中的至少每个可变对象都是递归复制的。由于副本不依赖于之前创建的任何可变对象，因此它不会像我们在浅副本中看到的那样被意外修改。

为了解决这个深拷贝实现将完成的工作。

public class DeepClone
{
    public static void main(String[] args)
    {
        Map<Long, Item> itemMap = Stream.of(
                entry(0L, new Item(2558584)),
                entry(1L, new Item(254243232)),
                entry(2L, new Item(986786)),
                entry(3L, new Item(672542)),
                entry(4L, new Item(4846)),
                entry(5L, new Item(76867467)),
                entry(6L, new Item(986786)),
                entry(7L, new Item(7969768)),
                entry(8L, new Item(68868486)),
                entry(9L, new Item(923)),
                entry(10L, new Item(986786)),
                entry(11L, new Item(549768)),
                entry(12L, new Item(796168)),
                entry(13L, new Item(868421)),
                entry(14L, new Item(923)),
                entry(15L, new Item(986786)),
                entry(16L, new Item(549768)),
                entry(17L, new Item(4846)),
                entry(18L, new Item(4846)),
                entry(19L, new Item(76867467)),
                entry(20L, new Item(986786)),
                entry(21L, new Item(7969768)),
                entry(22L, new Item(923)),
                entry(23L, new Item(4846)),
                entry(24L, new Item(986786)),
                entry(25L, new Item(549768))
        ).collect(entriesToMap());


        Map<Long, Item> clone = DeepClone.deepClone(itemMap);
        clone.remove(1L);
        clone.remove(2L);

        System.out.println(itemMap);
        System.out.println(clone);
    }

    private DeepClone() {}

    public static <T> T deepClone(final T input)
    {
        if (input == null) return null;

        if (input instanceof Map<?, ?>) {
            return (T) deepCloneMap((Map<?, ?>) input);
        } else if (input instanceof Collection<?>) {
            return (T) deepCloneCollection((Collection<?>) input);
        } else if (input instanceof Object[]) {
            return (T) deepCloneObjectArray((Object[]) input);
        } else if (input.getClass().isArray()) {
            return (T) clonePrimitiveArray((Object) input);
        }

        return input;
    }

    private static Object clonePrimitiveArray(final Object input)
    {
        final int length = Array.getLength(input);
        final Object output = Array.newInstance(input.getClass().getComponentType(), length);
        System.arraycopy(input, 0, output, 0, length);
        return output;
    }

    private static <E> E[] deepCloneObjectArray(final E[] input)
    {
        final E[] clone = (E[]) Array.newInstance(input.getClass().getComponentType(), input.length);
        for (int i = 0; i < input.length; i++) {
            clone[i] = deepClone(input[i]);
        }

        return clone;
    }

    private static <E> Collection<E> deepCloneCollection(final Collection<E> input)
    {
        Collection<E> clone;
        if (input instanceof LinkedList<?>) {
            clone = new LinkedList<>();
        } else if (input instanceof SortedSet<?>) {
            clone = new TreeSet<>();
        } else if (input instanceof Set) {
            clone = new HashSet<>();
        } else {
            clone = new ArrayList<>();
        }

        for (E item : input) {
            clone.add(deepClone(item));
        }

        return clone;
    }

    private static <K, V> Map<K, V> deepCloneMap(final Map<K, V> map)
    {
        Map<K, V> clone;
        if (map instanceof LinkedHashMap<?, ?>) {
            clone = new LinkedHashMap<>();
        } else if (map instanceof TreeMap<?, ?>) {
            clone = new TreeMap<>();
        } else {
            clone = new HashMap<>();
        }

        for (Map.Entry<K, V> entry : map.entrySet()) {
            clone.put(deepClone(entry.getKey()), deepClone(entry.getValue()));
        }

        return clone;
    }
}

Answer 4

不同之处在于，在 C++ 中，您的对象位于堆栈中，而在 Java 中，您的对象位于堆中。如果 A 和 B 是对象，那么在 Java 中的任何时候都可以：

B = A

A 和 B 指向同一个对象，所以你对 A 做的任何事情都会对 B 做，反之亦然。

如果您想要两个不同的对象，请使用 new HashMap()。

您可以使用Map.putAll(...) 在两个地图之间复制数据。

Answer 5

由于 OP 提到他无法访问其中存在 HashMap 的基类 - 恐怕可用的选项很少。

在 Java 中执行对象的深层复制的一种（非常缓慢且资源密集的）方法是滥用许多类有意或无意扩展的“可序列化”接口，然后利用它来将您的类序列化为 ByteStream .反序列化后，您将拥有相关对象的深层副本。

可在此处找到相关指南：https://www.avajava.com/tutorials/lessons/how-do-i-perform-a-deep-clone-using-serializable.html

Answer 6

如果你想要一份 HashMap 的副本，你需要用它构造一个新的。

myobjectListB = new HashMap<Integer,myObject>(myobjectListA);

这将创建地图的（浅）副本。

Answer 7

这里有一个小（巨大）的轻描淡写。如果您想复制带有嵌套结构的HashMap，HashMap.putAll() 将通过引用复制，因为它不知道如何准确复制您的对象。 For example:

import java.util.*;
class Playground {
    public static void main(String[ ] args) {
        Map<Integer, Map<Integer,List<Float>>> dataA = new HashMap<>();
        Map<Integer, Map<Integer,List<Float>>> dataB = new HashMap<>();

        dataA.put(1, new HashMap<>());
        dataB.putAll(dataA);

        assert(dataB.get(1).size() == 0);

        dataA.get(1).put(2, new ArrayList<>());

        if (dataB.get(1).size() == 1) { // true
            System.out.println(
                "Sorry object reference was copied - not the values");
        }
    }
}

所以基本上你需要像这里一样自己复制字段

List <Float> aX = new ArrayList<>(accelerometerReadingsX);
List <Float> aY = new ArrayList<>(accelerometerReadingsY);

List <Float> gX = new ArrayList<>(gyroscopeReadingsX);
List <Float> gY = new ArrayList<>(gyroscopeReadingsY);

Map<Integer, Map<Integer, Float>> readings = new HashMap<>();

Map<Integer,List<Float>> accelerometerReadings = new HashMap<>();
accelerometerReadings.put(X_axis, aX);
accelerometerReadings.put(Y_axis, aY);
readings.put(Sensor.TYPE_ACCELEROMETER, accelerometerReadings);

Map<Integer,List<Float>> gyroscopeReadings = new HashMap<>();
gyroscopeReadings.put(X_axis, gX);
gyroscopeReadings.put(Y_axis, gY);
readings.put(Sensor.TYPE_GYROSCOPE, gyroscopeReadings);

Answer 8

由于这个问题仍然没有答案，而且我遇到了类似的问题，我会尝试回答这个问题。问题（正如其他人已经提到的）是您只是复制对同一对象的引用，因此对副本的修改也会修改原始对象。所以你要做的是复制对象（你的地图值）本身。最简单的方法是让所有对象都实现可序列化接口。然后序列化和反序列化您的地图以获得真实副本。您可以自己执行此操作，也可以使用您可以在此处找到的 apache commons SerializationUtils#clone()：https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/SerializationUtils.html 但请注意，这是最简单的方法，但序列化和反序列化大量对象是一项昂贵的任务。

Answer 9

你也可以使用

clone()

将所有元素从一个hashmap复制到另一个hashmap的方法

将所有元素从一个 hashmap 复制到另一个的程序

import java.util.HashMap;

public class CloneHashMap {    
     public static void main(String a[]) {    
        HashMap hashMap = new HashMap();    
        HashMap hashMap1 = new HashMap();    
        hashMap.put(1, "One");
        hashMap.put(2, "Two");
        hashMap.put(3, "Three");
        System.out.println("Original HashMap : " + hashMap);
        hashMap1 = (HashMap) hashMap.clone();
        System.out.println("Copied HashMap : " + hashMap1);    
    }    
}

来源：http://www.tutorialdata.com/examples/java/collection-framework/hashmap/copy-all-elements-from-one-hashmap-to-another

Answer 10

您将一个对象分配给另一个对象，您所做的只是将 reference 复制到该对象，而不是它的内容。您需要做的是获取对象 B 并手动将对象 A 的内容复制到其中。

如果您经常这样做，您可以考虑在类上实现clone() 方法，该方法将创建一个相同类型的新对象，并将其所有内容复制到新对象中。

Answer 11

在 Java 中，当你编写时：

Object objectA = new Object();
Object objectB = objectA;

objectA 和objectB 相同，指向相同的引用。改变一个会改变另一个。因此，如果您更改 objectA 的状态（不是其引用）objectB 也会反映该更改。

但是，如果你写：

objectA = new Object()

那么objectB 仍然指向您创建的第一个对象（原始objectA），而objectA 现在指向一个新对象。