Compiler optimization of final variables

[asabab mortanonov]

Hi,
Can someone explain to me what optimizations respectively presumption the compiler makes on the following code?

public class AsmMain
{
   public static void main(final String[] args)
   {
      String a = "Bar";
      String b = " ";
      String c = "Foo";
      String d = a + b + c;
      System.out.println(d);
   }
}

When I disassembly this code, it is obviously that the compiler translates the string concatenation to StringBuilder.append() (yes, I know that strings are immutable)

Compiled from "AsmMain.java"
public class AsmMain extends java.lang.Object{
public AsmMain();
  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 Bar
   2:   astore_1
   3:   ldc     #3; //String
   5:   astore_2
   6:   ldc     #4; //String Foo
   8:   astore_3
   9:   new     #5; //class java/lang/StringBuilder
   12:  dup
   13:  invokespecial   #6; //Method java/lang/StringBuilder."<init>":()V
   16:  aload_1
   17:  invokevirtual   #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   20:  aload_2
   21:  invokevirtual   #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   24:  aload_3
   25:  invokevirtual   #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   28:  invokevirtual   #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   31:  astore  4
   33:  getstatic       #9; //Field java/lang/System.out:Ljava/io/PrintStream;
   36:  aload   4
   38:  invokevirtual   #10; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   41:  return

}

Now if I change the class AsmMain so that all the variables are final:

public class AsmMain
{
   public static void main(final String[] args)
   {
      final String a = "Bar";
      final String b = " ";
      final String c = "Foo";
      final String d = a + b + c;
      System.out.println(d);
   }
}

... the disassembled output looks like this :

Compiled from "AsmMain.java"
public class AsmMain extends java.lang.Object{
public AsmMain();
  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 Bar
   2:   astore_1
   3:   ldc     #3; //String
   5:   astore_2
   6:   ldc     #4; //String Foo
   8:   astore_3
   9:   ldc     #5; //String Bar Foo
   11:  astore  4
   13:  getstatic       #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   16:  ldc     #5; //String Bar Foo
   18:  invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   21:  return

}

What is the explanation of this optimizations?
Thanks in advance.

[Martin Vajsar]

Java compiler automatically joins any String constants that are concatenated using the "+" operator. I believe this is defined by the JLS. String constants are String literals and all final String variables whose value is a String constant (yes, the definition is recursive).

Non-final String variables are not considered String constants, which is why in the first case the concatenation was not done.

[asabab mortanonov]

Martin Vajsar wrote:Java compiler automatically joins any String constants that are concatenated using the "+" operator. I believe this is defined by the JLS. String constants are String literals and all final String variables whose value is a String constant (yes, the definition is recursive).

Non-final String variables are not considered String constants, which is why in the first case the concatenation was not done.

Hello Martin,

Thanks for the answer.After your hint I found it in JLS.