Java speed access array index versus temp variable

Question

What is faster in Java. Accessing an array index directly multiple times, or saving the value of the array index to a new variable and use this for following compution?

acces index

if ((shape.vertices[0].x >= fromX && shape.vertices[0].x <= toX) || // left side of shape in screen
    (shape.vertices[0].x <= fromX && shape.vertices[0].x + shape.width >= fromX) || // right side of shape in screen
    (shape.vertices[0].x >= fromX && shape.vertices[0].x + shape.width <= toX)) { // shape fully in screen

    // ...
}

temp variable

float x = shape.vertices[0].x;
float y = shape.vertices[0].y;
if ((x >= fromX && x <= toX) || // left side of shape in screen
    (x <= fromX && x + shape.width >= fromX) || // right side of shape in screen
    (x >= fromX && x + shape.width <= toX)) { // shape fully in screen

        // ...
    }

If it really makes a difference, then the JIT will probably optimize these to the same compiled code. I wouldn't expect there to be a performance difference at all. Which one is more _readable_ is pretty subjective, though I would lean towards option 2. — Louis Wasserman, Apr 19 '12 at 15:49

Eugene Retunsky · Accepted Answer · 2012-04-19T15:53:16.407

7

The second approach is definitely faster. But you can help even more with the final keyword:

final float x = shape.vertices[0].x;
final float y = shape.vertices[0].y;
final int rightEdge = x + shape.width;
if ((x >= fromX && x <= toX) || // left side of shape in screen
(x <= fromX && rightEdge >= fromX) || // right side of shape in screen
(x >= fromX && rightEdge <= toX)) { // shape fully in screen

    // ...
}

Not a significant improvement of course (but still an improvement and also makes the intent clear). You can read this discussion: http://old.nabble.com/Making-copy-of-a-reference-to-ReentrantLock-tt30730392.html#a30733348

edited Apr 19 '12 at 15:53

answered Apr 19 '12 at 15:35

Eugene Retunsky

13,009
4
52
55

I doubt that you'll get a measurable difference in performance from the `final` (but then again it's a good idea to use it to make the intent clear). – Joachim Sauer Apr 19 '12 at 15:38
how/why does final make it faster? – Andreas Linden Apr 19 '12 at 15:42
I would have though that the JVM would optimise the code this way for you. – Peter Lawrey Apr 19 '12 at 17:43
@SteveKuo it may have impact: http://stackoverflow.com/questions/316352/why-would-one-mark-local-variables-and-method-parameters-as-final-in-java – Eugene Retunsky Feb 26 '13 at 22:26
3

@EugeneRetunsky It has no impact. The generated byte code is identical with and without `final`. Try it yourself and see (use `javap -c`). – Steve Kuo Feb 26 '13 at 22:57
@SteveKuo ok, it has no impact. But still doesn't hurt and makes the intent clear (temp. caching of variables for read-only purposes). – Eugene Retunsky Mar 29 '13 at 17:51

score 2 · Answer 2 · answered Apr 19 '12 at 15:39

In the long run declaring a temp array would be quicker because the jvm has to compute the offset when accessing an array element.

Use a profiling tool and see which is quicker for your use, but I'd caution that unless you're doing something really intensive that is very time-sensitive, this isn't going to be a huge improvement.

score 1 · Answer 3 · answered Apr 19 '12 at 15:58

Run the code through a profiler to answer the question for your usecase.

The answer to this will probably be JVM specific. The Oracle HotSpot JVM is going to perform differently than OpenJDK or IBM's JDK. Timings will depend on how the JVM optimizes the byte code, what it decides to compile while it is running. Server vs client mode will probably make a difference too.

So aim for readability. Optimize after profiling and determining that section of code is the problem.

score 0 · Answer 4 · answered Apr 19 '12 at 15:37

0

The second approach is faster, but will consume more memory. But the performance increases is only nano seconds, unless you array size is huge.

answered Apr 19 '12 at 15:37

Pau Kiat Wee

9,485
42
40

LaGrandMere · Answer 5 · 2012-04-19T15:43:38.797

-1

I would recommend second approach, simply because it is a lot more readable and helps a lot the maintainability.

Performance gains, except if your array is huge, are really really small.

Readability gains, on the other hand, are always good to take.

edited Apr 19 '12 at 15:43

answered Apr 19 '12 at 15:37

LaGrandMere

10,265
1
33
41

@zolex : Well, then I'd go for Chris Blade's answer : Use a profiling tool :) – LaGrandMere Apr 19 '12 at 15:45

trevorism · Answer 6 · 2012-04-19T15:59:46.037

-1

Array access could be faster. Note the following program:

public class ArraySpeedTest{

public static void main(String [] args){

    float x = 4.4f;
    float [] xArr = new float[1];
    xArr[0] = 4.4f;

    long time1 = System.nanoTime();
    for(int i = 0 ; i < 1000*1000*1000; i++){
        if(x > 1 && x < 5){

        }
    }
    long time2 = System.nanoTime();

    System.out.println(time2-time1);

    long time3 = System.nanoTime();
    for(int i = 0 ; i < 1000*1000*1000; i++){
        if(xArr[0] > 1 && xArr[0] < 5){
        }
    }
    long time4 = System.nanoTime();

    System.out.println(time4-time3);


}

}

OUTPUT:: 5290289 2130667

JVM implementations, flags, and order of the program can change the performance on the order of a few milliseconds.

edited Apr 19 '12 at 15:59

answered Apr 19 '12 at 15:48

trevorism

411
2
7

2

Array is only faster because the variable loops are being used for warming up the jvm. Subsequent executions show that var access is definitely faster: var: 2802110900 arr: 2660019100 var: 2515318700 arr: 2670587900 var: 2487106500 arr: 2682468400 var: 2485047300 arr: 2642655100 var: 2501300200 arr: 2672457400 var: 2495593500 arr: 2650383400 var: 2489377200 arr: 2646188100 var: 2501328200 arr: 2643038700 var: 2489211300 arr: 2641330100 var: 2495374900 arr: 2662683300 – subes Oct 09 '18 at 15:10

Java speed access array index versus temp variable

6 Answers6

Linked

Related