Speicherverwaltung bei Strings

[wertixx]

Hallo,


ich hab da ein paar Fragen zur Speicherverwaltung in Java. Im Prinzip geht es mir darum, wie String im Heap gehandhabt werden,
wenn ihr Wert geändert wird, sowie um allgemeine Parameterübergabe. Gegeben sei die folgende Klasse:

public class Test {

	public static String a="A";
	public static String b="B";

	public static void vertauschen (String eins, String zwei) {
		String temp = eins; 
		eins = zwei; 
		zwei = temp;
	}

	public static void main (String args[]) {
		
		
		vertauschen(a,b);
		System.out.println("String a="+a);
		System.out.println("String b="+b);
	}
}

In der Methode vertauschen sollen die Werte der Strings 'eins' und 'zwei' vertauscht werden. Die klassenweiten Strings 'a' und 'b' befinden sich im Constant Pool.
Die Frames der Methoden vertauschen und main enthalten daher einen Verweis auf den Constant Pool. Daher schaut die Speicherverwaltung VOR dem Anwenden
der Methode vertauschen so aus:

Constant Pool:
b = <adr2>
a = <adr1>

*main Frame:
args = <adr3>

Heap:
<adr1>: "A" <adr2>: "B <adr3>: {}

Hab ich das soweit schon einmal richtig verstanden?

So, nun wird die Methode vertauschen ausgeführt. Java übergibt ja eigentlich per Call by Value, aber bei Klassen tritt ja für gewöhnlich ein
Call by Reference Effekt auf, da nur die Speicheradresse der Klasse in die Methode kopiert wird, nicht der Wert selbst. Vor Beginng der Neuzuweisungen
schaut die Speicherverwaltung daher so aus:

Constant Pool:
b = <adr2>
a = <adr1>

*vertauschen Frame
temp = <adr4> // oder wird Temp gleich <adr1> zugeordnet?
zwei = <adr2>
eins = <adr1>

*main Frame:
args = <adr3>

Heap:
<adr1>: "A"
<adr2>: "B
<adr3>: {}
<adr4>: <adr1>


Nun sind aber Strings im Allgemeinen unveränderbar. Deshalb funktioniert die Methode vertauschen NICHT.

Das lokale String 'eins' enthält eine Referenz auf das Klassenstring (nenn man da so?) a.

