Java code optimization, will it optimize this

Question

With newer compilers I find myself trying to write code that is easier to read but may be more memory hungry if the optimization I hope are being done under the hood are not actually being done. Take this code for example, very simple case

while (scanner.hasNextLine() && !result)
{
    String line = scanner.nextLine();
    result = line.indexOf(searchString) >= 0;
}

Would it be fair to assume ( Using Eclipse Juno, Java 7 ) that this will generate the same byte code as

while (scanner.hasNextLine() && !result)
{
    result = scanner.nextLine().indexOf(searchString) >= 0;
}

The former although 2 lines of code reduces the length of the second line and makes it easier on the eye. IMHO But would it also result in an unessecary String object being created? I hope not ...

There is the same number of object creations in both versions. — Denys Séguret
– Denys Séguret, Commented Nov 9, 2012 at 14:02
Use the javap tool (included with the JDK) to find out for yourself. Disassemble the code of both versions with the -c option. I wouldn't be surprised if the bytecode for both versions is exactly the same. (In fact, I would be surprised if it is not the same). — Jesper
– Jesper, Commented Nov 9, 2012 at 14:07
@ppeterka Wrong. Premature optimization is. Early optimization is sometimes perfectly valid and effective, and saves a lot of optimization work later on. — user395760
– user395760, Commented Nov 9, 2012 at 14:11

Marko Topolnik · Accepted Answer · 2012-11-09 14:09:07Z

7

You cannot escape the String being created. The fact that you assign it to a local variable is irrelevant here and actually at the bytecode level this fact will not even be noticed: at that level, with or without an explicit variable, the reference to the result must be placed on the stack in order to be passed into the next method invocation in the chain.

Your idea that an unnecessary String instance is created may stem from an instinct coming from another language, such as C: the assignment String s = ... only copies the reference to the one and only string instance. This is due to the fact that all Java objects reside on the heap, so you always need to explicitly copy an object to actually involve another instance. For example, if you wrote String line = new String(scanner.nextLine()), that would indeed create an unnecessary instance of String.

To conclude, there is no optimization involved in any version of your code, so choose according to stylistic preference only.

edited Nov 9, 2012 at 14:09

answered Nov 9, 2012 at 14:03

Marko Topolnik

201k31 gold badges336 silver badges455 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

MayoMan Over a year ago

The example was probably overly simplified but I get the point Marko makes here. I did read on SO here in a post I can't track down that in most cases the less attention you give to trying to write complex statements for optimizing code that the better the compiled code will be when modern day compilers parse your code and look for common coding structures that can be optimized easily. Thnx

Marko Topolnik Over a year ago

The first thing to distinguish is the Java compiler from the JIT compiler. The former is just a workhorse, doing the boilerplate stuff, and everything interesting happens in the JIT. So the JIT doesn't even see your source code directly. That makes it a doubly futile effort to try and outsmart the system, which is designed to produce optimal results for idiomatically written Java.

Jack · Accepted Answer · 2012-11-09 14:05:10Z

Some general principles:

premature optimization is rather pointless
saving for readability in these minor cirsumstances is pointless
most times optimization comes from changing algorithms and their complexity
you are never good as a compiler when trying to optimize something that is not an algorithm
to be sure of any optimization there are just two ways: looking at bytecode or benchmarking performance, everything else is usually speculation

In your specific case: a variable declaration doesn't change anything in term of optimitation since in both cases a string is istantiated by nextLine() and placed on the stack, assigning it to a variable (which disappears in bytecode, unless it's an instance variable, as it's usefulness is just for your eyes) doesn't change anything.

ymutlu · Accepted Answer · 2012-11-09 14:37:11Z

2

Seems off topic but this would inc performance too.

while (!result && scanner.hasNextLine())
{
    String line = scanner.nextLine();
    result = line.indexOf(searchString) >= 0;
}

answered Nov 9, 2012 at 14:37

ymutlu

6,7394 gold badges38 silver badges48 bronze badges

Comments

Natix · Accepted Answer · 2012-11-09 14:40:43Z

Why not ask the Java Class File Disassembler - the javap program that is included in every JDK?

Having the following source code:

public class Foo {

    static void m1(Scanner scanner, String searchString, boolean result) {
        while (scanner.hasNextLine() && !result) {
            String line = scanner.nextLine();
            result = line.indexOf(searchString) >= 0;
        }
    }

    static void m2(Scanner scanner, String searchString, boolean result) {
        while (scanner.hasNextLine() && !result) {
            result = scanner.nextLine().indexOf(searchString) >= 0;
        }
    }
}

