Differenza tra stringa Java nulla e vuota (“”)

Qual è la differenza tra nulle la ""(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 dichiarazioni ritornano false. Sembra che non riesca a trovare qual è la differenza effettiva tra loro.

"" è una stringa effettiva, sebbene vuota.

null, tuttavia, significa che la variabile String 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 è che dal momento che "" è una stringa effettiva, puoi comunque invocare metodi o funzioni su di essa come

a.length()

a.substring(0, 1)

e così via.

Se la stringa è nulla, come b, Java lancerebbe a NullPointerExceptionse si provasse a invocare, dire:

b.length()

Se la differenza che ti stai chiedendo è == contro uguale, è questa:

== confronta i riferimenti, come se fossi andato

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

Ciò darebbe falso perché ho allocato due oggetti diversi e aeb puntano a oggetti diversi.

Tuttavia, a.equals(b)in questo caso restituirà true, poiché equalsper String restituirà true se e solo se l'argomento String non è null e rappresenta la stessa sequenza di caratteri.

Tieni presente, tuttavia, 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, poiché dovrebbe allocare due stringhe diverse. In realtà, Java eseguirà internamente stringhe letterali (quelle inizializzate come aeb nel nostro esempio). Quindi fai attenzione, perché ciò può dare alcuni falsi positivi su come funziona ==.

Puoi anche capire la differenza tra null e una stringa vuota in questo modo:

Immagine originale di R. Sato ( @raysato )

String è un oggetto e può essere nullo

null significa che l'oggetto String non è stato istanziato

"" è un valore effettivo della stringa di oggetti istanziata come "aaa"

Ecco un link che potrebbe chiarire quel punto http://download.oracle.com/javase/tutorial/java/concepts/object.html

Quello che ti dicono le tue affermazioni è solo che "" non è uguale a null, il 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 niente lì.

C'è una differenza abbastanza significativa tra i due. La stringa vuota ""è "la stringa che non contiene caratteri". È una stringa effettiva che ha una lunghezza ben definita. Tutte le operazioni di stringa standard sono ben definite sulla stringa vuota: puoi convertirla in lettere minuscole, cercare l'indice di alcuni caratteri al suo interno, ecc. La stringa nulla nullè "nessuna stringa". Non ha una lunghezza perché non è affatto una stringa. Il tentativo di applicare qualsiasi operazione di stringa standard alla stringa nulla provocherà un NullPointerExceptionruntime.

qui a is an Objectma nonb(null) è un oggetto è un riferimento null

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

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

ecco la mia risposta simile

null indica che il nome non fa riferimento a nessun oggetto istanziato. "" indica una stringa vuota.

Qui a si sta riferendo un oggetto che sembra essere una stringa vuota. b non fa riferimento a nessun oggetto poiché è nullo.

In Java un tipo di riferimento assegnato nonnull ha alcun valore . Una stringa assegnata ""ha un valore: una stringa vuota, vale a dire una stringa senza caratteri. Quando viene assegnata una variabile nullsignifica che non vi è alcun oggetto sottostante di alcun tipo, stringa o altro.

"" e null sono entrambi diversi. il primo indica come parte della dichiarazione della variabile stringa la costante stringa è stata creata nel pool di stringhe e una parte della memoria è stata assegnata per la stessa.

Ma quando lo dichiariamo con null allora è stato appena istanziato jvm, ma non è stata allocata memoria per questo. quindi se stai provando ad accedere a questo oggetto controllandolo con "" - variabile vuota, non può impedire nullpointerexception. Di seguito è riportato 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 a cui punta nullnon ha alcun oggetto da indicare nell'heap e quindi otterrai un NullPointerException.

La stringa vuota è distinta da un riferimento null in quanto in un linguaggio di programmazione orientato agli oggetti un riferimento null a un tipo di stringa non punta a un oggetto stringa e provocherà un errore se si tenta di eseguire qualsiasi operazione su di esso. La stringa vuota è ancora una stringa su cui si possono tentare operazioni di stringa.

Dall'articolo di Wikipedia su stringa vuota .

String s=null;

La stringa non è inizializzata per null. se viene tentata un'operazione con una stringa, può generare un'eccezione puntatore null

String t="null";

È una stringa letterale con stringa di valore "null" uguale a t = "xyz". Non genererà un puntatore nullo.

String u="";

È una stringa vuota, non genererà un puntatore nullo.

Una stringa può essere vuota o avere un nullvalore. Se una stringa lo è null, non si riferisce a nulla in memoria. Prova s.length()>0. Questo perché se una stringa è vuota, restituisce comunque una lunghezza di 0. Quindi, se non si inserisce nulla per lo stesso, continuerà comunque a funzionare in ciclo poiché non registra la stringa come null. Considerando che se controlli per 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? Si otterrà un risultato che assomiglia a qualcosa questo: undefined, not a number, nullecc Ciò significa che l'operazione non è possibile, per alcuni motivi (Lasciamo queste ragioni da discutere un altro giorno).

Ora esegui questo: 0/7. Otterrai l'output, 0. Ciò significa che l'operazione è possibile e può essere eseguita, ma tu la risposta è solo 0 perché non è rimasto nulla dopo la divisione. C'è un output valido e quell'output è zero.

Nel primo esempio, non solo l'output non era valido, ma non era possibile eseguire l'operazione. Questo è simile a una nullstringa in Java. Il secondo esempio è simile alla emptystringa.

Quando scrivi

String a = "";

Significa che esiste una variabile 'a' di tipo stringa che punta a un riferimento a oggetto nel pool di stringhe che ha un valore "". Poiché la variabile acontiene un riferimento a un oggetto stringa valido, è possibile applicare qui tutti i metodi di stringa.

Mentre quando scrivi

String b = null;

Significa che esiste una variabile bdi tipo stringa che punta a un riferimento sconosciuto . E qualsiasi operazione su riferimento sconosciuto comporterà un NullPointerException.

Ora, valutiamo le espressioni seguenti.

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 parole povere,

• "" è una stringa vuota

• null è una variabile stringa vuota .

Differenza tra stringa nulla e stringa vuota. Ad esempio: hai una variabile chiamata x. Se scrivi in ​​JS,

var x = "";

questo significa che hai assegnato un valore che è stringa vuota (la lunghezza è 0). In realtà questo è come qualcosa ma che non sente nulla :) D'altra parte,

var y = null;

questo significa che non hai assegnato un valore a y che è chiaramente indicato scrivendo null a y al momento della dichiarazione. Se scrivi y.length; genererà un errore che indica che nessun valore assegnato a y e di conseguenza non può leggere la lunghezza di y.

Questa immagine potrebbe aiutarti a capire le differenze.

L'immagine è stata raccolta da ProgrammerHumor

"Lo chiamo il mio errore da miliardi di dollari. Fu l'invenzione del riferimento nullo nel 1965" - https://en.wikipedia.org/wiki/Tony_Hoare

Per quanto riguarda il mondo reale, entrambi possono essere assunti uguali. È solo una sintassi di un linguaggio di programmazione che crea una differenza tra due, come spiegato da altri qui. Questo crea semplicemente un sovraccarico come quando si controlla / confronta se la variabile stringa ha qualcosa, è necessario prima verificare se non è nullo e quindi confrontare la stringa effettiva, cioè due confronti. Questo è uno spreco di potenza di elaborazione per ogni confronto di stringhe.

Objects.equals () controlla null prima di chiamare .equals ().

come una curiosità

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

     s1 = s1 + s2;
   

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