The unary bitwise complement operator (~) inverts a bit pattern; it can be applied to any of the integral types, making every 0 a 1 and every 1 a 0.

For example, an integer contains 32 bits; applying this operator to a value whose bit pattern is 00000000000000000000000000001000 would change its pattern to 11111111111111111111111111110111.

package org.kodejava.basic;

public class UnaryBitwiseComplementOperator {
    public static void main(String[] args) {
        // An integer type contains 32 bit information.
        // 8 = 00000000000000000000000000001000
        int number = 8;
        System.out.println("number = " + number);
        System.out.println(Integer.toBinaryString(number));

        // Using the ~ operator inverts the number by change the
        // every "0" to "1" and every "1" to "0".
        // 00000000000000000000000000001000
        // 11111111111111111111111111110111
        //
        int invertedNumber = ~number;
        System.out.println("invertedNumber = " + invertedNumber);
        System.out.println(Integer.toBinaryString(invertedNumber));
    }
}

The result of the code snippet:

number = 8
1000
invertedNumber = -9
11111111111111111111111111110111

The unary operators requires only one operand to operate on, it can perform operations such as incrementing or decrementing value by one, negating a value or inverting a value of a boolean expression.

The unary operators use the following symbols:

Symbol	Description
+	unary plus operator; indicates positive value
-	unary minus operator; negates a value
++	unary increment operator; increments value by one
--	unary decrement operator; decrements value by one
!	unary logical complement operator; inverts a boolean value

package org.kodejava.basic;

public class UnaryOperatorsDemo {
    public static void main(String[] args) {
        int result = +10;  // result = 10
        System.out.println("result = " + result);
        result--;          // result = 9
        System.out.println("result = " + result);
        result++;          // result = 10
        System.out.println("result = " + result);
        result = -result;  // result = -10;
        System.out.println("result = " + result);

        // The increment and decrement operators can be applied
        // before (prefix) or after (postfix) the operand. Both
        // of them will increment or decrement value by one. The
        // different is that the prefix version evaluates to the
        // incremented or decremented value while the postfix
        // version evaluates to the original value;
        --result;
        System.out.println("result = " + result);
        ++result;
        System.out.println("result = " + result);

        boolean status = result == -10;  // status = true
        System.out.println("status = " + status);
        status = !status;                // status = false;
        System.out.println("status = " + status);
    }
}

The following example show you how to use Java arithmetic operators. The operators consist of the multiplicative operators (* for multiplication, / for division), % for remainder of division) and the additive operators (+ for addition,- for subtraction).

You’ll also see we are using a combination of a simple assignment operator with the arithmetic operators to create compound assignments.

package org.kodejava.basic;

public class ArithmeticOperatorsDemo {
    public static void main(String[] args) {
        int result = 5 + 4;  // result = 9
        System.out.println("result = " + result);

        result = result - 2; // result = 7
        System.out.println("result = " + result);

        result = result * 4; // result = 28
        System.out.println("result = " + result);

        result = result / 7; // result = 4
        System.out.println("result = " + result);

        result = result % 3; // result = 1
        System.out.println("result = " + result);

        // Combining the arithmetic operators with a simple assignment
        // operators give us a compound assignment. We can write the
        // operation above in the following form. But as you can see
        // the above snippets is easier to read.
        result = 5 + 4; // result = 9
        System.out.println("result = " + result);

        result -= 2;    // result = 7
        System.out.println("result = " + result);

        result *= 4;    // result = 28
        System.out.println("result = " + result);

        result /= 7;    // result = 4
        System.out.println("result = " + result);

        result %= 3;    // result = 1
        System.out.println("result = " + result);
    }
}

The remainder or modulus operator (%) let you get the remainder of a division of two numbers. This operator can be used to obtain a reminder of an integer or floating point types.

package org.kodejava.basic;

public class RemainderOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        double b = 49;

        // The reminder operator (%) gives you the remainder of
        // an integer or floating point division operation.
        System.out.println("The result of " + a + " % 5 = " + (a % 5));
        System.out.println("The result of " + b + " % 9.5 = " + (b % 9.5));
    }
}

Here is the result of the program:

The result of 10 % 5 = 0
The result of 49.0 % 9.5 = 1.5

The ternary operator or conditional operator can be use as a short version of the if-then-else statement. When you have a simple if-then-else statement in your code that return a value you might use the ternary operator, it can make your code easier to read.

The ternary operator is written using the symbol of ?: and it has the following syntax:

result = testCondition ? value1 : value2;

When the test condition evaluates to true the expression value1 will be returned else the expression value2 will be returned. The value1 or value2 is not only for a simple field or variable, it can be a call to a method for example. But it is advisable to use the ternary operator for a simple thing, because if you over do it, it will make your code harder to read.

Let’s see the following code:

package org.kodejava.basic;

public class TernaryOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // Get the maximum value
        int min = a < b ? a : b;

        // The use of ternary operator above is an alternative
        // of the following if-then-else statement.
        int minValue;
        if (a < b) {
            minValue = a;
        } else {
            minValue = b;
        }

        // Get the maximum value.
        int max = a > b ? a : b;

        // Get the absolute value.
        int abs = a < 0 ? -a : a;

        System.out.println("min      = " + min);
        System.out.println("minValue = " + minValue);
        System.out.println("max      = " + max);
        System.out.println("abs      = " + abs);
    }
}

The output of the code snippet above:

min      = 10
minValue = 10
max      = 20
abs      = 10