There always seems to be a lot of confusion over the usage of pre/post inc/decrement operators. Of course, most of this confusion comes from people trying to prepare for the SCJP exam. The way I'm going to show these operators being used is not the way they are, or should, be used. However, if you want to prepare for the SCJP, I suggest you understand this stuff.

Throughout this post, keep in mind what the various operators do. A pre-increment operator takes the current value of the variable, increments it, and then uses the new value in the place of the expression. Meanwhile, a post-increment operator uses the current value of the variable in the expression and then increments the value. The decrement operators behave the same way except that they decrement the values rather than increments them. Here are a few examples:

int x = 0;
int y = 0;

// This evaluates to y = 0 and x is then incremented to 1.
y = x++; 

// This evaluates to y = 2 as x is incremented first and
// then inserted.
y = ++x; 

// This first decrements x to 1 and then uses it to 
// evaluate this statement to y = 1.
y = --x; 

// This statement uses the original value of x, which is 1
// to evaluate to y = 1, and then decrements x to 0.
y = x--;

Okay. With that in mind, let's look at a more thought-provoking example. Try to answer the following question (be aware that such a question is certainly fair game for the SCJP exam).

What is the result of compiling and executing the following code:



int x = 0;
int y = x++ + --x + ++x + x++ - x--;
System.out.println(x + "," + y);



A. -2,-2
B. 0,1
C. 1,0
D. 2,0
E. None of the Above

Did you get the answer? Let's go through how to solve such a problem before I reveal the correct response.

The key to solving such problems is know that operands are evaluated from left to right. Oddly enough, I had someone try to convince me otherwise once, but it's written out, clear as can be, in the JLS §15.7 Evaluation Order:

The Java programming language guarantees that the operands of operators appear to be evaluated in a specific evaluation order, namely, from left to right.

So, with that in mind, let's step through the process of evaluating this statement. We'll evaluate each operand, from left to right, one at a time.

Step 0: y = x++ + --x + ++x + x++ - x--;  // x = 0
Step 1: y =  0  + --x + ++x + x++ - x--;  // x = 1
Step 2: y =  0  +  0  + ++x + x++ - x--;  // x = 0
Step 3: y =  0  +  0  +  1  + x++ - x--;  // x = 1
Step 4: y =  0  +  0  +  1  +  1  - x--;  // x = 2
Step 5: y =  0  +  0  +  1  +  1  -  2;   // x = 1

With the operands fully evaluated, we see that x = 1 and y = 0.

So, that leaves C as the correct answer. Did you get it right?

Let's try another one.

What is the result of compiling and executing the following code:




int x = 0;
x = ++x + x++ + x-- - ++x + x++ + ++x;
System.out.println(x);



A. 0
B. 4
C. 5
D. 6
E. None of the Above

Okay, did you get this one? Once again, before I give you the answer, let's work through the solution. We'll do it just as we did before, evaluating each operand from left to right, one at a time.

int i = 0;
for (; i < 12;)
{
    i = i++;
}
System.out.println(i);

Then you'll see some sort of question like "What is the value of i when the loop terminates?" or some such thing. Well, as you should now recognize, that loop will never terminate. Rather, i will constantly flip between 0 and 1. With each iteration of the loop, you'll increment i using the post-increment operator, but you'll then immediately assign the previous value of i, which is 0, back to i. That prevents i from ever reaching 12 and the loop runs indefinitely.

Like I said earlier, this is not how you should be using these operators. In general, you want a maximum of 1 side effect per expression. When you have more than that, it is confusing. Going back to the JLS section I pointed out earlier, this is the following line:

It is recommended that code not rely crucially on this specification. Code is usually clearer when each expression contains at most one side effect, as its outermost operation, and when code does not depend on exactly which exception arises as a consequence of the left-to-right evaluation of expressions.

This is just another case (one of many) in which studying for the SCJP exam will teach you what you can do with Java but not at all what you should do with Java.

Yeah, I know, it's another lengthy post. One of these days, I promise, I'll come up with a tip that's short and sweet - just you wait. ;) Hopefully, you found this helpful.

Corey