Erste Schritte Vergleich der String-Objekte

[jackochan]

public class Testclass {
	
  public static void main ( String[] args ) {
    String ersteswort; 
    ersteswort= new String();
    ersteswort = "Hallo";
    String zweiteswort; 
    zweiteswort = new String();
    zweiteswort = "Hallo"; 			  
			  			  	  
    if (ersteswort == zweiteswort){
      System.out.println("Wir haben die gleichen Referenzen");
				  			  }
    else{
      System.out.println("Wir haben unterschiedliche Referenzen");
    }
			  
    if ( ersteswort.equals(zweiteswort)){
      System.out.println("Unsere String-Objekt-Inhalte sind gleich");
    }
    else{
      System.out.println("Unsere String-Objekt-Inhalte sind nicht gleich");
    }
  }
}

Ich dachte, für "ersteswort" und "zweiteswort" werden zwei unterschiedliche Objekte auf dem Heap erzeugt (mit gleichem Inhalt).
Demzufolge hätte der Vergleich "ersteswort == Zweiteswort" -> "false" liefern müssen, da sie auf unterschiedliche Objekte referenzieren.
Leider bekomme ich folgende Antwort... why?

Wir haben die gleichen Referenzen
Unsere String-Objekt-Inhalte sind gleich

 

[Gast2]

Nein, das ist nicht ganz richtig.
Es gibt intern noch einen Stringpool. Für den String "Hallo" wird ein String erzeugt der im Stringpool liegt, deine beiden Referenzen ersteswort und zweiteswort zeigen damit auf den selben String.

			  ersteswort= new String();
			  ersteswort = "Hallo";

Das ist übrigens sinnlos, die Zuweisung

new String();

hat kein Gewicht, weil sie direkt wieder überschrieben wird. Oder meinst du sowas :

erstesWort = new String("Hallo");
zweiteswort = new String("Hallo");

Dann hast du tatsächlich errreicht dass

erstesWort == zweitesWort

false ergibt.

 

[HimBromBeere]

Nur mal so nebenbei, wie sieht es denn dann hiermit aus (hab grade nichts zum Testen da, sonst hätt ich das fix erledigt):

String str1 = "Hallo";
String str2 = "Hallo";
sysout(str1 == str2);

 

[Gast2]

Das ist doch der selben Code den jackochan probiert hat?! Ergebnis ist true, daran ändert sich nichts.

 

[jackochan]

Acsho, das mit dem Stringpool wusste ich nicht.
Dachte Strings werden genau so behandelt wie "Objekte" bzw. sind Objekte der Klasse "String".
Wollte mit dem Ausdruck:

  String ersteswort; 
  ersteswort= new String();
  ersteswort = "Hallo";

explizit darauf hinweisen, dass Strings genau wie Objekte erzeugt werden und dass das gleiche ist wie

String ersteswort = "Hallo"

Aber anscheinend stimmt das ja nicht. Und das Ergebnis vom Referenzvergleich liefert auch was anders.
Deine Antwor mit "Stringpool" stellt meine ganzen String-Vorstellungen auf dem Kopf.

Das ist übrigens sinnlos, die Zuweisung new String(); hat kein Gewicht, weil sie direkt wieder überschrieben wird. Oder meinst du sowas :

Kannst du mir vllt. erklären was ich hier überschrieben habe??

 String ersteswort;             // deklareation der Variablennamn für Stringtypen
 ersteswort= new String();  // Es wird ein String Objekt erzeugt und der Variable ersteswort zugewiesen
 ersteswort = "Hallo";         // Inhalt des referenzienten Objekts mit "Hallo" füllen

 

[Gast2]

Kannst du mir vllt. erklären was ich hier überschrieben habe??

folgendes wäre das gleich:

int i;
i = 3;
i = 4;
i = 5;
i = 6;

am Ende ist i immer 6, die vorherigen Zuweisungen sind irrelevant. Das selbe machst du mit deinen Strings.

