How is that x=20;x= ++x + ++x + x++ ;final value of x in java is 65 [duplicate]

Answer 1

I think that y= （++20） + (++21) + 22 = 21 + 22 +22 = 65

Answer 2

Overall this is bad programming and should never ever be used in actual code because it is easy to get lost in all the pre and post increments.

But here is the basic explanation.

simple enough:
x = 20 

Here is where it gets messy:
y = ++(20) + ++(++(20)) + (++(++(20)))++

Pre increment --> ++x
Post increment --> x++

Pre increments happen inside the evaluation and post 
increments happen after the evaluation.
So that statement can be reduced in the following steps.

y = 21 + ++(21) + (++(21))++

y = 21 + 22 + (22)++

y = 21 + 22 + 22

y = 65

After all these increments x = 23. In the statement above though, x equals multiple
numbers because of all the pre and post increments.

Moral of the story, don't ever do this and pre increments take place before the expression is evaluated and post increments take place after the expression is evaluated.

Answer 3

You should remember this C Operator Precedence

so post increment goes first ++X = 20 then x++=22 then x++ = 23 so total 65.

Answer 4

++x is different from x++

++x increments x before any operations done in that same line.

x++ increments x after any operations done in the same line.

For it to calculate to 65, it must be doing a calculation like the following.

(1+20)+(1+21)+(22)= 65

Afterwards, x would be 23

Answer 5

First, you should understand this:

++i increments i and returns i.

i++ returns i and then increments it.

Now that we have established this, let's break the program down.

At the start of your program, x = 20. So, ++x would return 21. Now when you increment x in this fashion again, you will be incrementing 21 and not 20. So, ++x + ++x will evaluate to 21 + 22 which equals 43. At this point in the program, x equals 22. So if you add x++ to 43, you will add the value of x to 43 and only then increment x. This ultimately results in y having a value of 65, and x having a value of 23.

Answer 6

Let Java show you. javap -c MyClass shows you bytecode:

  public static void main(java.lang.String[]);
    Code:
       0: bipush        20
       2: istore_1      
       3: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: iinc          1, 1
       9: iload_1       
      10: iinc          1, 1
      13: iload_1       
      14: iadd          
      15: iload_1       
      16: iinc          1, 1
      19: iadd          
      20: dup           
      21: istore_1      
      22: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      25: return        

And the result is completely logical if you think about it: you have two preincrements and one postincrement. So, your code is in effect:

y = 0

x++      // 21
y += x

x++      // 22
y += x

y += x   // (still 22!)
x++      // 23

x = y    // (21 + 22 + 22 at this point)