This question already has answers here:
How do I compare strings in Java?
(23 answers)
Closed 9 years ago.
Can you explain me why do I have "false" output? If I understand correctly, references point to the same object!
public class mainC {
String str1,str2;
public static void main(String [] args){
mainC m=new mainC();
m.str1="a";
m.str2="b";
System.out.print("m.str1 == m.str2: "+m.str1 == m.str2);
}
}
Thank you.
m.str1 and m.str2 point to different String objects, which is why you get false. The == compares str1 and str2, not m.
Side note: Now, if you had:
m.str1="a";
m.str2="a"; // Same series of characters, e.g., "a"
...you'd be getting true, but it would be misleading. == compares object references. So you can have two different String objects that have the same characters in them, but they would not be == to each other (in fact, that's quite common). To compare strings, you use equals. The reason my example above returns true is that both strings are initialized pointing to literals, and String literals in Java are intern'd by default, so that literals with the same characters are mapped to the same object.
A string in Java is implemented as a reference type and not a value type. Since this is the case, their pointers in memory aren't equal. To get around this, you can use their equals function to compare them.
Related
This question already has answers here:
Comparing strings with == which are declared final in Java
(6 answers)
How do I compare strings in Java?
(23 answers)
Closed 4 years ago.
Please follow the code below:
String s="helloworld";
String ss="hello";
String sss=ss+"world";
System.out.print(sss==s);
The output is false. Don't they get checked with the string pool rule for String? And what if we make them final?
A little explanation of internal working will help. Thanks in Advance.
String literals points to the same location if the content of them is same, that's what I got from different sources, am I right? If yes, then what's happening here? I'm a little confused about it.
EDIT:-
I think I didn't phrase it correctly. Let me rephrase it a little(Sorry for earlier attempt):-
String ss="hello";
System.out.print(ss+"world"=="helloworld");
This returns false. However these are String literals and as I have read they don't create two different objects for same value. They are just reference to a same value. Here, "helloworld" is the value for both sides of ==. I hope that I'm able to communicate it well.
Because String is an object, it is comparing that the two objects are the same with ==, which will equate to false.
Using the object ss to concat into sss will not make s = sss.
If you set ss to s, then using == will equate to true since they are now the same object.
If you set a second String object with a string literal, using == will equate the true.
If you use the String object's function .equals(String), you will find that it equates to true.
If you compare two string literals, i.e. "helloworld" == "helloworld" or "helloworld" == "hello" + "world", these will also equate to true.
As lealceldeiro pointed out, strings should always be compared with .equals().
EDIT
A good thing to look at is this answer. It has good references and explanation.
Other resources:
JournalDev
Baeldung
This question already has answers here:
Comparing strings with == which are declared final in Java
(6 answers)
Closed 7 years ago.
I was doing some java tests to practice and I came across a question that I don't understand. I created a small program to test it:
The question was to say what would be the output of System.out.println(ab==abc);
I answered 'true' thinking that String literals are not objects, so the can be seen as a kind of primitive type so the comparation == would compare the values and nothing to do with references. But actually the answer in "false";
Then I did this test and I even print the outputs and as you can see ab and abc are exactly the same, however the comparation is returning false , but if I do the comparation directly without doing any concatenation (as I did at the end of the program) the comparation is returning true. So it seems clear the reason has to be with the concatenation, I know that Strings are inmutable so when concatenating then we are getting another String literal with exactly same value.
Can someone please explain me who't going on here?
For those telling me that String literals are objects, why then this code returns true?
String p="meowdeal";
String o="meowdeal";
System.out.println(o == p);
//output true
Of course I would understand that this code
String o=new String("meowdeal");
String p=new String("meowdeal");
System.out.println(o==p);
returns false because in that case they are really objects but not when they are String literal, am I right?
Thank you for your time
public static void main(String ads[] ){
String a="meow";
String ab=a+"deal";
String abc="meowdeal";
System.out.println(a);
System.out.println(ab);
System.out.println(abc);
System.out.println(ab == abc);
//output
//meow
//meowdeal
//meowdeal
//false
String p="meowdeal";
String o="meowdeal";
System.out.println(o == p);
//output
//true
}
ab and abc are objects so .equals() is used to see if they have the same contents and == is used to see if they are the same object.
The last test is only true due to a compile optimization known as string interning
(Your second comment below is correct)
In Java you should compare Strings with .equals(String s) because the '==' returns only true if it's the exact same String in the memory and doesn't compare if the content is the same. In your first example you've got two different strings in your memory. In the second, java saw, that these would be the same and allocated only space for one string and your p and o are only a reference to the same object.
String literals are Objects. User equals method instead of == operator.
Just to explain what happen here,
String p="meowdeal"; //creates "meowdeal" in heap
String o="meowdeal"; // o also refer to same object in heap.
This is called pooling of String. Since both refer to same memory location == operator returns true.
This question already has answers here:
How do I compare strings in Java?
(23 answers)
Closed 8 years ago.
String str1 = "abc:5";
String str2 = "abc:" + str1.length();
String str3 = "abc:" + 5;
System.out.println(str1==str2);
System.out.println(str1==str3);
Output of the program is :
false
true
But I don't understand why?
== operator will compare reference only
.equals() will compare the values.
in your case
str1==str2 // compares the two references, which are different.
had it been, str1.equals(str2), it would have compared the values, which will return true
The “==” operator
In Java, when the “==” operator is used to compare 2 objects, it checks to see if the objects refer to the same place in memory. In other words, it checks to see if the 2 object names are basically references to the same memory location.The “==” operator compares the objects’ location(s) in memory
The “equals” method
The Java String class actually overrides the default equals() implementation in the Object class – and it overrides the method so that it checks only the values of the strings, not their locations in memory.
Here str1 = "abc:5"; is located in constant pool of string and str2 is concatenated with 2 different object with new operator. So both str1 and str2 are referring to different object. That's the reason it is showing false.
The == operator is used for only reference variables in java. For example if you are comparing characters a1 and a2 you can use the == operator because the char type is highlighted in most IDEs in Java. To check if two Strings are equal to each other you can use .equals()or .equalsIgnoreCase() to compare the Strings. This is because Strings are objects, not primitives, and require their own method in the class to test if Strings are the same.
For the first System.out.println(); statement, you would use System.out.println(str1.equals(str2)); or System.out.println(str1.equalsIgnoreCase(str2));.
For the second System.out.println(); statement, you would use System.out.println(str1.equals(str3)); or System.out.println(str1.equalsIgnoreCase(str3));.
This question already has answers here:
How do I compare strings in Java?
(23 answers)
Closed 8 years ago.
What is "==" in Java ? Why can i only compare numerical data type with it and characters can be compared. But not the string data types. What does it provide when i compare two strings?
== compares reference equality: it returns true if its operands have the same value on the stack. (that is, they are either the same numerical quantity or they point to the same object)
Strings are objects, so here we're asking whether they point to the same object on the stack. This will be true if we're talking about String literals defined in code:
If we have
String s1 = "Hello";
String s2 = "Hello";
then s1 == s2 => true
However, if one of the Strings is obtained by some run-time process, for example user input, then it will not be reference-identical, even if the contents of the two Strings are the same.
In Java == compare reference two reference value. If left side reference equals to right side reference will return true else false.
When you come to compare String(objects) you should use equals()
Why?
String a= new String("a");
String b= new String("a");
Here a and b are same by value but they have two different reference.
If you compare to objects (strings are objects) you will compare the reference of both objects.
The '==' operator in Java is used to compare similar variables (like an integer and another integer). For an over-complicated reason, Strings are considered 'Object' type variables. To compare strings use the operator variableString.equals(otherString);
This question already has answers here:
How do I compare strings in Java?
(23 answers)
Closed 8 years ago.
I understand and know why you typically have to use == to compare strings in java, but for some reason I am able to do it in Eclipse. My code is
Code:
public class Test{
public static void main(String [] args){
String str1 = "string";
if(str1 == "string"){
System.out.println("wtf");
}
}
}
Why does this print "wtf" yet using javac from command line does not?
Eclipse allows you to compare references because it is a legitimate comparison. Just probably not the one you really want.
Because of String interning it will sometimes appear to work, but you should not rely upon it unless you know the strings you're comparing have been interned. The correct way to compare Strings for equal value is to use .equals.
It allow cause it probably faster to compare two address than comparing 2 string (but use it with caution, you probably never have to compare two String address).
It is sometime usefull to compare Object memories address, and as long as String is an object, eclipse allow you to compare using ==