Dachte Strings werden genau so behandelt wie "Objekte" bzw. sind Objekte der Klasse "String".

Ja, ist richtig. Nur dass eben noch ein Pool von Strings verwaltet wird. Stell dir vor du hast in deinem Quellcode sehr viele "" oder " " stehen. Da wärs ja quatsch für jeden solchen String ne eigene Instanz zu haben. Das wird dann durch den String pool optimiert.
Ne weitere Besonderheit ist, dass du Strings nicht explizit per new erzeugen musst:

String s = "Test";

 

[xehpuk]

 String ersteswort;             // deklareation der Variablennamn für Stringtypen
 ersteswort= new String();  // Es wird ein String Objekt erzeugt und der Variable ersteswort zugewiesen
 ersteswort = "Hallo";         // Inhalt des referenzienten Objekts mit "Hallo" füllen

Die letzte Zeile stimmt nicht. Mit einer Zuweisung rührst du das Objekt, das hinter der Variable steckt, nicht an. Stattdessen wird die Referenz auf das neu zugewiesene Objekt umgeleitet. Das alte Objekt wird nun einfach nicht mehr von dieser Variable referenziert.

 

[jackochan]

Ja, das stimmt....wär echt nicht logisch für jeden String ein Objekt zu erzeugen.

Die letzte Zeile stimmt nicht. Mit einer Zuweisung rührst du das Objekt, das hinter der Variable steckt, nicht an. Stattdessen wird die Referenz auf das neu zugewiesene Objekt umgeleitet. Das alte Objekt wird nun einfach nicht mehr von dieser Variable referenziert

Verstehe...! Das alte Stringobjekt , das ich mit

new String ()

erzeugt habe wird mit der neuen Zuweisung

ersteswort = "Hallo"

futter für Garbage Collector.
Okay, muss die Strings noh genauer unter die Lupe nehmen...Danke

 

[Gast2]

Verstehe...! Das alte Stringobjekt , das ich mit new String () erzeugt habe wird mit der neuen Zuweisung ersteswort = "Hallo" futter für Garbage Collector.

Ganz genau.

 

[bygones]

als Zusatzinfos:

zb bei Integer und Boolean ist es aehnlich. Letzteres sollte man immer per

Boolean.TRUE

bzw

Boolean.FALSE

nutzen, nicht

new Boolean

- da gepoolt.
Bei Integer sollte man auch

Integer.valueOf(x)

und nicht

new Integer(x)

nehmen, da (manche) Zahlen gepoolt werden.

 

[jackochan]

Okay.. also Strings werden im "Stringpool" gespeichert, wenn sie mit dem Befehl

String wort = "Hallo";

erzeugt werden.

Werden sie dagegen mit dem Befehl

 String wort = new String("Hallo");

erzeugt , werden tatsächlich neue Objekte für jeden so erzeugten String auf dem (Garbage Collector) Heap erstellt.

Diese Befehle sind unterschiedlich. Ich dachte immer, dass der Letzterer einfach eine Kurzschreibweise des ersten Befehls sei. Aber so ist es nicht!!

String ersteswort = new String("Hallo");
String zweiteswort = new String("Hallo");
boolean test = (ersteswort == zweiteswort)   // Ergebnis: FALSE

String ersteswort = "Hallo";
String zweiteswort = "Hallo";
boolean test = (ersteswort == zweiteswort)   // Ergebnis: TRUE

Hier ist das gut erklärt
Der Stringpool - Java als erste Programmiersprache - Javaschublade

 

[musiKk]

Wenn wir schon beim Thema Lernen sind:

Man kann auch bei dynamischen Strings erzwingen, dass sie in den Pool wandern (bzw. aus diesem genommen werden, falls schon existent). Das geht per [c]String#intern()[/c]:

public class Test {

