Equality (==) operator in Java with Examples

== operator is a type of Relational Operator in Java which is used to check for relations of equality. It returns a boolean result after the comparison and is extensively used in looping statements as well as conditional if-else statements.

Syntax:

LHS value == RHS value

But, while comparing these values, three cases arise generally:



  1. Case 1: When both LHS and RHS values are primitive
    This is most simple among the cases. As a primitive data is stored in the stack memory, in this case, the actual value of both the sides are fetched from the stack memory and compared. It returns true, if they both are equal, else false is returned.

    Syntax:

    Actual value == Actual value
    

    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Java program for using == operator
      
    import java.io.*;
      
    public class GFG {
        public static void main(String[] args)
        {
      
            // Declaring primitive values
            int a = 4;
            int b = 4;
            int c = 5;
      
            // Comparing a and b using == operator
            System.out.println("Are " + a
                               + " and " + b
                               + " equal? "
                               + (a == b));
      
            // Comparing b and c using == operator
            System.out.println("Are " + b
                               + " and " + c
                               + " equal? "
                               + (b == c));
        }
    }

    chevron_right

    
    

    Output:

    Are 4 and 4 equal? true
    Are 4 and 5 equal? false
    
  2. Case 2: When one of LHS and RHS value is a primitive and the other is reference
    In this scenario, for the primitive side, the actual value is taken for comparison from the stack memory. But for the reference side, when an array is declared and initialized, the data is stored in the heap memory and the reference pointer in the stack memory. So all that is in the stack memory is the memory address.

    Syntax:

    Actual value == Address value
        OR
    Address value == Actual value
    

    So when the comparison between a primitive value and a reference value is taken, the program doesn’t compile and throws an error:

    Compilation Error in java code:-

    prog.java:20: error: incomparable types: int and int[]
                               + (a == b));
                                    ^
    1 error
    

    This is because the value for the primitive side is easily fetched from the stack memory, but for the reference side, the value cannot be fetched, as the value is in heap memory. Hence the error.

    Example:



    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Java program for using == operator
      
    import java.io.*;
      
    public class GFG {
        public static void main(String[] args)
        {
      
            // Declaring primitive value
            int a = 4;
      
            // Declaring reference value
            int[] b = { 1, 2, 3, 4 };
      
            // Comparing a and b using == operator
            System.out.println("Are " + a
                               + " and " + b
                               + " equal? "
                               + (a == b));
        }
    }

    chevron_right

    
    

  3. Case 3: When both of the LHS and RHS value are reference
    In this scenario, for both the sides, when an array is declared and initialized, the data is stored in the heap memory and the reference pointer in the stack memory. So both the variables, their address is checked. If both the variables point to the same memory address, then this operator returns true. Else it returns false.

    Syntax:

    Address value == Address value
    

    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Java program for using == operator
      
    import java.io.*;
      
    public class GFG {
        public static void main(String[] args)
        {
      
            // Declaring reference value
            int[] a = { 1, 2, 3, 4 };
            int[] b = { 1, 2, 3, 4 };
            int[] c = b;
      
            // Comparing a and b using == operator
            // Though they both have the same value
            // the output will be false because
            // they both have a different address in the memory
            System.out.println("Are " + a
                               + " and " + b
                               + " equal? "
                               + (a == b));
      
            // Comparing b and c using == operator
            // Though they both have the same value
            // the output will be true because
            // they both have same address in the memory
            System.out.println("Are " + b
                               + " and " + c
                               + " equal? "
                               + (b == c));
        }
    }

    chevron_right

    
    

    Output:

    Are [I@232204a1 and [I@4aa298b7 equal? false
    Are [I@4aa298b7 and [I@4aa298b7 equal? true
    

java-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.