Why output is 0?

Question

class T {
    public static void main(String args[]) {
        int x = 0;
        x = x++;
        System.out.println(x);
    }
}

Answer 1

Because ++ is the "post increment" operator - it returns the value of the variable before it gets incremented.

The steps are:

• Take the value of i (before incrementing it) and remember it
• Increment i
• Assigned the remembered value to i

Answer 2

Because the post increment operator returns a temporal value (x´s current value) and then increments x.

Try it like this:

class T {
    public static void main(String args[]) {
        int x = 0;
        x = ++x;
        System.out.println(x);
    }
}

Answer 3

x = x++;

is equivalent to

 temp = x;

 x = x + 1;

 x = temp;

That's why the output is zero.

This operator is known as post increment operator. Other operator related to post increment operator is, per-increment operator.

x = ++x;

If you apply per-increment output will be 1.

Answer 4

Because you've used a postfix ++ operator, which means it's evaluated after the assignment. So first x = x is evaluated, so x stays as 0, and then x++ is evaluated, but the result is not assigned to anything.

You could use the prefix ++ operator to achieve your desired result: x = ++x;

From the docs:

The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value.

Answer 5

x++ returns zero and then increments x. The assignment x = x++ sets x (after it has been incremented) to the return value of x++, which was 0.

Answer 6

because ++ after is add after the program runs. you can fix it by the following two ways

class T {
    public static void main(String args[]) {
        int x = 0;
        x = ++x;
        System.out.println(x);
    }
}

or

class T {
    public static void main(String args[]) {
        int x = 0;
        x += 1;
        System.out.println(x);
    }
}

Answer 7

It's because x++ effectively means, "use the value stored in x and then increment it". If you want to increment the value before you use it, do ++x instead.

Answer 8

I don't now that it will make a difference in the output, but you don't need the import and you can change:

x = x++;

to:

x++;

Answer 9

Showing example of post increment with regular increment, as previous answerers said:

class T { 
    public static void main(String args[]) { 
        for (int i = 0; i < 6; i++) {
          int x = 0; 
          x = x+1+i; 
          System.out.println(x); 
        }
    } 
} 

Answer 10

The first result of this search is this link.

The reason it behaves as observed is because of the interaction between the operator precedence and the odd "return value" of the ++ operator. The postfix increment happens first (see your favorite copy of the operator precedence chart); but postfix, by definition, returns the previous value of the variable. So that "return value" is not "original x plus one", but instead just "original x" (x, at this point, actually contains the incremented value). This returned value is then assigned to x, which overwrites what the ++ did in the first place. IOW, in the expression x=x++, the incremented value is lost, overwritten by the assignment that happens last.

Google is your friend! :)

Answer 11

Explanation of what you are doing:

class T {
    public static void main(String args[]) {
        int x = 0; // x is zero
        x = x++;  // assign x to be x (which is 0). 
                 //  then increment a non-existant variable by 1
        System.out.println(x); //print 0
    }
}