Differenza tra stringa Java null e empty ("")
Qual è la differenza tra null e "" (stringa vuota)?
Ho scritto un codice semplice:
String a = "";
String b = null;
System.out.println(a==b); // false
System.out.println(a.equals(b)); // false
Entrambe le istruzioni restituiscono false. Sembra, non sono in grado di trovare qual è la vera differenza tra loro.
13 answers
"" è una stringa reale, anche se vuota.
Null, tuttavia, significa che la variabile Stringa non punta a nulla.
a==b restituisce false perché "" e null non occupano lo stesso spazio in memoria-in altre parole, le loro variabili non puntano agli stessi oggetti.
a.equals(b) restituisce false perché "" non è uguale a null, ovviamente.
La differenza è però che dal momento che "" è una stringa reale, è ancora possibile invocare metodi o funzioni su di esso come
a.length()
a.substring(0, 1)
E così via.
Se la stringa è uguale a null, come b, Java genererebbe un NullPointerException se hai provato a richiamare, diciamo:
b.length()
Se la differenza che ti stai chiedendo è = = rispetto a uguale, è questa:
== confronta i riferimenti, come se andassi
String a = new String("");
String b = new String("");
System.out.println(a==b);
Ciò produrrebbe false perché ho allocato due oggetti diversi e a e b puntano a oggetti diversi.
Tuttavia, a.equals(b) in questo case restituirebbe true, perché equals per le stringhe restituirà true se e solo se la stringa dell'argomento non è null e rappresenta la stessa sequenza di caratteri.
Attenzione, però, che Java ha un caso speciale per le stringhe.
String a = "abc";
String b = "abc";
System.out.println(a==b);
Si potrebbe pensare che l'output sarebbe false, dal momento che dovrebbe allocare due stringhe diverse. In realtà, Java intern stringhe letterali (quelle che sono inizializzate come a e b nel nostro esempio). Quindi stai attento, perché questo può dare alcuni falsi positivi su come funziona==.
Puoi anche capire la differenza tra stringa nulla e vuota in questo modo:
String è un Oggetto e può essere null
Null indica che l'Oggetto String non è stato istanziato
""è un valore effettivo della stringa Oggetto istanziato come" aaa "
Ecco un link che potrebbe chiarire quel punto http://download.oracle.com/javase/tutorial/java/concepts/object.html
Ciò che le tue affermazioni ti stanno dicendo è solo che "" non è lo stesso di null - che è vero. ""è una stringa vuota; null significa che non è stato assegnato alcun valore.
Potrebbe essere più illuminante provare:
System.out.println(a.length()); // 0
System.out.println(b.length()); // error; b is not an object
"" è ancora una stringa, il che significa che puoi chiamare i suoi metodi e ottenere informazioni significative. null è una variabile vuota-non c'è letteralmente nulla lì.
C'è una differenza piuttosto significativa tra i due. La stringa vuota "" è "la stringa che non contiene caratteri."È una stringa reale che ha una lunghezza ben definita. Tutte le operazioni di stringa standard sono ben definite sulla stringa vuota: puoi convertirla in minuscolo, cercare l'indice di alcuni caratteri in esso contenuti, ecc. La stringa null null è "nessuna stringa."Non ha una lunghezza perché non è affatto una corda. Cercando di applicare qualsiasi stringa standard l'operazione alla stringa null causerà un NullPointerException in fase di runtime.
Qui a is an Object ma b(null) è non un Oggetto è un riferimento nullo
System.out.println(a instanceof Object); // true
System.out.println(b instanceof Object); // false
Null significa che il nome non fa riferimento a nessun oggetto istanziato. "" significa una stringa vuota.
Qui un fa riferimento ad un oggetto che sembra essere una stringa vuota. b non fa riferimento a nessun oggetto come null.
In Java un tipo di riferimento assegnato nullha nessun valore. Una stringa assegnata "" ha un valore: una stringa vuota, vale a dire una stringa senza caratteri. Quando a una variabile viene assegnato null significa che non vi è alcun oggetto sottostante di alcun tipo, stringa o altro.
"" e null entrambi sono diversi . il primo significa che come parte della dichiarazione della variabile stringa la costante di stringa è stata creata nel pool di stringhe e una certa memoria è stata assegnata per lo stesso.
Ma quando lo stiamo dichiarando con null allora è stata appena istanziata jvm , ma nessuna memoria è stata allocata per esso. pertanto se si sta tentando di accedere a questo oggetto controllandolo con "" - variabile vuota, non può impedire nullpointerexception . Si prega di trovare sotto un caso d'uso.
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();
Un riferimento a una stringa vuota "" punta a un oggetto nell'heap, in modo da poter chiamare metodi su di esso.
Ma un riferimento che punta a null non ha alcun oggetto da puntare nell'heap e quindi otterrai un NullPointerException.
La stringa vuota è distinta da riferimento nullo in quello in un linguaggio di programmazione orientato agli oggetti a riferimento null a un tipo di stringa non punta a un oggetto string e causerà un errore se si tenta di eseguire qualsiasi operazione su di esso. Il vuoto stringa è ancora una stringa su cui le operazioni stringa possono essere tentate.
Dall'articolo di wikipedia su stringa vuota .
Una stringa può essere vuota o avere un valore null. Se una stringa è null, non si riferisce a nulla in memoria. Prova s.length()>0. Questo perché se una stringa è vuota, restituisce ancora una lunghezza di 0. Quindi, se non inserisci nulla per lo stesso, continuerà comunque il loop poiché non registra la stringa come null. Mentre se controlli la lunghezza, uscirà dal suo ciclo.
Questo concetto può essere meglio compreso dalla matematica. Hai mai provato a dividere un numero (non zero) per 0 usando una calcolatrice, ad esempio 7/0? Otterrai un risultato che assomiglia a qualcosa di questo: undefined, not a number, null ecc. Ciò significa che l'operazione è impossibile, per alcuni motivi (lasciamo che questi motivi siano discussi un altro giorno).
Ora, esegui questo: 0/7. Otterrai l'output, 0. Ciò significa che l'operazione è possibile e può essere eseguita, ma la risposta è solo 0 perché nulla è rimasto dopo la divisione. C'è un output valido e quell'output è zero.
Nel primo esempio, non solo l'output non era valido, ma l'operazione non era possibile eseguire. Questo è simile alla stringa null in java. Il secondo esempio è simile a empty string.