Is declaring a local variable and setting it once more efficient than using a getter over and over?

Question

I was going through some code today and saw this:

    x.add(getResources().getString(R.string.none));
    x.add(getResources().getString(R.string.today));
    x.add(getResources().getString(R.string.tomorrow));
    ...

and so I thought, "that's inefficient!" and started to change it to:

    Resources res = getResources();
    x.add(res.getString(R.string.none));
    x.add(res.getString(R.string.today));
    x.add(res.getString(R.string.tomorrow));
    ...

but then I stopped and wondered: Is the second section of code really more efficient or does it not really matter? Is the compiler going to generate the same byte code either way?

score 4 · Accepted Answer · answered Oct 20 '11 at 15:02

4

The compiler will not generate the same byte code, but if getResources() is a trivial method then the JIT-compiler may effectively run the same code at execution time.

Personally I prefer the second form on the grounds of it being cleaner and more readable rather than for performance reasons.

answered Oct 20 '11 at 15:02

Jon Skeet

1,421,763
867
9,128
9,194

Thanks for all the answers - everyone of them was constructive, but I have to give the nod to Skeet. ;) – Jerry Brady Oct 20 '11 at 15:17

score 4 · Answer 2 · answered Oct 20 '11 at 15:06

Never trust the optimization of the compiler, I was disappointed in it several times. And in this case the java compiler cannot know if the getResources() method has any side effect or not (like locking an object, incrementing a counter), since when you build your project, it's compiled against the stub api, not the real code. The JIT is running inside the phone, so it's usually not as smart as a desktop compiler.

Also I think the preferred way would be:

final Resources res = getResources();
x.add(res.getString(R.string.none));
x.add(res.getString(R.string.today));
x.add(res.getString(R.string.tomorrow));
...

The final keyword usually helps the compiler in optimization.

I agree with you - some people poo poo the idea of using final outside of anonymous functions where they are necessary but I agree that anything you can tell the compiler about the future of the object helps. — Jerry Brady, Oct 20 '11 at 15:18

score 2 · Answer 3 · answered Oct 20 '11 at 15:09

The milliseconds difference between the two is nothing in comparison to the hours spent debugging this mistake:

x.add(getNewResources().getString(R.string.none));
x.add(getResources().getString(R.string.today));
x.add(getResources().getString(R.string.tomorrow));

Oops. The person updating the code was not sufficiently familiar with it and did not appreciate that all the getStrings had to come from the NewResource, not just the first one. He made the change, compiled it, delivered it, and now strange things are happening, and no one knows why.

In your second code fragment, you communicate to the reader of the code that there is a common place from which all the strings are extracted by actually creating a common place called "res".

score 1 · Answer 4 · answered Oct 20 '11 at 15:06

I would simply opt for the second version because it is a lot easier to read. You should not care about the potentially trivial performance impact, choosing readability over performance concerns is almost always the better choice.

Most likely in this trivial piece of code there will be no effect because the JIT will eventually generate the same code (although I am not sure if the Dalvik JVM is as good in jitting as the Java JVM is).

score 1 · Answer 5 · answered Oct 20 '11 at 15:06

Developer's Guide doesn't recommend using getters when you can use direct field access: Avoid Internal Getters/Setters.

Without a JIT, direct field access is about 3x faster than invoking a trivial getter. With the JIT (where direct field access is as cheap as accessing a local), direct field access is about 7x faster than invoking a trivial getter.

However, it won't make much of a difference unless you make many calls. So I would go with the most readable variant, which is in my opininon the second one since it has less clutter.

score 0 · Answer 6 · edited May 23 '17 at 12:12

0

Yes. The Java compilers are MUCH smarter than they were 10 years back. This would certainly optimized if the implementation of getResource() is { return xxx; }. But compilers are capable of doing even better optimizations. E.g.

edited May 23 '17 at 12:12

Community

1
1

answered Oct 20 '11 at 15:04

Kashyap

15,354
13
64
103

Is declaring a local variable and setting it once more efficient than using a getter over and over?

6 Answers6