String-Initialisierung in Java

1. Einleitung

Java String ist eine der wichtigsten Klassen, und wir haben bereits viele Aspekte in unserer String- bezogenen Reihe von Tutorials behandelt.

In diesem Tutorial konzentrieren wir uns auf die String- Initialisierung in Java.

2. Schöpfung

Zunächst sollten wir uns daran erinnern, wie Strings in Java erstellt werden.

Wir können das neue Schlüsselwort oder die Literal-Syntax verwenden:

String usingNew = new String("baeldung"); String usingLiteral = "baeldung";

Außerdem ist es wichtig, dass wir verstehen, wie Strings in einem speziellen Pool verwaltet werden.

3. Nur String- Deklaration

Lassen Sie uns zunächst nur einen String deklarieren , ohne explizit einen Wert zuzuweisen.

Wir können dies entweder lokal oder als Mitgliedsvariable tun:

public class StringInitialization { String fieldString; void printDeclaredOnlyString() { String localVarString; // System.out.println(localVarString); -> compilation error System.out.println(fieldString); } }

Wie wir sehen können , erhalten wir einen Kompilierungsfehler , wenn wir versuchen, localVarString zu verwenden, bevor wir ihm einen Wert geben. Auf der anderen Seite zeigt die Konsole " null" für den Wert von fieldString an .

Siehe, Mitgliedsvariablen werden beim Erstellen der Klasse mit einem Standardwert initialisiert , im Fall von String null . Aber haben wir uns lokale Variablen zu initialisieren.

Wenn wir localVarString den Wert null geben , werden wir sehen, dass die beiden tatsächlich jetzt gleich sind:

String localVarString = null; assertEquals(fieldString, localVarString);

4. String- Initialisierung mit Literalen

Erstellen wir nun zwei Zeichenfolgen mit demselben Literal:

String literalOne = "Baeldung"; String literalTwo = "Baeldung";

Wir werden bestätigen, dass nur ein Objekt erstellt wird, indem wir die Referenzen vergleichen:

assertTrue(literalOne == literalTwo);

Der Grund für diese horcht auf die Tatsache zurück , dass String s in einem Pool gespeichert werden. literalOne fügt den String "baeldung" zum Pool hinzu und literalTwo verwendet ihn erneut.

5. String- Initialisierung mit new

Wir werden jedoch ein anderes Verhalten feststellen, wenn wir das neue Schlüsselwort verwenden.

String newStringOne = new String("Baeldung"); String newStringTwo = new String("Baeldung");

Obwohl der Wert beider Zeichenfolgen derselbe wie zuvor ist, müssen wir diesmal unterschiedliche Objekte verwenden:

assertFalse(newStringOne == newStringTwo);

6. Leere Zeichenfolge s

Erstellen wir nun drei leere Zeichenfolgen :

String emptyLiteral = ""; String emptyNewString = new String(""); String emptyNewStringTwo = new String();

Wie wir inzwischen wissen, wird das emptyLiteral zum String- Pool hinzugefügt , während die anderen beiden direkt auf den Heap gehen.

Obwohl dies nicht dieselben Objekte sind, haben alle denselben Wert:

assertFalse(emptyLiteral == emptyNewString) assertFalse(emptyLiteral == emptyNewStringTwo) assertFalse(emptyNewString == emptyNewStringTwo) assertEquals(emptyLiteral, emptyNewString); assertEquals(emptyNewString, emptyNewStringTwo);

7. Null - Werte

Lassen Sie uns abschließend sehen, wie sich Null- Strings verhalten.

Lassen Sie uns einen Null- String deklarieren und initialisieren :

String nullValue = null;

Wenn wir nullValue drucken , sehen wir das Wort "null", wie wir es zuvor gesehen haben. Und wenn wir versuchen würden, Methoden für nullValue aufzurufen, würden wir erwartungsgemäß eine NullPointerException erhalten .

But, why does “null” is being printed? What is null actually?

Well, the JVM specification says that null is the default value for all references, so it's not specifically tied to the String. And actually, the specification doesn't mandate any concrete value encoding for null.

So, where is “null” coming from for printing a String then?

If we take a look at the PrintStream#println implementation, we'll see it calls String#valueOf:

public void println(Object x) { String s = String.valueOf(x); synchronized (this) { print(s); newLine(); } }

And, if we look at String#valueOf, we get our answer:

public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }

And, obviously, that's the reason for “null”.

8. Conclusion

In diesem Artikel haben wir die String- Initialisierung untersucht. Wir haben den Unterschied zwischen Deklaration und Initialisierung erklärt. Wir haben auch die Verwendung von new und die Verwendung der Literal-Syntax angesprochen .

Schließlich haben wir uns angesehen, was es bedeutet, einem String einen Nullwert zuzuweisen , wie der Nullwert im Speicher dargestellt wird und wie er beim Drucken aussieht.

Alle im Artikel verwendeten Codebeispiele sind auf Github verfügbar.