Come si può inizializzare una stringa usando “”?

Se String è una classe come qualsiasi altra, come può essere inizializzata usando virgolette doppie?

Java String è speciale

I progettisti di Java hanno deciso di conservare i tipi primitivi in ​​un linguaggio orientato agli oggetti, invece di rendere tutto un oggetto, in modo da migliorare le prestazioni del linguaggio. I primitivi sono memorizzati nello stack di chiamate, che richiedono meno spazi di archiviazione e sono più economici da manipolare. D'altra parte, gli oggetti vengono archiviati nell'heap del programma, il che richiede una gestione della memoria complessa e più spazi di archiviazione.

Per motivi di prestazioni, Java String è progettato per essere compreso tra una primitiva e una classe.

Per esempio

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

Nota: i valori letterali di stringa sono memorizzati in un pool comune. Ciò facilita la condivisione dell'archiviazione per stringhe con gli stessi contenuti per conservare l'archiviazione. Stringgli oggetti allocati tramite un nuovo operatore vengono archiviati in heap, e non esiste condivisione dello spazio di archiviazione per gli stessi contenuti.

Java considera String come una classe speciale, che puoi inizializzare in entrambi i modi

1. Assegnazione diretta letterale

   String a = "adsasdf";

2. Come altri oggetti che usano una nuova parola chiave

   String a = new String("adsasdf");

È necessario prestare particolare attenzione quando si desidera confrontare con il ==segno:

String a = "asdf";
String b = "asdf";
System.out.println(a == b);  // True
System.out.println(a.equals(b)); // True

String a = new String("asdf");
String b = new String("asdf");
System.out.println(a == b);  // False
System.out.println(a.equals(b)); // True

Questo perché nel primo caso gli oggetti aeb vengono mantenuti in qualcosa chiamato literal pool ed entrambi fanno riferimento allo stesso oggetto, quindi sono uguali in entrambi i modi.

Ma nel secondo caso aeb fanno riferimento a diversi oggetti come quando inizializziamo qualsiasi altro oggetto. quindi sono disuguali se confrontati con l' ==operatore mentre sono uguali in valori.

La stringa riceve un trattamento speciale nel JLS: è uno dei due tipi non primitivi per i quali esistono letterali (l'altro è Class) ^* .

Dal JLS :

Un letterale stringa è un riferimento a un'istanza della classe `String [...].

^{* beh, c'è anche il "tipo null" con il suo "valore letterale null" null, ma la maggior parte delle persone non pensa al "tipo null" come a un tipo corretto.}

È una caratteristica del linguaggio Java. Ai letterali di stringa nel codice sorgente viene assegnato un trattamento speciale.

Le specifiche del linguaggio, qui , dicono semplicemente che un letterale stringa è di Stringtipo

Il testo tra virgolette doppie crea un Stringoggetto letterale .

String myString = "Some text";

Il codice sopra crea un Stringoggetto, usando le doppie virgolette.

Le stringhe sono molto spesso utilizzate in un linguaggio di programmazione. Poiché java è orientato agli oggetti, una stringa è un oggetto. Per evitare la nuova ingombrante String ("someString"); ogni volta che hai bisogno di un oggetto stringa java ti permette di creare un oggetto stringa usando il valore letterale stringa.

Ma dovresti tenere presente l'uguaglianza delle stringhe. Ecco un breve test JUnit per dimostrare cosa intendo.

    @Test
    public void stringTest() {
       // a string literal and a string object created 
       // with the same literal are equal
       assertEquals("string", new String("string"));

       // two string literals are the same string object
       assertSame("string", "string"); 

       // a string literal is not the same object instance 
       // as a string object created with the same string literal
       assertFalse("string" == new String("string"));

       // java's String.intern() method gives you the same
       // string object reference for all strings that are equal.
       assertSame("string", new String("string").intern());
    }

Solo per citare. Un letterale a string è un riferimento a un'istanza della classe String che puoi scrivere in questo modo:

 .getBytes "ABC" ();

 "A: b: c" .split ( ":");

 "愛" .codePointAt (0);

- String è una classe in Java . Hai ragione, quindi possiamo sempre inizializzare con la newparola chiave.

- Ma quando facciamo qualcosa del genere:

String s = "";

L'istruzione precedente è contrassegnata dal compilatore come un oggetto String speciale e quindi JVM durante il caricamento della classe (il caricamento viene eseguito prima dell'inizializzazione), vede ciò che è noto come letterale stringa , che viene archiviato in un pool letterale stringa .

- Quindi una stringa può essere creata usando new()e con il ""metodo, ma quest'ultima fornisce una stringa letterale che rimane nell'heap anche quando non c'è alcun riferimento a quell'oggetto stringa, perché ha un riferimento dal pool letterale stringa.

Java esegue un processo in due fasi per noi.

String str = "hello";

è equivalente a

char data[] = {'h', 'e', 'l' , 'l', 'o'};
String str = new String(data);

Come [.NET] [1] ha ottenuto una cosa simile.

String(Char[]) constructor

fa

String(char[] value)

Aggiunta di riferimenti: -

• http://docs.oracle.com/javase/6/docs/api/java/lang/String.html
• http://msdn.microsoft.com/en-us/library/system.string.aspx

Java.lang.Stringnon è solo una classe. È parte integrante del linguaggio principale. Il compilatore ha zucchero sintattico per questo. Ad esempio, ""è come un'abbreviazione per new String(""). Quando è scritto, ""il compilatore ottimizza stringhe identiche nella stessa istanza per risparmiare spazio."a" + 5 == "a5" ==> true

Il compilatore ha zucchero sintattico per molte cose, incluso il non dover box / unbox tra le versioni degli oggetti e i loro tipi nativi, nessun genitore significa Oggetto, costruttore predefinito, ...