CODEWITHSUNDEEP
javavariablesswitch-statementbytecode
Twinone
Twinone

Reputation: 3029

Storing in variable vs. having multiple different methods

What are the pros and cons of using this:

String a = new String();
switch (i) {
case 1: a = "Cueck"; break;
case 2: a = "Blub"; break;
case 3: a = "Writing cases is BORING!"; break;
}
System.out.println(a);

Versus:

switch (i) {
case 1: System.out.println("Cueck"); break;
case 2: System.out.println("Blub"); break;
case 3: System.out.println("Writing cases is BORING!"); break;
}

Which generates better bytecode? And which generates more bytecode?

Upvotes: 4

Views: 103

Answers (3)

beny23
beny23

Reputation: 35018

Using javap -c classname you can check the bytecode yourself,

Here's option 1:

(Note, I had to initialise a = null otherwise it doesn't compile)

   7:   aconst_null
   8:   astore_2
   9:   iload_1
   10:  tableswitch{ //1 to 3
                1: 36;
                2: 42;
                3: 48;
                default: 51 }
   36:  ldc     #3; //String Cueck
   38:  astore_2
   39:  goto    51
   42:  ldc     #4; //String Blub
   44:  astore_2
   45:  goto    51
   48:  ldc     #5; //String Writing cases is BORING!
   50:  astore_2
   51:  getstatic       #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   54:  aload_2
   55:  invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   58:  return

Here's option 2:

   7:   iload_1
   8:   tableswitch{ //1 to 3
                1: 36;
                2: 47;
                3: 58;
                default: 66 }
   36:  getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   39:  ldc     #4; //String Cueck
   41:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   44:  goto    66
   47:  getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   50:  ldc     #6; //String Blub
   52:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   55:  goto    66
   58:  getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   61:  ldc     #7; //String Writing cases is BORING!
   63:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   66:  return

Personally, I don't think there's better bytecode in this instance, I find option 1 more readable.

Upvotes: 4

Duncan Jones
Duncan Jones

Reputation: 69339

Your first option is neater and has less redundant code. One suggested change:

String a;

switch (i) {
  case 1: a = "Cueck"; break;
  case 2: a = "Blub"; break;
  case 3: a = "Writing cases is BORING!"; break;
  default: throw new IllegalStateException("Unknown option!");
}

System.out.println(a);

Don't create a String unnecessarily - a should be instatiated when required. A default case should either throw an exception or set a to a default value.

Which generates better bytecode? And which generates more bytecode?

I wouldn't worry about that. This doesn't strike me as a likely bottleneck in any real-life application. Also, you cannot be sure what the JVM will do to optimise the byte-code once your application is running.

Upvotes: 5

partlov
partlov

Reputation: 14277

I don't think there will be much difference in bytecode size but I suggest first approach. If you in some future code changes decide not to call System.out.println(a) but logger.debug(a) you will change that only on one place and not on all case switches.

Upvotes: 4

Related Questions