Understanding Different Operators in Java

Welcome back, Java enthusiasts! In this article, we’ll dive into the various operators in Java. Operators are special symbols that perform specific operations on one, two, or three operands, and then return a result. Understanding how to use these operators effectively is crucial for writing efficient and concise code. Let’s explore the different types of operators available in Java and see some practical examples.

Types of Operators

Java operators can be categorized into several groups:

1. Arithmetic Operators
2. Relational Operators
3. Logical Operators
4. Assignment Operators
5. Unary Operators
6. Bitwise Operators
7. Ternary Operator

Arithmetic Operators

Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus.

• + : Addition
• - : Subtraction
• * : Multiplication
• / : Division
• % : Modulus (remainder)

Example:

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

        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
    }
}

Relational Operators

Relational operators are used to compare two values. They return a boolean result based on the comparison.

• == : Equal to
• != : Not equal to
• > : Greater than
• < : Less than
• >= : Greater than or equal to
• <= : Less than or equal to

Example:

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

        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));
    }
}

Logical Operators

Logical operators are used to perform logical operations on boolean values.

• && : Logical AND
• || : Logical OR
• ! : Logical NOT

Example:

public class LogicalOperatorsExample {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;

        System.out.println("x && y: " + (x && y));
        System.out.println("x || y: " + (x || y));
        System.out.println("!x: " + (!x));
    }
}

Assignment Operators

Assignment operators are used to assign values to variables. The most common assignment operator is =, but there are also compound assignment operators that combine arithmetic or bitwise operations with assignment.

• = : Simple assignment
• += : Add and assign
• -= : Subtract and assign
• *= : Multiply and assign
• /= : Divide and assign
• %= : Modulus and assign

Example:

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

        a += 5; // a = a + 5
        System.out.println("a += 5: " + a);

        a -= 3; // a = a - 3
        System.out.println("a -= 3: " + a);

        a *= 2; // a = a * 2
        System.out.println("a *= 2: " + a);

        a /= 4; // a = a / 4
        System.out.println("a /= 4: " + a);

        a %= 3; // a = a % 3
        System.out.println("a %= 3: " + a);
    }
}

Unary Operators

Unary operators are used with only one operand to perform various operations like incrementing/decrementing a value, negating an expression, or inverting the value of a boolean.

• + : Unary plus (indicates a positive value, but numbers are positive by default)
• - : Unary minus (negates an expression)
• ++ : Increment (increases a value by 1)
• -- : Decrement (decreases a value by 1)
• ! : Logical complement (inverts the value of a boolean)

Example:

public class UnaryOperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        boolean b = false;

        System.out.println("+a: " + (+a));
        System.out.println("-a: " + (-a));
        System.out.println("++a: " + (++a));
        System.out.println("--a: " + (--a));
        System.out.println("!b: " + (!b));
    }
}

Bitwise Operators

Bitwise operators are used to perform bit-level operations on integer types.

• & : Bitwise AND
• | : Bitwise OR
• ^ : Bitwise XOR
• ~ : Bitwise complement
• << : Left shift
• >> : Right shift
• >>> : Unsigned right shift

Example:

public class BitwiseOperatorsExample {
    public static void main(String[] args) {
        int a = 5; // 0101 in binary
        int b = 3; // 0011 in binary

        System.out.println("a & b: " + (a & b)); // 0001 in binary = 1
        System.out.println("a | b: " + (a | b)); // 0111 in binary = 7
        System.out.println("a ^ b: " + (a ^ b)); // 0110 in binary = 6
        System.out.println("~a: " + (~a)); // 1010 in binary = -6
        System.out.println("a << 1: " + (a << 1)); // 1010 in binary = 10
        System.out.println("a >> 1: " + (a >> 1)); // 0010 in binary = 2
        System.out.println("a >>> 1: " + (a >>> 1)); // 0010 in binary = 2
    }
}

Ternary Operator

The ternary operator is a shorthand way of writing an if-else statement. It has the form condition ? expression1 : expression2.

Example:

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

        int max = (a > b) ? a : b;
        System.out.println("Maximum value: " + max);
    }
}

Conclusion

Operators are fundamental tools in Java that allow you to perform a wide range of operations on data. In this article, we covered arithmetic, relational, logical, assignment, unary, bitwise, and ternary operators. Understanding and using these operators effectively will help you write more concise and efficient code.

Next up: We’ll explore control flow statements in Java, including if-else, switch-case, loops, and more. Keep coding and happy learning!