    public static void main(String[] args) throws Exception {

        System.err.println((new Ha() + "llo") == "Hallo");
        System.err.println((new Ha() + "llo").intern() == "Hallo");

    }

    static class Ha {
        @Override
        public String toString() {
            return "Ha";
        }
    }

}

gibt

false
true

(Den Umweg mit der extra Klasse bin ich gegangen, weil der Compiler das sonst schon optimiert und der Effekt nicht erkennbar ist.)

 

[Andreas29]

Hi,

ich denke das es wichtig ist zu erwähnen das Strings immutable sind. Also unveränderlich. Dies bedeutet, dass jede Operation, die einen String verändert, einen neuen String liefert. Nur dadurch ist es möglich die Strings zu poolen. Ansonsten würde es zu unabsehrbaren Nebenwirkungen kommen, wenn sich im programmteil eins ein Steingut ändert u dies auf mal Auswirkungen auf ganz andere Programmteile hat.

Grüße,
Andreas

 

[California]

Was alle hier vergessen haben:

Strings können nur mit .equals verglichen werden!

also auf Gleichheit:

 if (text1.equals( text2 )) {...

oder Ungleich:

 if (!text1.equals( text2 )) {...

== vergleicht die Adressen der Strings und würde damit sagen, dass text1 identisch (heisst an derselben Speicheradresse stehend) mit text2 ist, und das ist in der Praxis leider meistens wertlos :-D

Falls Du wissen willst, ob ein String grösser / kleiner / auch gleich einem anderen ist, musst du compareTo nehmen:

 if (text1.compareTo( text2 ) > 0) { // text2 ist grösser als text1 ...

..äähm, korrekt heisst es "kommt bei Vergleich der Unicodes lexikographisch nach text1" statt "grösser als"...

 

[HimBromBeere]

Was alle hier vergessen haben:

Strings können nur mit .equals verglichen werden!

Einfach mal richtig lesen, California, der erste Beitrag von EikeB sagt dir, warum.

Im Zweifelsfall probier das Folgende aus:

String s1 = "Hallo";
String s2 = "Hallo";
System.out.println(s1 == s2);

War für mich aber auch neu...
Was lernen wir daraus? Immer alle Beiträge durchlesen

 

[California]

Genau das habe ich geschrieben. Deine beiden Hallos sind IDENTISCH, weil der Compiler die Konstante nur einmal ablegt.
Deshalb haben sie auch die gleiche Adresse. Wenn der Compiler die Konstanten anders implementiert, zum Beispiel nicht platzoptimiert, ist es mit dem == wieder Essig.

Stringvergleiche mit == sind und bleiben Quatsch.

Und die Ausnutzung eines systeminternen (damit von der JVM - Implementierung abhängigen) Mechanismus in realen Programmen ist höchst fragwürdig.

 

[bygones]

wo er aber dennoch recht hat ist, dass man sich nicht auf den StringPool verlassen sollte und denken "naja, dann kann ich ja Strings per == vergleichen". Strings sind Objekte und daher sollte man auf Gleichheit NUR mit equals vergleichen. Wenn man auf Identitaet vergleichen will, dann kann man == nehmen.

Also - immer mit equals nehmen und den Stringpool zwar wissen, aber nicht sich darauf verlassen.

 

[California]

wo er aber dennoch recht hat ist, dass man sich nicht auf den StringPool verlassen sollte und denken "naja, dann kann ich ja Strings per == vergleichen". Strings sind Objekte und daher sollte man auf Gleichheit NUR mit equals vergleichen. Wenn man auf Identitaet vergleichen will, dann kann man == nehmen.

Also - immer mit equals nehmen und den Stringpool zwar wissen, aber nicht sich darauf verlassen.

Genau. Bitte auch daran denken, dass wir im Anfängerforum sind. Der ganze Thread gehört eher unter "Java- Philosphie für Fortgeschrittene...". Irgendeiner nimmt das wörtlich.