Подтвердить что ты не робот

Назначение Hashmap для Hashmap

У меня есть hashmap, который я хочу скопировать для другого использования. Но всякий раз, когда я копирую его и повторно его использую, он также меняет исходный. Почему это?

    do {
            Map<Integer, Map<String, Object>> map1 = originalMap; 
            //at the second iteration originalMap is the same as map1 of the last iteration, 
            //eventhough the change was nog accepted;
            //do something with map1 (change value);
            if(change is accepted) {
               originalMap = map1;
            }
        } while(iteration < 10);

Заранее спасибо

    public static <Integer,String, Schedule>Map<Integer, Map<String, Schedule>> deepCopy(Map<Integer, Map<String, Schedule>> original) {
    Map<Integer, Map<String, Schedule>> copy = new HashMap<Integer, Map<String, Schedule>>();

    for (Map.Entry<Integer, Map<String, Schedule>> entry : original.entrySet()) {
        copy.put(entry.getKey(), deepCopy2(entry.getValue()));
    }
    return copy;
}

public static <String, Schedule>Map<String, Schedule> deepCopy2(Map<String, Schedule> original) {
    Map<String, Schedule> copy = new HashMap<String, Schedule>();
    for (Map.Entry<String, Schedule> entry : original.entrySet()) {
        copy.put(entry.getKey(), entry.getValue());
    }

    return copy;
}
4b9b3361

ОТВЕТЫ

Ответ 1

То, что вы сделали, это не создание копии карты, а ссылка на нее. когда две ссылки указывают на один и тот же объект, изменения в одном будут отражаться в другом.

Решение 1: Если это была карта из какого-то простого типа в другой, вы должны сделать это вместо:

Map<SomeType, OtherType> map1 = new HashMap<SomeType, OtherType>(original);

Это называется Копировать конструктор. Почти все стандартные реализации Collection и Map имеют один, и обычно это самый простой способ клонирования простой структуры. Это будет работать нормально, пока SomeType и OtherType immutable (например, Integer и другие Number типы, Boolean, String, но не коллекции, даты, карты, массивы и т.д.)

Если нет, как указывали другие ответчики и комментаторы, вам также нужно скопировать значения карт.

Решение 2: Здесь быстрая и грязная версия, которая должна быть безопасной:

Map<Integer, Map<String, Object>> original=new HashMap<Integer, Map<String,Object>>();
Map<Integer, Map<String, Object>> copy = 
        new HashMap<Integer, Map<String, Object>>();
for(Entry<Integer, Map<String, Object>> entry : original.entrySet()){
    copy.put(entry.getKey(), new HashMap<String, Object>(entry.getValue()));
}

Но на самом деле мне нравится идея Хантера о предоставлении метода глубокой копии. Итак, решение 3: моя собственная версия с использованием общих параметров:

public static <K1, K2, V> Map<K1, Map<K2, V>> deepCopy(
    Map<K1, Map<K2, V>> original){

    Map<K1, Map<K2, V>> copy = new HashMap<K1, Map<K2, V>>();
    for(Entry<K1, Map<K2, V>> entry : original.entrySet()){
        copy.put(entry.getKey(), new HashMap<K2, V>(entry.getValue()));
    }
    return copy;
}

Вы можете называть это следующим образом:

Map<Integer, Map<String, Object>> original=new HashMap<Integer, Map<String,Object>>();
// do stuff here
Map<Integer, Map<String, Object>> copy = deepCopy(original);

Обновление

Я взломал класс, который выполняет глубокое клонирование для карт, коллекций и массивов (примитивных и других). Использование:

Something clone = DeepClone.deepClone(original);

Вот он:

public final class DeepClone {

    private DeepClone(){}

    public static <X> X deepClone(final X input) {
        if (input == null) {
            return input;
        } else if (input instanceof Map<?, ?>) {
            return (X) deepCloneMap((Map<?, ?>) input);
        } else if (input instanceof Collection<?>) {
            return (X) deepCloneCollection((Collection<?>) input);
        } else if (input instanceof Object[]) {
            return (X) deepCloneObjectArray((Object[]) input);
        } else if (input.getClass().isArray()) {
            return (X) clonePrimitiveArray((Object) input);
        }

        return input;
    }