Wird nun 'eins' ein neuer Wert zugewisen (a = zwei, dann wird dem String 'eins' eine neue Adresse im Heap zugeordnet. Für 'zwei' gilt das gleiche.

Constant Pool:
b = <adr2>
a = <adr1>

*vertauschen Frame
temp = <adr4> // oder wird Temp gleich <adr1> zugeordnet?
zwei = <adr6>
eins = <adr5>

*main Frame:
args = <adr3>

Heap:
<adr1>: "A"
<adr2>: "B
<adr3>: {}
<adr4>: <adr1>
<adr5>: <adr2> // oder gleich "B" ?
<adr6>: <adr1> // oder gelich "A" ?


Und da die lokalen String eins und zwei nicht in im main-Frame sichtbar sind, funktioniert die Methode nicht.

Mir geht's nur darum, ob ich das richtig verstanden habe - was ich nämlich nicht glaube :noe: Wahrscheinlich blickt eh keiner durch bei dem was ich da zusammengefaselt habe, aber es wär zumindest nett, wenn mir jemand dann mit eigenen Worten erklärt, warum die Methode vertauschen nicht funktioniert.

Vielen Dank!

Gruß,
wertixx

 

[fastjack]

Es gibt eigentlich nur zwei Regeln :

1. Stringliterale kommen in den ConstantPool.

String s = "lala";

2. Strings aus String-Objekten kommen auf den Heap und in den ConstantPool.

String s = new String("lala");

 

[ModellbahnerTT]

Das was du da zusammengefaselt hast hättst du dir auch sparen können, in Java gibt es nur Call by Value darum funktioniert dein Code nicht.
Strings liegen zur Laufzeit natürlich wie alle anderen Objekte auf dem Heap.

 

[wertixx]

Ja, das ist schon klar, aber gibt es bei Klassen für gewöhnlich doch einen Call-by-Reference EFFEKT, da eben nicht der ganze Wert, sondern nur die Referenz, also die Speicheradresse, kopiert wird.

Hätte ich jetzt ein Array als Parameter übertragen würde das wunderbar klappen, meine Frage ist, warum dass nicht bei Strings funktioniert!

 

[fastjack]

Das ist richtig.

Strings liegen zur Laufzeit natürlich wie alle anderen Objekte auf dem Heap.

Trotzdem bitte nicht den ConstantPool unterschlagen.

check this : JavaRanch Journal - September 2004 Volume 3 Issue 7 :rtfm:

 

[faetzminator]

Weil Strings immutable objects sind. immutable : Java Glossary

 

[ModellbahnerTT]

Das ist richtig.
Trotzdem bitte nicht den ConstantPool unterschlagen.

check this : JavaRanch Journal - September 2004 Volume 3 Issue 7 :rtfm:

Der Constant Pool ist eine Einheit in class Dateien und hat zur Laufzeit keine Bedeutung. Wenn du Strings noch weiter einordnen willst kannst du sagen sie liegen im Perm Space im Heap, hat für das Problem aber genausowenig relevanz.

Weil Strings immutable objects sind. immutable : Java Glossary

Ist zwar richtig aber als Antwort für die Frage blödsinnig, schließlich hab ich das selbe Problem mit einer normalen nicht immutable Klasse.

Ja, das ist schon klar, aber gibt es bei Klassen für gewöhnlich doch einen Call-by-Reference EFFEKT, da eben nicht der ganze Wert, sondern nur die Referenz, also die Speicheradresse, kopiert wird.

Hätte ich jetzt ein Array als Parameter übertragen würde das wunderbar klappen, meine Frage ist, warum dass nicht bei Strings funktioniert!

Der "Effekt" ist, dass du innerhalb der Methode mit dem gleichen Objekt wie der Aufrufer arbeitet, das heißt noch nicht, dass das irgendwen interessiert wenn du die Referenz in der Methode versuchst umzubiegen.
Mit Arrays hättest du übrigens genau das gleiche Problem.
public static void vertauschen (Object[] eins, Object[] zwei) {
Object[] temp = eins;
eins = zwei;
zwei = temp;
}
Ist aber schon klar was du meinst...

 

[faetzminator]

Nunja, davon ausgegangen, dass man einen Container um ein Immutable oder eine sonstige Klasse mit Werten hat, kann man das folgendermassen lösen (darum ist meine Antwort nicht grundlegend falsch):

public class Foo<T> {

    private T data;

    public Foo(T data) {
        this.setData(data);
    }

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }
    
    @Override
    public String toString() {
        return data == null ? "null" : data.toString();
    }

    public static <T> void switchObj(Foo<T> a, Foo<T> b) {
        T data = a.getData();
        a.setData(b.getData());
        b.setData(data);
    }

    public static void main(String[] args) {
        Foo<String> a = new Foo<String>("A");
        Foo<String> b = new Foo<String>("B");
        Foo.switchObj(a, b);
        System.out.println("Foo a=" + a);
        System.out.println("Foo b=" + b);
    }
}

 

[fastjack]

@ModellbahnerTT Hast recht, Content Table meinte ich, copy&paste

 

[wertixx]

Mit Arrays hab ich nicht das gleiche Problem...

public class Test2 {

	public static String a="A";
	public static String b="B";
	public static String[] neu = {a,b};

	public static void vertauschen (String[] s) {
		String temp=s[0];
		s[0]=s[1];
		s[1]=temp;
	}

	public static void main (String args[]) {
		vertauschen(neu); 
		System.out.println("String a="+neu[0]);
		System.out.println("String b="+neu[1]);

	}
}

Hier wird aber definitiv:

String a = B
String b = A

ausgegeben!

 

[faetzminator]

ja, das Array ist ja immer noch das gleiche, du referenzierst es nicht neu. Gleich wie in meinem Beispiel hast du da eine Referenz, welche übergeben wird, welche sich nicht ändert. Lediglich inhaltlich ändern sich die Objekte - dieser wird vertauscht.