Java: What is the difference between comparing strings with == and "str.equals()"?

[RockSolid1106]

So I just made this very simple code which checks if an array contains an item equal to something.

Code:

Spoiler

import java.util.*;
public class pg202Q7 {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String x[]={"hello", "how", "are", "you"};
        String y=in.next();
        System.out.println(inarray(x, y));
        in.close();
        }

    public static Boolean inarray(String array[], String needle){
        int i=0;
        Boolean p=false;
        for(;i<array.length; i++){
            if (array[i].equals(needle)){
                p=true;
                return p;
            }
        }
        return p;
    }
    

}
    

 

 

It works, but if I change the <string>.equals(needle) part to:

if (array[i]==needle){

then the code would always return false, even though the item is present in the array.

 

But, if I call the method by:

inarray(x, "hello"){

then the result is perfect(true).

But it wont work if I use:

inarray(x, y)

where String y is taken as input from the user with Scanner.

 

Could someone please explain to me, why == doesn't work the same as string.equals?

[tikker]

The equals method checks if the contents of the string are the same. == checks if they are the same object.

 

https://stackoverflow.com/questions/513832/how-do-i-compare-strings-in-java

[AlTech]

24 minutes ago, RockSolid1106 said:

snip

As @tikker said

When using == in Java or C#, the compiler is doing a check to see if something has the same memory address/is the same object  as the other item being compared/evaluated in the check.

 

Using the equals method checks the contents of the string or variable.

[trag1c]

The method equals() checks if the contents of an object (string in this case) are equal. The equality operator when used on non basic data types (==) checks if two references are the same. So when you create a string object you actually don't hold the object it self you hold a reference to it. A reference is nothing more than a number that shows where that object is located. 

 

So since you don't actually have the object you can't directly compare them with the == operator. You can only compare if references point to the same object. That's why we have the equals method so that you can compare the contents of objects.

[tikker]

25 minutes ago, RockSolid1106 said:

But, if I call the method by:

inarray(x, "hello"){

then the result is perfect(true).

But it wont work if I use:

inarray(x, y)

where String y is taken as input from the user with Scanner.

In addition, the reason for this behaviour is probably related to the interned strings explanation in that post. It's been a long time since I've done any Java, but when directly passing "hello" as

inarray(x, "hello")

the compiler may be smart enough to optimise it to a string constant, after which it ends up as one of those "interned" strings they refer to, in which case they are the same object. This doesn't happen if you pass it as a variable through Scanner.

[Franck]

1 hour ago, AluminiumTech said:

As @tikker said

When using == in Java or C#, the compiler is doing a check to see if something has the same memory address/is the same object  as the other item being compared/evaluated in the check.

 

Using the equals method checks the contents of the string or variable.

Watchout, this is only true for reference type object not value type.

 

On a side note I think everyone forgot to mention that Equals also perform check for reference type if the pointer is the same. If the pointer is the same it skips else it start comparing the values.

[bullipatty]

On 7/16/2021 at 7:14 PM, AluminiumTech said:

As @tikker said

When using == in Java or C#, the compiler is doing a check to see if something has the same memory address/is the same object  as the other item being compared/evaluated in the check.

 

Using the equals method checks the contents of the string or variable.

Careful, in C# the == operator can be overwritten, in fact is overwritten for strings, so comparing strings in C# with == compares also contents and not just references

[bullipatty]

On 7/16/2021 at 6:53 PM, RockSolid1106 said:

But, if I call the method by:

inarray(x, "hello"){

then the result is perfect(true).

by the way that is only true because JavaVM only instantiates strings once for equal literals, since it looks them up in the constant pool.
 

so the "hello"s from 

String x[]={"hello", "how", "are", "you"};

and

inarray(x, "hello")

will have the same reference, just as

"hello" == "hello"

is true, but

"hello" == nonConstantHelloString

is false

EDIT:
sorry @tikker I just noticed you basically already explained that, but yea that's the standard behavior