Unterschied zwischen null und leerem ("") Java-String

Was ist der Unterschied zwischen nullund der ""(leeren Zeichenfolge)?

Ich habe einen einfachen Code geschrieben:

String a = "";
String b = null;

System.out.println(a == b); // false
System.out.println(a.equals(b)); // false

Beide Aussagen kehren zurück false. Es scheint, ich bin nicht in der Lage, den tatsächlichen Unterschied zwischen ihnen zu finden.

"" ist eine tatsächliche Zeichenfolge, wenn auch eine leere.

null bedeutet jedoch, dass die Variable String auf nichts zeigt.

a==b gibt false zurück, weil "" und null nicht denselben Speicherplatz belegen - mit anderen Worten, ihre Variablen zeigen nicht auf dieselben Objekte.

a.equals(b) gibt false zurück, weil "" offensichtlich nicht gleich null ist.

Der Unterschied besteht jedoch darin, dass Sie, da "" eine tatsächliche Zeichenfolge ist, weiterhin Methoden oder Funktionen wie diese aufrufen können

a.length()

a.substring(0, 1)

und so weiter.

Wenn der String gleich Null ist, wie b, würde Java a auslösen, NullPointerExceptionwenn Sie versuchen, aufzurufen, sagen Sie:

b.length()

Wenn der Unterschied, über den Sie sich wundern, == gegen gleich ist, ist dies:

== vergleicht Referenzen, als ob ich gegangen wäre

String a = new String("");
String b = new String("");
System.out.println(a==b);

Das würde false ausgeben, da ich zwei verschiedene Objekte zugewiesen habe und a und b auf verschiedene Objekte zeigen.

In a.equals(b)diesem Fall würde jedoch true zurückgegeben, da equalsfor Strings nur dann true zurückgibt, wenn das Argument String nicht null ist und dieselbe Zeichenfolge darstellt.

Seien Sie jedoch gewarnt, dass Java einen Sonderfall für Strings hat.

String a = "abc";
String b = "abc";
System.out.println(a==b);

Sie würden denken, dass die Ausgabe wäre false, da sie zwei verschiedene Strings zuordnen sollte. Tatsächlich wird Java wörtliche Strings internieren (solche, die in unserem Beispiel wie a und b initialisiert sind). Seien Sie also vorsichtig, denn dies kann zu Fehlalarmen bei der Funktionsweise von == führen.

Sie können den Unterschied zwischen null und einer leeren Zeichenfolge auch folgendermaßen verstehen:

Originalbild von R. Sato ( @raysato )

String ist ein Objekt und kann null sein

null bedeutet, dass das String-Objekt nicht instanziiert wurde

"" ist ein tatsächlicher Wert der instanziierten Objektzeichenfolge wie "aaa"

Hier ist ein Link, der diesen Punkt verdeutlichen könnte: http://download.oracle.com/javase/tutorial/java/concepts/object.html

Was Ihre Aussagen Ihnen sagen, ist nur, dass "" nicht dasselbe ist wie null - was wahr ist. "" ist eine leere Zeichenfolge; null bedeutet, dass kein Wert zugewiesen wurde.

Es könnte aufschlussreicher sein, zu versuchen:

System.out.println(a.length()); // 0
System.out.println(b.length()); // error; b is not an object

"" ist immer noch eine Zeichenfolge, dh Sie können ihre Methoden aufrufen und aussagekräftige Informationen erhalten. null ist eine leere Variable - da ist buchstäblich nichts.

Es gibt einen ziemlich signifikanten Unterschied zwischen den beiden. Die leere Zeichenfolge ""ist "die Zeichenfolge, die keine Zeichen enthält". Es ist eine tatsächliche Zeichenfolge mit einer genau definierten Länge. Alle Standard-Zeichenfolgenoperationen sind für die leere Zeichenfolge genau definiert. Sie können sie in Kleinbuchstaben konvertieren, den Index eines Zeichens darin nachschlagen usw. Die Nullzeichenfolge nulllautet "überhaupt keine Zeichenfolge". Es hat keine Länge, weil es überhaupt keine Zeichenfolge ist. Der Versuch, eine Standardzeichenfolgenoperation auf die Nullzeichenfolge anzuwenden, führt NullPointerExceptionzur Laufzeit zu einer.

