Unary Operators in Java: Positive, Negative, Increment, and More

A unary operator takes exactly one operand, which is why it binds more tightly than any binary operator: in -a * b the minus applies to a before the multiplication happens.

There is no unary "not a number" operator, and no unary version of %, *, or /. Note also that - and + in this table are the single-operand forms: a - b is binary subtraction and is a completely different operator that merely shares a symbol.

Both forms change the variable by exactly one. The only difference is **what value the expression produces**.

int x = 5;
int y = x++;
step 1: read x -> 5(this is what y receives) step 2: x becomes 5 + 1 = 6 result: x == 6 y == 5 6(this is what q receives) result: p == 6 q == 6

int a = 5;
int b = ++a;
// b = 6, a = 6
int c = 5;
int d = c++;
// d = 5, c = 6
System.out.println(b + " " + a);
// 6 6
System.out.println(d + " " + c);
// 5 6

So the difference is only visible when the expression's value is **used**. On its own line, i++; and ++i; do exactly the same thing to i.

This is the single most common interview question on the topic, and the answer surprises almost everyone.

int i = 1;
i = i++;
System.out.println(i);
// 1, not 2

Why? Postfix i++ produces the value 1 and leaves i holding 2. Then the assignment i = 1 writes the 1 back over it. The increment happened and was immediately thrown away.

i = i++;
i = 1 RHS: i++ -> yields 1, leaves i = 2 LHS: i -> write 1 final: i == 1 the +1 was discarded

Contrast this with the compound assignment form, which behaves as you would expect, because it reads the variable and writes back the combined result.

int i = 1;
i += 1;
System.out.println(i);
// 2

The two operators work on different levels, which is why they disagree. i++ hands you a **copy** of the old value, and you store that copy. i += 1 reads the current value, adds one, and stores the sum.

Increment and decrement change a variable in place, so they require something the language treats as an assignable location, called an **lvalue**. Literals, constants and arbitrary expressions are not assignable, and the compiler rejects them.

int x = ++5;
// error: unexpected type
int y = ++(3 + 2);
// error: unexpected type
final int K = 1;
int z = ++K;
// error: cannot assign a value to final variable K

Unary minus and plus have no such restriction, because they only read their operand and produce a new value.

int a = -5;
// perfectly legal
int b = -(3 + 2);
// also legal, evaluates to -5

The same distinction explains a pair of compile errors that look inconsistent at first glance but are not.

byte b = 10;
b = b + 1;
// error: incompatible types: possible lossy conversion from int to byte
b++;
// perfectly legal, and b becomes 11

b + 1 is binary arithmetic, so it promotes b to int and produces an int, which cannot be assigned back to a byte without a cast. b++ is treated as b = (byte)(b + 1), because increment is a compound assignment and the language inserts the narrowing cast for you. Both are covered in detail in the assignment topic.

Increment works on byte, short, char, int, long, float and double, but not on boolean, which is a compile error.

byte b = 10;
b++;
// 11
short s = 10;
s++;
// 11
char c = 'A';
c++;
// 'B', since 65 becomes 66
double d = 1.5;
d++;
// 2.5
boolean flag = false;
flag++;
// error: bad operand type boolean for unary operator '++'

An int that is incremented at Integer.MAX_VALUE wraps around to Integer.MIN_VALUE, with no exception. The same is true for long, and for byte and short, which wrap within their own range.

int big = Integer.MAX_VALUE;
big++;
System.out.println(big);
// -2147483648
int small = Integer.MIN_VALUE;
small--;
System.out.println(small);
// 2147483647
byte b = Byte.MAX_VALUE;
b++;
System.out.println(b);
// -128, wrapped within the byte range

The narrower types are worth noting. byte wraps at 127 back to -128, and short wraps at 32767 back to -32768, because those are their own ranges and not versions of the int range.

Because an array element is a genuine variable, arr[i]++ is legal and it writes back to the array. This is one place where postfix increment does something useful rather than merely handing back a stale copy.

int[] arr = {
    10, 20, 30
};
int v = arr[1]++;
System.out.println(v);
// 20, the old value
System.out.println(arr[0] + "," + arr[1] + "," + arr[2]);
// 10,21,30

The same expression can be dangerous when the index depends on the element being incremented.

int[] arr = {
    10, 20, 30
};
int v = arr[arr[1]++];
// uses arr[1] == 20 as the index
// throws ArrayIndexOutOfBoundsException: Index 20 out of bounds for length 3

The value 20 is read as the index and the array is still written back, but the index is far past the end of a three-element array. It is a rare trap precisely because the first half of the expression looks completely normal.

