String.equals versus ==
Use the string.equals(Object other)
function to compare strings, not the ==
operator.
The function checks the actual contents of the string, the ==
operator checks whether the references to the objects are equal. Note that string constants are usually "interned" such that two constants with the same value can actually be compared with ==
, but it's better not to rely on that.
if (usuario.equals(datos[0])) {
...
}
NB: the compare is done on 'usuario' because that's guaranteed non-null in your code, although you should still check that you've actually got some tokens in the datos
array otherwise you'll get an array-out-of-bounds exception.
String comparison : operator==() vs. Equals()
I like Equals()
because the available StringComparison
option is very useful.
The ==
and !=
operators are based on the value, so they are safe to use, even though String
is a reference type.
What use does the == operator have for String?
Imagine a thread-safe Queue<String>
acting as a communication channel between a producer thread and a consumer thread. It seems perfectly reasonable to use a special String
to indicate termination.
// Deliberate use of `new` to make sure JVM does not re-use a cached "EOT".
private static final String EOT = new String("EOT");
...
// Signal we're done.
queue.put(EOT);
// Meanwhile at the consumer end of the queue.
String got = queue.get();
if ( got == EOT ) {
// Tidy shutdown
}
note that this would be resilient to:
queue.put("EOT");
because "EOT" != EOT
even though "EOT".equals(EOT)
would be true
.
What is the difference between == and equals() in Java?
In general, the answer to your question is "yes", but...
.equals(...)
will only compare what it is written to compare, no more, no less.- If a class does not override the equals method, then it defaults to the
equals(Object o)
method of the closest parent class that has overridden this method. - If no parent classes have provided an override, then it defaults to the method from the ultimate parent class, Object, and so you're left with the
Object#equals(Object o)
method. Per the Object API this is the same as==
; that is, it returns true if and only if both variables refer to the same object, if their references are one and the same. Thus you will be testing for object equality and not functional equality. - Always remember to override
hashCode
if you overrideequals
so as not to "break the contract". As per the API, the result returned from thehashCode()
method for two objects must be the same if theirequals
methods show that they are equivalent. The converse is not necessarily true.
Java, what's the difference between == and equals
Yes, ==
with objects is a reference comparison* (checks if the operands are references to the same object), while equals
is whatever the class involved defines it to mean (within the requirements documented for equals
). Some classes define equals
as being the same as ==
, including Java's arrays. (Because they don't override the default implementation from Object.equals
, which uses ==
.)
If you want to compare Java arrays based on the equality of their contents, you use Arrays.equals
instead.
Your experiment would have worked if you used a class that defined equals
in a useful way, you were just unlucky picking arrays. It's a bit tricky to find a class in the JVM to use for this experiment, because so many either don't implement equals
(like arrays) or could be confusing because there are several immutable classes which may reuse instances (although not if you explicitly use new
; but I don't want to go down a path of having you use new
with something you probably shouldn't, like String
; more on that here). I'm going to give up on picking a good example and use the slightly old class SimpleDateFormat
:
DateFormat a = new SimpleDateFormat("yyyy-MM-dd");
DateFormat b = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(a == b ? "== Same" : "== Different");
System.out.println(a.equals(b) ? "equals Same" : "equals Different");
That outputs
== Different
equals Same
because SimpleDateFormat
defines equals
to check that the other object is also a SimpleDateFormat
with the same formatting.
Live example
Re your comment on the question:
I have someone the answer points but I only get the == part, if .equals is checking the content, how come the code didnt print "same" for the second if
Because equals
doesn't, necessarily, check content. It only does if a class overrides the default Object.equals
(which just uses ==
) and implements a content check. Arrays don't. (One could argue that they should have, but they don't.) Other classes, like SimpleDateFormat
and String
and Integer
and HashMap
do.
In essence: ==
is always a reference comparison. equals
may or may not be a contents comparison, depending on what class you're using it on.
So for instance, say we have this class:
class Example1
{
private int content;
Example1(int content) {
this.content = content;
}
public static void main (String[] args) throws java.lang.Exception
{
Example1 a = new Example1(42);
Example1 b = new Example1(42);
System.out.println(a == b ? "== Same" : "== Different");
System.out.println(a.equals(b) ? "equals Same" : "equals Different");
}
}
Since that class doesn't override equals
, you'll get the same answer ("Different") for both ==
and equals
. Live Example.
But if we override equals
to define what it would mean for two instances to be equal (in this case: because they have the same content):
class Example2
{
private int content;
Example2(int content) {
this.content = content;
}
@Override
public boolean equals(Object obj) {
if (obj == null || !obj.getClass().equals(this.getClass())) {
return false;
}
Example2 other = (Example2)obj;
return this.content == other.content;
}
@Override
public int hashCode() {
return this.content;
}
public static void main (String[] args) throws java.lang.Exception
{
Example2 a = new Example2(42);
Example2 b = new Example2(42);
System.out.println(a == b ? "== Same" : "== Different");
System.out.println(a.equals(b) ? "equals Same" : "equals Different");
}
}
Now equals
says two instances with the same content are the same, because the class defines what that means. Live Example. (Also note that when overriding equals
, you must override hashCode
, which is why I've done so above.)
* More generally, ==
tests if the values of its operands are the same. The value in the case of reference types is an object reference, and two object reference values are only the same when they refer to the same object are are only different when they refer to different objects (or one of them is null
; not referring to an object at all).
C# difference between == and Equals()
When ==
is used on an expression of type object
, it'll resolve to System.Object.ReferenceEquals
.
Equals
is just a virtual
method and behaves as such, so the overridden version will be used (which, for string
type compares the contents).
Difference between == operator and Equals() method in C#?
There are several things going on. Firstly, in this example:
string s1 = "a";
string s2 = "a";
Console.WriteLine(s1 == s2);
You claim that:
Both are different object reference.
That's not true due to string interning. s1
and s2
are references to the same object. The C# specification guarantees that - from section 2.4.4.5 of the C# 4 specification:
When two or more string literals that are equivalent according to the string equality operator (§7.10.7) appear in the same program, these string literals refer to the same string instance.
So in this particular case, you would still get "true" even if you printed object.ReferenceEquals(s1, s2)
, or if you made it use a true reference identity comparison with ==
:
object s1 = "a";
object s2 = "a";
Console.WriteLine(s1 == s2); // Still prints True due to string literal interning
However, even if these were references to separate objects, ==
is overloaded for string
. Overloading is a compile-time decision - the implementation to use depends on the compile-time types of the operands. So for example:
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a == b); // Uses string's implementation, prints True
object c = a;
object d = b;
Console.WriteLine(c == d); // Reference identity comparison, prints False
Compare that with object.Equals(object)
which is a virtual method. As it happens, String
overloads this method as well, but importantly it overrides it. So if we change our code to:
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a.Equals((object) b));
object c = a;
object d = b;
Console.WriteLine(c.Equals(d));
... then both method calls in the compiled code will simply be to object.Equals(object)
, but they'll still both print True because of polymorphism: the implementation in String
will be used.
Here's what a call to the overloaded method would look like:
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a.Equals(b)); // Calls string.Equals(string)
Related Topics
How to Get the Current Username in .Net Using C#
Best Practices For Catching and Re-Throwing .Net Exceptions
Make a Borderless Form Movable
Binding a Wpf Combobox to a Custom List
Simple Proof That Guid Is Not Unique
Is Task.Result the Same as .Getawaiter.Getresult()
Why Doesn't C# Allow Static Methods to Implement an Interface
How to Ensure That a Division of Integers Is Always Rounded Up
Deserializing Json Data to C# Using Json.Net
How to Check For Internet Connectivity Using .Net
Mssql Error 'The Underlying Provider Failed on Open'
How to Get Httpclient to Pass Credentials Along With the Request
Metadataexception: Unable to Load the Specified Metadata Resource