hierher a is an Objectaber b(null)ist nicht ein Objekt ist ein NULL - Verweis

System.out.println(a instanceof Object); // true

System.out.println(b instanceof Object); // false

Hier ist meine ähnliche Antwort

null bedeutet, dass der Name kein instanziiertes Objekt referenziert. "" bedeutet eine leere Zeichenfolge.

Hier ein verweist einiges Objekt , das eine leere Zeichenfolge sein geschieht. b verweist nicht auf ein Objekt, da es null ist.

In Java hat ein zugewiesener Referenztyp nullüberhaupt keinen Wert . Eine zugewiesene Zeichenfolge ""hat einen Wert: eine leere Zeichenfolge, dh eine Zeichenfolge ohne Zeichen. Wenn eine Variable zugewiesen wird null, bedeutet dies, dass kein zugrunde liegendes Objekt jeglicher Art, Zeichenfolge oder auf andere Weise vorhanden ist.

"" und null sind beide unterschiedlich. Die erste bedeutet, dass im Rahmen der Deklaration von Zeichenfolgenvariablen die Zeichenfolgenkonstante im Zeichenfolgenpool erstellt und ein Speicher für dieselbe zugewiesen wurde.

Aber wenn wir es mit null deklarieren, wurde es gerade jvm instanziiert, aber es wurde kein Speicher dafür zugewiesen. Wenn Sie versuchen, auf dieses Objekt zuzugreifen, indem Sie es mit der leeren Variablen "" - überprüfen , kann dies keine Nullpointerexception verhindern. Nachfolgend finden Sie einen Anwendungsfall.

public class StringCheck {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    String s1 = "siddhartha";
    String s2 = "";
    String s3 = null;

    System.out.println("length s1 ="+s1.length());
    System.out.println("length s2 ="+s2.length());

    //this piece of code will still throw nullpointerexception . 
    if(s3 != ""){
        System.out.println("length s3 ="+s3.length());
    }
}

}}

String s = "";
s.length();

String s = null;
s.length();

Ein Verweis auf eine leere Zeichenfolge ""verweist auf ein Objekt im Heap, sodass Sie Methoden dafür aufrufen können.

Eine Referenz, auf die verweist, nullhat jedoch kein Objekt, auf das im Heap verwiesen werden kann, und daher erhalten Sie eine NullPointerException.

Die leere Zeichenfolge unterscheidet sich von einer Nullreferenz dadurch, dass in einer objektorientierten Programmiersprache eine Nullreferenz auf einen Zeichenfolgentyp nicht auf ein Zeichenfolgenobjekt verweist und einen Fehler verursacht, wenn versucht wird, eine Operation daran auszuführen. Die leere Zeichenfolge ist immer noch eine Zeichenfolge, mit der Zeichenfolgenoperationen versucht werden können.

Aus dem Wikipedia-Artikel über leere Zeichenfolge .

String s=null;

String wird nicht für null initialisiert. Wenn eine Zeichenfolgenoperation versucht wird, kann eine Nullzeigerausnahme ausgelöst werden

String t="null";

Es ist ein String-Literal mit dem Wert string "null" wie t = "xyz". Es wird kein Nullzeiger geworfen.

String u="";

Es ist eine leere Zeichenfolge. Es wird kein Nullzeiger ausgegeben.

Eine Zeichenfolge kann leer sein oder einen nullWert haben. Wenn es sich um eine Zeichenfolge handelt null, bezieht sie sich nicht auf etwas im Speicher. Versuchen Sie es s.length()>0. Dies liegt daran, dass eine leere Zeichenfolge immer noch eine Länge von 0 zurückgibt. Wenn Sie also nichts für dieselbe Zeichenfolge eingeben, wird die Schleife fortgesetzt, da die Zeichenfolge nicht als registriert wird null. Wenn Sie dagegen nach der Länge suchen, wird die Schleife verlassen.

