Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Performance difference between using int a=a+1 and a++ in Java

Is there any performance difference between using int a=a+1 and a++ in Java?

If so which is better and why? Could you briefly explain me to understand this?

like image 612
Surya Chandra Avatar asked Feb 15 '12 11:02

Surya Chandra


People also ask

Which one is faster i ++ or i 1 explain?

As i++ does automatic typecasting and uses a compiler instruction which internally uses iadd instruction, i=i+1 is faster than i++.

Which is faster int or Integer in Java?

Primitive type int needs 4 bytes in Java but, Integer object occupies 16 bytes of memory. Hence, int is comparatively faster than an Integer object.

Is there a performance difference between i ++ and ++ i in Java?

What is the Difference Between i++ and ++i in Java? ++i and i++ both increment the value of i by 1 but in a different way. If ++ precedes the variable, it is called pre-increment operator and it comes after a variable, it is called post-increment operator.

Is Integer less efficient than int Java?

Use int when possible, and use Integer when needed. Since int is a primitive, it will be faster. Modern JVMs know how to optimize Integer s using auto-boxing, but if you're writing performance critical code, int is the way to go.


2 Answers

First of all, the Java Language Specification doesn't say anything about timing. But assuming we're using a typical compiler such as Suns javac we see that all of the above examples (a++, ++a, a += 1, a = a + 1) could either be compiled into something like:

  • iinc instruction, working on variables:

    iload_<variable>
    iinc <variable>, 1
    istore_<variable>
    
  • iadd instuction, using the stack (here using variable 1 as a the storage):

    iload_1
    iconst_1
    iadd
    istore_1
    

It's up to the compiler to choose the best possible way to compile them. E.g. there is no difference between them. And it shouldn't be any difference between the statements - they all express the same thing - adding one to a number.

That beeing said, both the iinc and the iadd version can be compiled using the JIT to something fast and platform dependent, and in the end I would assume that a normal runtime compiles both versions into the same assembler code.


With my compiler, *jdk1.6.0_20* the "increment" methods even uses the same instruction.

public class Test {
    public static void main(String[] args) {

        int a = 0;

        a = a + 1;
        a += 1;
        a++;
        ++a;
    }
}

This is the disassembly:

Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #8; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iinc    1, 1   // a = a + 1;
   5:   iinc    1, 1   // a += 1;
   8:   iinc    1, 1   // a++;
   11:  iinc    1, 1   // ++a;
   14:  return

}
like image 129
dacwe Avatar answered Oct 14 '22 14:10

dacwe


Looking at the generated bytecode:

public static void main(String[] args) {
    int x = 1;
    int y = 1;
    int z = 1;
    int a = 1;
    int b = 1;
    x = x + 1;
    y++;
    ++z;
    a += 1;
    b += 2;
}

generates (use javap -c classname)

0:   iconst_1
1:   istore_1
2:   iconst_1
3:   istore_2
4:   iconst_1
5:   istore_3
6:   iconst_1
7:   istore  4
9:   iconst_1
10:  istore  5
12:  iload_1
13:  iconst_1
14:  iadd
15:  istore_1
16:  iinc    2, 1
19:  iinc    3, 1
22:  iinc    4, 1
25:  iinc    5, 2
28:  return

So using (jdk1.6.0_18):

x = x + 1

creates

12:  iload_1
13:  iconst_1
14:  iadd
15:  istore_1

whereas

y++;
++z;
a += 1;

all result in

iinc

However, doing a rough performance test on my laptop resulted in next to no difference in the runtime between the two (sometimes ++x was quicker, sometimes x=x+1 was quicker), so I wouldn't worry about the performance implications.

like image 41
beny23 Avatar answered Oct 14 '22 15:10

beny23