    private static Object clonePrimitiveArray(final Object input) {
        final int length = Array.getLength(input);
        final Object copy = Array.newInstance(input.getClass().getComponentType(), length);
        // deep clone not necessary, primitives are immutable
        System.arraycopy(input, 0, copy, 0, length);
        return copy;
    }

    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;
        // this is of course far from comprehensive. extend this as needed
        if (input instanceof LinkedList<?>) {
            clone = new LinkedList<E>();
        } else if (input instanceof SortedSet<?>) {
            clone = new TreeSet<E>();
        } else if (input instanceof Set) {
            clone = new HashSet<E>();
        } else {
            clone = new ArrayList<E>();
        }

        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;
        // this is of course far from comprehensive. extend this as needed
        if (map instanceof LinkedHashMap<?, ?>) {
            clone = new LinkedHashMap<K, V>();
        } else if (map instanceof TreeMap<?, ?>) {
            clone = new TreeMap<K, V>();
        } else {
            clone = new HashMap<K, V>();
        }

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

        return clone;
    }
}

Ответ 2

Сделав это:

Map<Integer, Map<String, Object>> copy = originalMap;

... вы не копируете карту, создавая новую переменную, которая относится к одной и той же карте, и, очевидно, изменения, которые вы делаете с использованием этой переменной, будут отражаться на исходной карте - они указывают на тот же объект в памяти. Лучше скопируйте исходную карту, используя конструктор который получает другую карту в качестве параметра:

Map<Integer, Map<String, Object>> copy;
copy = new HashMap<Integer, Map<String, Object>>(originalMap);

Вышеприведенный код создаст мелкую копию исходной карты, что означает: если вы измените значение элементов внутри одной карты, изменения будут отражены в другом, но вы можете свободно добавлять/удалять элементы из карта и другое не будут затронуты. Если это не достаточно хорошо, вам нужно будет выполнить глубокую копию элементов на карте во время ее копирования.

Ответ 3

Простым и понятным решением было бы просто перебрать значения в Карте и скопировать их в карту:

Map<Integer, Map<String, Object>> map1;

//iterate over the map copying values into new map
for(Map.Entry entry : originalMap.entrySet())
{
   map1.put(entry.getKey(), new HashMap<String, Object>(entry.getValue()));
}

Лучшим решением было бы обернуть это в методе:

public static <K,J,V> Map<K, Map<J, V>> deepCopy(Map<K, Map<J, V>> original)
{
    Map<K, Map<J, V>> copy;

    //iterate over the map copying values into new map
    for(Map.Entry<K, Map<J, V>> entry : original.entrySet())
    {
       copy.put(entry.getKey(), new HashMap<J, V>(entry.getValue()));
    }

    return copy;
}

Ответ 4

В вашем коде originalMap просто ссылка на map1. Теперь они оба указывают на те же ключи и значения. Помните, что это Java, где '=' в ссылках на объекты - это просто ссылочное задание (не глубокая или мелкая копия).

Коллекция Java обычно поддерживает некоторую форму мелкого копирования через clone или putAll. В случае карт предполагается, что map1 и map2 имеют тип HashMap<KeyType,ValueType>, если вы хотите, чтобы одна карта была мелкой копией другой (что означает, отдельный объект HashMap, но с общими ключами и значениями), вы делаете это:

HashMap<KeyType,ValueType> map1();
HashMap<KeyType,ValueType> map2();

map2.put(x1,v1); // map2 = {{x1,v1}}

map1.put(x2,v2); // map1 = {{x2,v2}}

map1 = map2.clone(); // map1 = {{x1,v1}}, with x2 and v2 gone

map2.clear();
map2.put(x3,v3); // map2 = {{x3,v3}}
map2.put(x4,v4); // map2 = {{x3,v3},{x4,v4}}

map1.put(x4,v5); // map1 = {{x1,v1}, {x4,v5}}

// add all of map2 into map1, replacing any mappings with shared keys
map1.putAll(map2); // map1 = {{x1,v1},{x3,v3},{x4,v4}}, notice how v5 is gone

На прощальной мысли вам нужно привыкнуть к Java API. Это поможет вам многое.

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

Ответ 5

Это может быть немного запоздалым, но еще одним простым решением будет Сериализация карты на выходной поток и де-сериализация его на новый объект карты. Это также один из самых простых способов разорвать одноэлементный узор.