La copie d'une table de hachage en Java

Si vous voulez une copie de la table de hachage, vous devez construire une nouvelle avec.

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

Cela va créer une (profonde) copie de la carte.

La différence est qu'en C++, votre objet est sur la pile, alors qu'en Java, votre objet est dans le tas. Si A et B sont des Objets, en tout temps, en Java, vous n':

B = A

A et B pointent sur le même objet, donc tout ce que vous faites à vous faire à B et vice-versa.

Utiliser de nouvelles HashMap() si vous voulez deux objets différents.

Et vous pouvez utiliser Map.putAll(...) pour copier des données entre deux Cartes.

En Java, quand vous écrivez:

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

objectA et objectB sont les mêmes et le point à la même référence. Le changement de l'un va changer les autres. Donc, si vous modifiez l'état de objectA (pas de référence) objectB va refléter ce changement trop.

Toutefois, si vous écrivez:

objectA = new Object()

Puis objectB pointe toujours vers le premier objet que vous avez créé (original objectA), tandis que objectA est maintenant pointe vers un nouvel Objet.

Si nous voulons copier un objet en Java, il existe deux possibilités que nous avons besoin à considérer: une copie superficielle et un copie en profondeur.

La copie superficielle est l'approche à adopter lorsqu'on ne copie que les valeurs de champ. Par conséquent, la copie peut être dépend de l'objet d'origine. Dans le copie en profondeur approche, nous nous assurons que tous les objets de l'arbre sont profondément copié, de sorte que la copie n'est pas fonction d'une quelconque antérieure objet existant qui pourrait jamais changer.

Cette question est la parfaite définition pour l'application de la copie en profondeur approche.

Tout d'abord, si vous avez un simple HashMap<Integer, List<T>> carte alors que nous venons de créer une solution de ce genre. La création d'une nouvelle instance de la 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;
}

Celui-ci utilise Stream.collect() méthode pour créer le clone de la carte, mais utilise la même idée que la méthode précédente.

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())));
}   

Mais, si les instances à l'intérieur de T sont également mutable objets nous avons un gros problème. Dans ce cas, une réelle profondeur copie est une alternative qui permet de résoudre ce problème. Son avantage est qu'au moins chaque mutable objet dans l'objet graphique est copié récursivement. Depuis la copie n'est pas fonction d'une quelconque mutable objet qui a été créé plus tôt, il ne sera pas modifié par accident, comme nous l'avons vu avec la copie.

À résoudre que cette copie en profondeur les implémentations de faire le travail.

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;
}
}

Depuis l'OP a dit qu'il n'a pas accès à la classe de base à l'intérieur de laquelle existe une HashMap - j'ai peur, il y a très peu d'options disponibles.

Un (douloureusement lent et laborieux) de l'exécution d'une copie d'un objet en Java est de l'abus de la "Serializable' interface de nombreuses classes, que ce soit volontairement ou involontairement étendre - et ensuite l'utiliser pour serialise votre classe à ByteStream. Lors de la sérialisation, vous aurez une copie de l'objet en question.

Un guide pour ce qui peut être trouvé ici: https://www.avajava.com/tutorials/lessons/how-do-i-perform-a-deep-clone-using-serializable.html