Quanti oggetti String ..?

Question

Io e il mio amico stava discutendo sulle stringhe e abbiamo bloccato su questo:

String str = "ObjectOne"+"ObjectTwo"; 

Dice totale tre oggetto verrà creato e io dico verrà creato un oggetto.

La sua logica dietro 3 oggetti è: uno per "ObjectOne" e uno per "ObjectTwo" e il terzo è la versione concatenata di due oggetti String.

La mia logica dietro un oggetto è in fase di compilazione sia gli oggetti stringa verranno concatenati nel codice byte come:

String str = "ObjectOneObjectTwo"; 

E in fase di esecuzione un solo oggetto verrà creato in questo modo. Qual è la verità dietro a questo.

Answer 1

Se si scrive (letterali o costanti)

String str = "ObjectOne"+"ObjectTwo"; 

E 'equivalente a

String str = "ObjectOneObjectTwo"; // compiler optimize it so one Object 

Answer 2

È possibile trovare questo da soli utilizzando lo strumento javap di smontare il codice, per vedere che cosa la compilatore fatto di esso. Supponiamo di avere questo esempio:

public class Example { 
    public static void main(String[] args) { 
     String s = "ObjectOne" + "ObjectTwo"; 
     System.out.println(s); 
    } 
} 

compilarlo, poi smontare con javap -c Example. Il risultato è:

Compiled from "Example.java" 
public class Example { 
    public Example(); 
    Code: 
     0: aload_0 
     1: invokespecial #1     // Method java/lang/Object."<init>":()V 
     4: return 

    public static void main(java.lang.String[]); 
    Code: 
     0: ldc   #2     // String ObjectOneObjectTwo 
     2: astore_1 
     3: getstatic  #3     // Field java/lang/System.out:Ljava/io/PrintStream; 
     6: aload_1 
     7: invokevirtual #4     // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
     10: return 
} 

Come si vede, c'è solo un String oggetto, che contiene "ObjectOneObjectTwo". Quindi, in effetti, il compilatore esegue la concatenazione per te al momento della compilazione.

Answer 3

String str = "ObjectOne"+"ObjectTwo"; 

3 oggetti saranno creati come

1- "ObjectOne"

2- "ObjectTwo"

3- "ObjectOneObjectTwo"

uso

StringBuffer tmp = new StringBuffer("ObjectOne"); 
tmp.append("ObjectTwo"); 
str = tmp.toString(); 

Answer 4

Si può facilmente verificare voi stessi:

1. compilare il seguente programma:

   public static void main(String[] args) { 
       String str = "ObjectOne"+"ObjectTwo"; 
       System.out.println(str); 
   } 
   

2. Ispezionare il bytecode emessa dal compilatore:

   javap.exe -v Test.class 
   

Per il metodo principale , queste stampe:

public static void main(java.lang.String[]); 
    flags: ACC_PUBLIC, ACC_STATIC 

    Code: 
     stack=2, locals=2, args_size=1 
     0: ldc   #16     // String ObjectOneObjectTwo 
     2: astore_1  
     3: getstatic  #18     // Field java/lang/System.out:Ljava/io/PrintStream; 
     6: aload_1  
     7: invokevirtual #24     // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
     10: return   
     LineNumberTable: 
     line 6: 0 
     line 7: 3 
     line 8: 10 
     LocalVariableTable: 
     Start Length Slot Name Signature 
       0  11  0 args [Ljava/lang/String; 
       3  8  1 str Ljava/lang/String; 
} 

Come si può vedere, il programma utilizza l'istruzione bytecode ldc per fare riferimento a una singola istanza di stringa già caricata (che viene caricata quando Test.class è). Nessun nuovo oggetto viene quindi creato durante l'esecuzione di quella linea.

Il compilatore è required per eseguire questa ottimizzazione da parte del linguaggio Java Specification:

L'oggetto String viene creato ex novo (§12.5) a meno che l'espressione è una fase di compilazione un'espressione costante (§15.28).

Answer 5

String str1 = "ObjectOne"; 
String str2 = "ObjectTwo"; 
str1 = str1+str2; 

Nel caso di cui sopra verrà creato tre oggetti.

Ma quando si definisce come

String str = "ObjectOne"+"ObjectTwo"; 

quindi verrà creato un solo oggetto. Il compilatore lo ottimizza.

Answer 6

L'oggetto stringa è immutabile.

String str = "ObjectOne"+"ObjectTwo"; 

     is same as 

    String str = "ObjectOneObjectTwo"; 

Immutabile, intendiamo che il valore memorizzato nell'oggetto String non può essere modificato. Quindi la prossima domanda che ci viene in mente è "Se String è immutabile, allora come posso modificare il contenuto dell'oggetto ogni volta che lo desidero?". Beh, per essere precisi non è lo stesso oggetto String che riflette le modifiche che fai. Internamente viene creato un nuovo oggetto String per eseguire le modifiche.

Quindi supponiamo si dichiara un oggetto String:

String myString = "Hello"; 

Successivamente, si vuole aggiungere “Guest” per la stessa stringa. cosa fai?

myString = myString + " Guest"; 

Quando si stampa il contenuto di myString, l'output sarà "Ciao ospite". Sebbene abbiamo fatto uso dello stesso oggetto (myString), internamente è stato creato un nuovo oggetto nel processo. Quindi mystring si riferirà a "Hello Guest". Il riferimento a Ciao è perso.

String s1 = "hello"; //case 1 
    String s2 = "hello"; //case 2 

Nel caso 1, il letterale s1 viene creato di recente e tenuto nella piscina. Ma nel caso 2, letteralmente s2 si riferisce a s1, non ne creerà uno nuovo.

if (s1 == s2) System.out.println ("uguale"); // Stampe uguali

 String s= "abc"; //initaly s refers to abc 
     String s2 =s; //s2 also refers to abc 
     s=s.concat("def"); // s refers to abcdef. s no longer refers to abc.