Ile obiektów String ..?

Question

Ja i mój przyjaciel dyskusji na smyczki i trzymaliśmy na ten temat:

String str = "ObjectOne"+"ObjectTwo"; 

Mówi sumie trzy obiekt zostanie utworzony i mówię zostanie utworzony jeden obiekt.

Jego logika za 3 obiektami to: jeden dla "ObjectOne" i jeden dla "ObjectTwo", a trzeci to połączona wersja dwóch obiektów String.

Moja logika jeden obiekt jest w czasie kompilacji oba obiekty STRING być łączone w kodu bajtowego jak:

String str = "ObjectOneObjectTwo"; 

iw czasie wykonywania tylko jeden obiekt zostanie utworzony w taki sposób. Jaka jest prawda za tym.

Answer 1

Jeśli piszesz (literały lub stałymi)

String str = "ObjectOne"+"ObjectTwo"; 

to odpowiednik

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

Answer 2

Można to znaleźć dla siebie za pomocą funkcji javap demontować kod, aby zobaczyć, co kompilator z tego. Załóżmy, że masz ten przykład:

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

skompilować, a następnie demontować go javap -c Example. Wynikiem jest:

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 
} 

Jak widać, istnieje tylko jeden String obiekt, który zawiera „ObjectOneObjectTwo”. Tak naprawdę, kompilator wykonuje konkatenację dla ciebie podczas kompilacji.

Answer 3

String str = "ObjectOne"+"ObjectTwo"; 

3 przedmioty zostaną utworzone

1- "ObjectOne"

2 "ObjectTwo"

3- "ObjectOneObjectTwo"

zastosowanie

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

Answer 4

Można łatwo sprawdzić to samemu:

1. Kompilacja następującego programu:

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

2. skontrolować kodu bajtowego emitowanego przez kompilator:

   javap.exe -v Test.class 
   

Na główne metody , drukuje:

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; 
} 

Jak widać, program używa instrukcji kodu bajtowego ldc, aby odnieść się do pojedynczej, już załadowanej instancji łańcucha (ładowanej podczas testu Test.class). W związku z tym nie powstaje nowy obiekt podczas wykonywania tej linii.

Kompilator jest required aby wykonać tę optymalizację przez języka Java Specification:

Obiekt String jest nowo utworzone (§12.5), chyba że wyrażenie jest stałą czasu kompilacji wyrażenie (§15.28).

Answer 5

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

W powyższym przypadku zostaną utworzone trzy obiekty.

Ale podczas definiowania jak

String str = "ObjectOne"+"ObjectTwo"; 

następnie zostanie utworzony tylko jeden obiekt. Kompilator je optymalizuje.

Answer 6

Obiekt typu String jest niezmienny.

String str = "ObjectOne"+"ObjectTwo"; 

     is same as 

    String str = "ObjectOneObjectTwo"; 

Przez niezmienny rozumiemy, że wartości zapisanej w obiekcie String nie można zmienić. Następne pytanie, które przychodzi nam na myśl, brzmi: "Jeśli String jest niezmienny, to w jaki sposób mogę zmienić zawartość obiektu, kiedy tylko chcę?". Cóż, to dokładnie to nie jest ten sam obiekt String, który odzwierciedla zmiany, które robisz. Wewnętrznie tworzony jest nowy obiekt String w celu dokonania zmian.

Więc załóżmy zadeklarować obiekt String:

String myString = "Hello"; 

Następny, który chcesz dołączyć „guest” do tego samego łańcucha. Co robisz?

Podczas drukowania zawartości myString na wyjściu pojawi się "Witaj gościu". Mimo że korzystaliśmy z tego samego obiektu (myString), wewnętrznie powstał nowy obiekt w procesie. Tak więc mystring będzie odnosić się do "Hello Guest". Odniesienie do cześć jest utracone.

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

W przypadku 1 literał s1 jest tworzony nowo i przechowywany w puli. Ale w przypadku 2, dosłowny s2 odwołuje się do s1, zamiast tego nie utworzy nowego.

jeśli (s1 == s2) System.out.println ("równy"); // Prints równać

 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.