Java permits an expression that increments the same variable twice, and it does produce a value. It is legal, and the result is deterministic on a given run, but the language specification says the two modifications are not sequenced relative to each other, so depending on it is a bad idea.

int i = 5;
System.out.println(i++ + i++);
// 11
System.out.println(i);
// 7, both increments did apply
int j = 5;
System.out.println(j++ + j);
// 11, j reads as 6 by then
int k = 1;
System.out.println(k++ + ++k);
// 4

The practical advice is to never write two of these in one expression. Keep each one as its own statement and the question disappears.

int i = 5;
int sum = i++;
sum = sum + i++;

Unary minus negates its operand and unary plus leaves the value alone, but both still perform numeric promotion. This is the detail that surprises people: + is not quite a no-op.

int a = +7;
System.out.println(a);
// 7
char c = 'A';
System.out.println(-c);
// -65, not a character
System.out.println((char)(-c));
// a non-ASCII character
System.out.println((int)+c);
// 65, plus promoted the char to int

Because both promote, unary minus on a char gives an int, and assigning it back to a char needs a cast, just like binary arithmetic does.

char c = 'A';
c -> 'A'(a 16 bit char, value 65) -c -> promote to int -> 65 negate -> -65 an int, not a char(char)(-c) -> narrow back down -> some non-ASCII character so -'A' == -65 , and -'A' != '-' or 'A' in any sense

Unary minus can also be applied twice to undo itself, and it overflows on the most negative value.

int n = 5;
System.out.println(-(-n));
// 5
int m = Integer.MIN_VALUE;
System.out.println(-m);
// still MIN_VALUE, it overflows

-Integer.MIN_VALUE is itself Integer.MIN_VALUE, because 2147483648 has no int representation and wraps. There is no positive counterpart to MIN_VALUE in the signed 32-bit range.

! inverts a boolean and only a boolean. It does not work on numbers, which is where it differs from the bitwise operators in C and C++.

boolean flag = false;
System.out.println(!flag);
// true
System.out.println(!!flag);
// false, back where it started
System.out.println(!(5 > 3));
// false
System.out.println(!5 > 3);
// compiles as (!5) > 3, and !5 does not compile

The last line is worth pausing on. Because ! binds very tightly, !5 > 3 is parsed as (!5) > 3, not as !(5 > 3), so it fails to compile. Parentheses are not optional there.

~ flips every bit of an integral value. In two's complement, which is what Java uses for all its signed integers, flipping all the bits is the same as negating and then subtracting one: ~n equals -(n + 1).

Here is the bit pattern that makes it obvious. The compiler prints it for us with toBinaryString.

System.out.println(Integer.toBinaryString(5));
// 101
System.out.println(Integer.toBinaryString(~5));
// 11111111111111111111111111111010
System.out.println(Integer.toBinaryString(-6));
// 11111111111111111111111111111010
System.out.println(~5 == -(5 + 1));
// true

5 in 32 bit two's complement

       00000000 00000000 00000000 00000101
       |
       |  flip every single bit
       v
     ~5

       11111111 11111111 11111111 11111010

     and that is exactly -6, because -6 is stored as its complement plus one,
     which is 5 + 1 =
6.  This is why ~n always equals -(n + 1).

Since ~ is its own inverse, applying it twice gives the original back, which is a handy way to describe it.

System.out.println(~~5 == 5);
// true
System.out.println(~~Integer.MIN_VALUE == Integer.MIN_VALUE);
// true

Note that ~Integer.MIN_VALUE is Integer.MAX_VALUE, not MIN_VALUE. It is the one value in the range that is its own negative, so negating it overflows and returns it unchanged, but complementing it produces the largest positive value.

System.out.println(~Integer.MIN_VALUE);
// 2147483647
System.out.println(-Integer.MIN_VALUE);
// -2147483648, unchanged by overflow

++ and -- are close relatives of += and -=, and the pair behaves in a revealingly different way, which is worth seeing side by side.

byte i = 10;
i = i + 1;
// error: incompatible types: possible lossy conversion from int to byte
i += 1;
// legal, i is 11
i++;
// legal, i is 12

This is the practical reason to reach for ++ rather than writing out += 1: it is shorter, and it also compiles on the narrow types where the expanded form does not.

The whole topic reduces to one distinction. ++x and --x change the variable and then hand you the new value, while x++ and x-- hand you the old value and change the variable afterwards. Everything else follows from that: why i = i++ is a no-op, why ++ needs a real variable while - does not, and why the increment forms compile on a byte where the written-out version does not.