XOR and XNOR operators in Java

One of the Bitwise operators offered by Java is XOR. Two boolean operands are given to the XOR (also known as exclusive OR), which returns true if they are different. When neither of the two boolean conditions supplied can be true simultaneously, the XOR operator is most useful.

XOR Operator in Java (Exclusive OR)

The carrot ( ) symbol denotes the XOR operator. If two values are provided, it returns true when they differ; else, it returns false. True gets represented by 1 in binary, whereas false gets represented by 0.

The XOR operator's truth table is shown below:

As we can see from the above table, it only returns true if the values of both operands differ. Otherwise, false is returned.

Let's use an illustration to clarify it:

A good XOR operator example

Consider the illustration below:

XorExpl1.java

class XorExpl1    
{     
public static void main(String args[])     
{     
int a = 10, b = 7;   //declaring values  
// bitwise XOR         
System.out.println("a ^ b = " + (a ^ b));     
}    
}

Output:

XNOR operator

The opposite of the binary equivalent of XOR is given by XNOR.

Truth table:

If the bits are the same, it returns 1, else it returns 0.

Examples:

Input: 10 20

Output : 1

A Binary of 20 is 10100

A Binary of 10 is 1010

So the XNOR is 00001

So the output is 1

Input : 10 10

Output : 15

A Binary of 10 is 1010

So the XNOR is 1111

So the output is 15

Method 1:- (O(logn))

In this solution, each bit is checked separately. If two bits match, we output 1; otherwise, we output 0.

Let's explain it using the following code.

XNORExpl1.java

// Java program to calculate
// XNOR of two numbers
import java.util.*;
import java.lang.*;
 
public class XNORExpl1 {
 
    public static int xnor(int x, int y)
    {
        // x should be larger
        if (x < y) {
            // swapping x and y;
            int temp = x;
            x = y;
            y = temp;
        }
 
        if (x == 0 && y == 0)
            return 1;
 
        // for last bit of x
        int x_rem = 0;
 
        // for the last bit of y
        int y_rem = 0;
 
        // counter for c bit
        // and set bit in xnorn
        int c = 0;
 
        // to make new xnor number
        int xnorn = 0;
 
        // for set bits in new xnor number
        while (true) {
            // get last bit of x
            x_rem = x & 1;
 
            // get the last bit of y
            y_rem = y & 1;
 
            // Checking if the current two bits are the same
            if (x_rem == y_rem)
                xnorn |= (1 << c);
 
            // counter for c bit
            c++;
            x = x >> 1;
            y = y >> 1;
            if (x < 1)
                break;
        }
        return xnorn;
    }
 
    // Driver code
    public static void main(String args[])
    {
        int x = 10, y = 50;
        System.out.println(xnor(x, y));
    }
}

Output:

Second Method:- O(1)

Determine the maximum of the two provided numbers.
Flip the highest two numbers' bits.
Return the XOR of the bigger original number and the smaller changed number.

XNORExpl2.java

// Java program to calculate XNOR
// of two numbers
import java.io.*;
 
class XNORExpl2 {
     
    
    static int togglebit(int m)
    {
        if (m == 0)
            return 1;
 
        // copying m as we are
        // going to change it.
        int j = m;
 
        // Below steps set bits after
        // MSB (including MSB)
 
        m |= m >> 1;
 
        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        m |= m >> 2;
        m |= m >> 4;
        m |= m >> 8;
        m |= m >> 16;
 
        return j ^ m;
    }
 
    // Returns XNOR of n1 and n2
    static int xnor(int n1, int n2)
    {
        // if n2 is greater then
        // swap this number in n1 
        if (n1 < n2)
        {
            int t = n1;
            n1 = n2;
            n2 = t;
        }
     
        n1 = togglebit(n1);
     
        return n1 ^ n2;
    }
 
    /* Driver code to test above method */
    public static void main(String args[])
    {
        int x = 10, y = 20;    
        System.out.println(xnor(x, y));
    }
}

Output:

Third Method: Using XOR

Simply said, A XOR B is the opposite of XNOR of A and B. A bit mask must be created in order to only retrieve the real bits from an inverted binary number because directly inverting any binary number also flips the leading zeroes.

Below is an example of this implementation:

XNORExpl3.java

// Java program to find XNOR of two numbers.
class XNORExpl3 {
 
  // Returns XNOR of n1 and n2
  static int XNOR(int x, int y)
  {
    // getting the number of bits from
    // max of x and y to construct the bit mask
    int nOB = (int)(Math.log(Math.max(x, y)) / Math.log(2));
 
    // constructing the bit m
    int m = (1 << nOB) - 1;
 
    // x = inverted xor
    int x1 = ~(x ^ y);
 
    // getting only the required bits
    // using the m
    return x1 & m;
  }
 
  // Main method
  public static void main(String args[])
  {
    int n1 = 7, n2 = 19;
 
    // calling the function
    System.out.print(XNOR(n1, n2));
  }
}

Output: