Der Gleiche oder der Selbe?

[Guest]

Hallo,

ich habe einen Hashtable():

Hashtable x = new Hashtable();
x.add("Key1","Val1");

Jetzt möchte ich diesen Hashtable kopieren:

Hashtable y = x;

Füge ich jetzt in x noch einen Eintrag dazu ist er auch in y. Wie kann ich eine Kopie des Hashtables erstellen und nicht auf das vorhandene Objekt referenzieren?

 

[diggaa1984]

public Object clone()
Creates a shallow copy of this hashtable. All the structure of the hashtable itself is copied, but the keys and values are not cloned. This is a relatively expensive operation.

allerdings wie es da steht eine "flache Kopie" .. also, wenn du da keine einfachen Datenstrukturen verwendest, kanns sein das die geklonten Daten dennoch selbe membervariablen verwenden .. ne deep-copy müsstest selbst machen

 

[Guest]

Ich habe einen Hashtable in einen Hashtable geschachtelt.

Enumeration e = hash1.keys();
while (e.hasMoreElements){
   String key = e.nextElement();
   Hashtable val = hash1.get(key);
   // HIER IN DER SCHLEIFE
}

Reicht zu einer deep copy dann in der Schleife ein:

hashCopy.put(key,val);

Oder muss ich jetzt den geschachtelten Hash nochmal durchlaufen?

bzw kann ich:

hash2Copy = val.clone();
hashCopy.put(key,hash2Copy);

Im zweiten Hash sind Key und Val ein String.

 

[andre111]

Benutz halt einfach den copy-Konstruktor:

Hashtable h1 = new Hashtable();
h1.put("key1","key2");
Hashtable h2 = new Hashtable(h1);

 

[diggaa1984]

Benutz halt einfach den copy-Konstruktor:

Hashtable h1 = new Hashtable(); 
h1.put("key1","key2"); 
Hashtable h2 = new Hashtable(h1);

da würde ich aber mal behaupten das da definitiv die selben Objekte drin liegen und nicht wie der ThreadOpener fordert die Gleichen

was die Frage vom TO angeht:

du hast also:

Hashtable<String,Hashtable<String,String>> !?

da würde ich sagen, das du auch den inneren Hashtable clonen musst, da du sonst diesen bearbeiten würdest.
Im äußeren clone() kopierst alle keys und values in einen neuen Hashtable rein. Bei Strings ist das im Prinzip egal, aber der innere Hashtable würde so übernommen werden, und du hättest Änderungen im Klon wie im Original. Folglich müsstest den inneren Hash nochmal clonen, was dieser Doku-Comment bestätigen würde.

Creates a shallow copy of this hashtable. All the structure of the hashtable itself is copied, but the keys and values are not cloned.

Man korrigiere mich, wenn ich das falsch interpretiere

 

[byte]

da würde ich aber mal behaupten das da definitiv die selben Objekte drin liegen und nicht wie der ThreadOpener fordert die Gleichen

Die selben Objekte sind auch immer die gleichen! :roll:

Wenn eh nur Strings in der Map liegen, ist es aber wurscht, ob man eine Deep oder Shallow Copy macht, da Strings sowieso immutable sind.

 

[diggaa1984]

Wenn eh nur Strings in der Map liegen, ist es aber wurscht, ob man eine Deep oder Shallow Copy macht, da Strings sowieso immutable sind.

aber es ist doch ein unterschied ob ich mit outerHashCopy.val auf die selbe Hashtable referenziere oder auf eine echte Kopie davon, oder nicht!? Mit nem normalen clone() kann ich in der outerHashCopy Änderungen an der inneren Hashtable (outerHashCopy.val) vornehmen, welche sich dann ebenfalls auf die originale innere Hashtable auswirkt, da ja die Referenzen der inneren Hashtable ein und das selbe Objekt liefern.

hashtableOrg = <String,Hashtable<String,String>>
hashtableCopy = hashtableOrg.clone()

wären nun hashtableOrg.val und hashtableCopy.val nicht Referenzen auf ein und die selbe innere Hashtable, sodass Änderungen im Klon auch Änderungen im Original bewirken würden!? Ob Strings nun immutable sind oder nicht dürfte ja nix daran ändern.

Nur wenn man die innere Hashtable noch clonen würde, hätten Änderungen in hashtableCopy keine Auswirkungen mehr auf hashtableOrg.

so, hab dann doch mal n kleines testtool geschrieben:

import java.util.*;

public class Test {
	
	public static void main(String[] args) {
		//innere Hashtable (wird nich mit geklont)
		Hashtable<String,String> innerHashtable = new Hashtable<String,String>();
		innerHashtable.put("innerFirstKey","innerOrgVal");
		
		//Original-Hashtable
		Hashtable<String,Hashtable<String,String>> hOrg = new Hashtable<String, Hashtable<String,String>>();
		hOrg.put("outerFirstKey",innerHashtable);
		
		//Ausgabe des inneren Hashtables des Originals
		System.out.println(hOrg.get("outerFirstKey").get("innerFirstKey"));	
		
		//Erstellung des Klons durch #clone() (shallow copy)
		Hashtable<String,Hashtable<String,String>> hCopy = (Hashtable<String,Hashtable<String,String>>) hOrg.clone();
		//Änderngen am inneren Hashtable des Klons
		hCopy.get("outerFirstKey").put("innerFirstKey","innerCopyVal");

		//Ausgabe des inneren Hashtables des Originals nach Änderungen im Klon		
		System.out.println(hOrg.get("outerFirstKey").get("innerFirstKey"));	
	}
}

Ausgabe:
innerOrgVal
innerCopyVal