When running the disassembler:

javap -c Foo.class

You get the following bytecode:

static void m1(java.util.Scanner, java.lang.String, boolean);
Code:
   0: goto          22
   3: aload_0
   4: invokevirtual #33                 // Method java/util/Scanner.nextLine:()Ljava/lang/String;
   7: astore_3
   8: aload_3
   9: aload_1
  10: invokevirtual #39                 // Method java/lang/String.indexOf:(Ljava/lang/String;)I
  13: iflt          20
  16: iconst_1
  17: goto          21
  20: iconst_0
  21: istore_2
  22: aload_0
  23: invokevirtual #45                 // Method java/util/Scanner.hasNextLine:()Z
  26: ifeq          33
  29: iload_2
  30: ifeq          3
  33: return

static void m2(java.util.Scanner, java.lang.String, boolean);
Code:
   0: goto          20
   3: aload_0
   4: invokevirtual #33                 // Method java/util/Scanner.nextLine:()Ljava/lang/String;
   7: aload_1
   8: invokevirtual #39                 // Method java/lang/String.indexOf:(Ljava/lang/String;)I
  11: iflt          18
  14: iconst_1
  15: goto          19
  18: iconst_0
  19: istore_2
  20: aload_0
  21: invokevirtual #45                 // Method java/util/Scanner.hasNextLine:()Z
  24: ifeq          31
  27: iload_2
  28: ifeq          3
  31: return

If you compare the bytecode for the two methods, you see that the only difference is that the m1 contains these two extra instructions:

7: astore_3
8: aload_3

This simply stores a reference to the object on top of the stack into a local variable, nothing else.

Edit:

The disassembler can also show the number of local variables for the methods:

javap -l Foo.class

Which outputs:

static void m1(java.util.Scanner, java.lang.String, boolean);
LocalVariableTable:
  Start  Length  Slot  Name   Signature
         0      34     0 scanner   Ljava/util/Scanner;
         0      34     1 searchString   Ljava/lang/String;
         0      34     2 result   Z
         8      14     3  line   Ljava/lang/String;

static void m2(java.util.Scanner, java.lang.String, boolean);
LocalVariableTable:
  Start  Length  Slot  Name   Signature
         0      32     0 scanner   Ljava/util/Scanner;
         0      32     1 searchString   Ljava/lang/String;
         0      32     2 result   Z
}

Which basically confirms the only difference seen above - the m1 methods only allocates one more local variable - String line. It doesn't create any more objects, it only creates one more reference to an object that is allocated either way.

Operations that will probably be optimised on the fly (thanks JIT)

Colin Hebert · Accepted Answer · 2012-11-09 14:22:26Z

To answer your question, when scanner.nextLine().indexOf(searchString) is executed; what do you expect nextLine() to do? And on which object do you expect indexOf() to be executed?

As you have probably guessed it relies on a String; so yes, this String is created and yes this String is used. It is (contrary to your guess) necessary.

The operation of declaring a variable (String s) and assigning a value cost nothing compared to the instantiation of an object (new String("test")).

In other words, what you are trying to achieve isn't either useful or significantly more performant.

There is a second problem here, a way deeper problem for developers in general. Trying to do optimisation on that kind of code, without having encountered an actual problem and without any obvious sign that this code could make your application run significantly slower is simply premature.

Most of the time it will distract you from what you want to achieve and will lead you to write unreadable code for the sake of an optimisation (that may not even be an optimisation at all!).

In your particular case (I'm surprise nobody mentioned it earlier, and this is why I write this answer) your "optimised" code will make everyone's life worse.

Imagine that your code runs, and a some point everything fails and you get a NullPointerException on this line:

    result = scanner.nextLine().indexOf(searchString) >= 0;

Instead of having a clear idea of what is failing you now have to manually debug that code to find out if scanner is null or if for some reason nextLine() returns null.

This problem didn't even exist in your previous code, but this desire of optimising early and trying to make your code more compact to avoid waisting a few operations has now made your code globally worse.

Dace · Accepted Answer · 2012-11-09 14:04:34Z

0

The compiler will inline the local variable line anyway, so there is no difference between the two

answered Nov 9, 2012 at 14:04

Dace

4991 gold badge7 silver badges17 bronze badges

Collectives™ on Stack Overflow

Java code optimization, will it optimize this

6 Answers 6

2 Comments

Comments

Comments

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

2 Comments

Comments

Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related