XOR Operation on Long in Java

The XOR (distinctive OR) operation is a logical operation that takes two operands and returns genuine if and most effective if precisely one of the operands is authentic. In Java, the XOR operation is represented by using the caret symbol (^). While the XOR operation is generally used with boolean values, it could also be implemented to different statistics sorts, along with the long data type. In this context text, we are able to discover the XOR operation on long in Java and offer examples of the way it may be used.

The long data type in Java is a 64-bit signed two's complement integer. It can hold larger numerical values than the int data type, which makes it useful in scenarios that require the representation of large numbers. When applying the XOR operation to long values, the operation is performed bitwise, comparing the corresponding bits of the two operands.

Let's begin by looking at a simple program that demonstrates the XOR operation on long in Java:

XorOperationExample.java

public class XorOperationExample {
    public static void main(String[] args) {
        // Declare and initialize the first operand
        long operand1 = 123456789L;
        // Declare and initialize the second operand
        long operand2 = 987654321L;
        // Apply XOR operation on the two operands
        long result = operand1 ^ operand2;
        // Print the result
        System.out.println("Result: " + result);
    }
}

Output:

Result: 868421532

In this program, we declare long variables, operand1 and operand2, and assign them the values 123456789L and 987654321L, respectively. We then observe the XOR operation between the 2 operands and save the end result variable. Finally, we print the result to the console. The XOR operation on long compares each little bit of the two operands and returns a value with the same bit set to one if the corresponding bits are different, and 0 if they're the same. In this example, the binary representation of 123456789 is '00000111010101111000011000101001, and the binary illustration of 987654321 is '00111001011010000101111100100001'. After performing the XOR operation, we get 00111110001111111101100100001000, which is the binary representation of the decimal value 868421532.

Now, let's explore a few more examples to understand the behavior of the XOR operation on long in different scenarios.

Example 1:

XorOperationExample.java

public class XorOperationExample {
    public static void main(String[] args) {
        // Declare and initialize the first operand
        long operand1 = 10L;
        // Declare and initialize the second operand
        long operand2 = 10L;
        // Apply XOR operation on the two operands
        long result = operand1 ^ operand2;
        // Print the result
        System.out.println("Result: " + result);
    }
}

Output:

Result: 0

In this example, both operand1 and operand2 are assigned the value 10L. Since both operands have the same binary representation (00000000000000000000000000001010), the XOR operation will return 0.

Example 2:

XorOperationExample.java

public class XorOperationExample {
    public static void main(String[] args) {
        // Declare and initialize the first operand
        long operand1 = 5L;
        // Declare and initialize the second operand
        long operand2 = 3L;
        // Apply XOR operation on the two operands
        long result = operand1 ^ operand2;
        // Print the result
        System.out.println("Result: " + result);
    }
}

Output:

Result: 6

In this example, operand1 is assigned the value 5L ('00000000000000000000000000000101') and operand2 is assigned the value 3L ('00000000000000000000000000000011'). The XOR operation between these two operands will yield 00000000000000000000000000000110, which is the binary representation of the decimal value 6.

Example 3:

XorOperationExample.java

public class XorOperationExample {
    public static void main(String[] args) {
        long operand1 = -1L;
        long operand2 = -1L;
        long result = operand1 ^ operand2;
        System.out.println("Result: " + result);
    }
}

Output:

Result: 0

In this example, both operand1 and operand2 are assigned the value -1L. The binary representation of -1L in two's complement is all 1s (11111111111111111111111111111111). When the XOR operation is applied to two equal operands, the result is always 0. These examples demonstrate the application of the XOR operation on long in Java. The XOR operation may be beneficial in scenarios along with records encryption, error detection, and bitwise manipulation.

In the end, the XOR operation on long in Java compares the corresponding bits of two operands and returns a value with the identical bit set to one if the corresponding bits are distinct, and zero if they may be the identical. This operation can be easily performed using the caret symbol (^). Understanding the XOR operation and its behavior on long values is essential for working with bitwise operations and solving various programming challenges.

Next TopicArray Programs in Java

← prev next →