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.
Which one is better string.Equals() or == , in case of checking the equality of two strings in c#?
I would suggest string.Equals
as equality(==
) operator internally use string.Equals
first check for references equality and then for value equality, hence it would be better to use string.Equals
than ==
in case of string variables.
String.Equals vs String.Compare vs == in Action. Explanation needed
Why does the first comparison (string.compare) work and the other two
comparison methods does not work in THIS PARTICULAR CASE
There are invisible characters (particularly, a Left-to-Right mark (Thanks @MatthewWatson)) in your code. You can view them with any hex editor:
This is over-looked by string.Compare
, while it isn't with string.Equals
. You can see it in the docs:
Notes to Callers:
Character sets include ignorable characters. The
Compare(String, String) method does not consider such characters when
it performs a culture-sensitive comparison. For example, if the
following code is run on the .NET Framework 4 or later, a
culture-sensitive comparison of "animal" with "ani-mal" (using a soft
hyphen, or U+00AD) indicates that the two strings are equivalent.
==' vs string.equals c# .net
string == string
is entirely the same as String.Equals
. This is the exact code (from Reflector):
public static bool operator ==(string a, string b)
{
return Equals(a, b); // Is String.Equals as this method is inside String
}
What are the benefits of String .equals(otherString)
That saves you from a NullPointerException.
That is Yoda Condition used to solve unsafe null behavior.
In programming jargon, Yoda Conditions (also called Yoda Notation) is a programming style where the two parts of an expression are reversed in a conditional statement.
Advantage is
Swapping the two conditional values does not change the behavior of the program. A common mistake is to accidentally assign a value instead of writing a conditional statement.
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.
Equals() vs Static string.Equals()
According to MSDN, the string.Equals
method
Determines whether two String objects have the same value.
This is why string.equals(s1,s2);
would always return false in your case, and if both s1
and s2
are null or have the same value would return true.
Also another thing is that if i type the string.equals() with a
capital S in the string like this String.equals() then it wll still
run the same as if i had it lower case but the IDE (visual studio
2015) will tell me that it can be simplified and when i simplify it it
turn it to a lower case s. Why is that?
The string
is a C# primitive, while System.String
or simple String
is the corresponding FCL (Framework Class Library) type. It is the same like int
and Int32
, where int
is a C# primitive and Int32
is the corresponding FLC type.
How do I compare strings in Java?
==
tests for reference equality (whether they are the same object).
.equals()
tests for value equality (whether they are logically "equal").
Objects.equals() checks for null
before calling .equals()
so you don't have to (available as of JDK7, also available in Guava).
Consequently, if you want to test whether two strings have the same value you will probably want to use Objects.equals()
.
// These two have the same value
new String("test").equals("test") // --> true
// ... but they are not the same object
new String("test") == "test" // --> false
// ... neither are these
new String("test") == new String("test") // --> false
// ... but these are because literals are interned by
// the compiler and thus refer to the same object
"test" == "test" // --> true
// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true
// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true
You almost always want to use Objects.equals()
. In the rare situation where you know you're dealing with interned strings, you can use ==
.
From JLS 3.10.5. String Literals:
Moreover, a string literal always refers to the same instance of class
String
. This is because string literals - or, more generally, strings that are the values of constant expressions (§15.28) - are "interned" so as to share unique instances, using the methodString.intern
.
Similar examples can also be found in JLS 3.10.5-1.
Other Methods To Consider
String.equalsIgnoreCase() value equality that ignores case. Beware, however, that this method can have unexpected results in various locale-related cases, see this question.
String.contentEquals() compares the content of the String
with the content of any CharSequence
(available since Java 1.5). Saves you from having to turn your StringBuffer, etc into a String before doing the equality comparison, but leaves the null checking to you.
Related Topics
How to Get the Color from a Hexadecimal Color Code Using .Net
Problem With Converting Int to String in Linq to Entities
Dpi Awareness - Unaware in One Release, System Aware in the Other
How to Get C# Enum Description from Value
Why and How to Avoid Event Handler Memory Leaks
Ipc Mechanisms in C# - Usage and Best Practices
How to Add a Timer to a C# Console Application
Linq to Entities Case Sensitive Comparison
Unit Testing Private Methods in C#
How to Increase the Max Upload File Size in Asp.Net
Visual Studio Publish Project into One Simple Installer
Deserializing Json to .Net Object Using Newtonsoft (Or Linq to Json Maybe)
Difference in Months Between Two Dates