Dieses Konzept kann aus der Mathematik besser verstanden werden. Haben Sie jemals versucht, eine Zahl (nicht Null) mit einem Taschenrechner, z. B. 7/0, durch 0 zu teilen? Sie erhalten ein Ergebnis erhalten , das aussieht wie etwas , das: undefined, not a number, nullusw. Dies bedeutet , dass die Operation nicht möglich ist, aus irgendwelchen Gründen (lassen Sie sich diese Gründe lassen an einem anderen Tag diskutiert werden).

Führen Sie nun Folgendes aus: 0/7. Sie erhalten die Ausgabe 0. Dies bedeutet, dass die Operation möglich ist und ausgeführt werden kann, aber Sie haben nur die Antwort 0, da nach der Division nichts mehr übrig ist. Es gibt eine gültige Ausgabe und diese Ausgabe ist Null.

Im ersten Beispiel war nicht nur die Ausgabe ungültig, die Operation konnte auch nicht ausgeführt werden. Dies ist vergleichbar mit einem nullString in Java. Das zweite Beispiel ähnelt einem emptyString.

Wenn du schreibst

String a = "";

Dies bedeutet, dass es eine Variable 'a' vom Typ string gibt, die auf eine Objektreferenz im Zeichenfolgenpool verweist, die den Wert "" hat. Da die Variable aeine gültige Zeichenfolgenobjektreferenz enthält, können hier alle Zeichenfolgenmethoden angewendet werden.

Während beim Schreiben

String b = null;

Dies bedeutet, dass es eine Variable bvom Typ string gibt, die auf eine unbekannte Referenz verweist . Und jede Operation mit unbekannter Referenz führt zu einem NullPointerException.

Lassen Sie uns nun die folgenden Ausdrücke bewerten.

System.out.println(a == b); // false. because a and b both points to different object reference

System.out.println(a.equals(b)); // false, because the values at object reference pointed by a and b do not match.

System.out.println(b.equals(a)); // NullPointerException, because b is pointing to unknown reference and no operation is allowed

In einfachen Worten,

• "" ist eine leere Zeichenfolge

• null ist eine leere Stringvariable .

Unterschied zwischen null und leerer Zeichenfolge. Zum Beispiel: Sie haben eine Variable namens x. Wenn Sie in JS schreiben,

var x = "";

Dies bedeutet, dass Sie einen Wert zugewiesen haben, der eine leere Zeichenfolge ist (Länge ist 0). Eigentlich ist das wie etwas, aber das ist ein Gefühl von nichts :) Auf der anderen Seite,

var y = null;

Dies bedeutet, dass Sie y keinen Wert zugewiesen haben, der eindeutig angegeben ist, indem Sie zum Zeitpunkt der Deklaration null an y geschrieben haben. Wenn Sie y.length schreiben; Es wird ein Fehler ausgegeben, der angibt, dass y kein Wert zugewiesen wurde und daher die Länge von y nicht gelesen werden kann.

Dieses Bild kann Ihnen helfen, die Unterschiede zu verstehen.

Das Bild wurde von ProgrammerHumor gesammelt

"Ich nenne es meinen Milliarden-Dollar-Fehler. Es war die Erfindung der Nullreferenz im Jahr 1965" - https://en.wikipedia.org/wiki/Tony_Hoare

In Bezug auf die reale Welt können beide gleich angenommen werden. Es ist nur eine Syntax einer Programmiersprache, die einen Unterschied zwischen zwei erzeugt, wie von anderen hier erklärt. Dies erzeugt einfach Overhead, wie beim Überprüfen / Vergleichen, ob eine Zeichenfolgenvariable etwas enthält. Sie müssen zuerst prüfen, ob sie nicht null ist, und dann den tatsächlichen Zeichenfolgenvergleich, dh zwei Vergleiche. Dies ist eine Verschwendung von Rechenleistung für jeden Zeichenfolgenvergleich.

Objects.equals () sucht vor dem Aufruf von .equals () nach null.

als eine neugier

    String s1 = null;
    String s2 = "hello";

     s1 = s1 + s2;
   

    System.out.println((s); // nullhello