Java Comparison with == of Two Strings Is False

Wrong results while String comparison

To compare two strings u should use the method equals() or equalsIgnoreCase().

in your case:

if(it.next().equals(args[0]))

the operator == returns true if the two object are the same object, same address in memory.

Identical strings comparison gives me false

When you use the == operator in Java with objects, you are attempting to compare object references. That is, is this object handle pointing to the EXACT same object as this other object handle. Unless the strings are interned, this will not work.

Use String.equals(Object) instead:

Boolean equal = temp.equals(answers[i]);

Comparing two Strings using .equals() returns False, but their byte arrays are equal

Unequal strings do not have to produce different arrays when you do getBytes().

The result depends on the platform's default charset, but when I run the following code

String str1 = "?";
byte[] arr1 = str1.getBytes();
String str2 = "\u0080";
byte[] arr2 = str2.getBytes();
System.out.println(str1.equals(str2));
System.out.println(Arrays.equals(arr1, arr2));

the output I see is

false
true

I don't know exactly what is going on here, but it looks like certain control characters get treated as '?'.

The correct way to understand why strings are different is to compare the character arrays returned by toCharArray().

Android string compare is false

Use equals() to compare strings for content, not ==.

== will check if the objects are the same.

String foo = "foo";

if (foo == foo) {
    // same object, so true
}

String foo1 = "foo";
String foo2 = "foo";

if (foo1 == foo2) {
    // both are string literals set at compile time, so true
}

String foo1 = loadFoo1(); // imagine this returns "foo"
String foo2 = loadFoo2(); // imagine this also returns "foo"

if (foo1 == foo2) {
    // not the same object, and not string literals, so false
}

if (foo1.equals(foo2)) {
    // both strings hold "foo", so true
}

Comparison of two String return always false java

First of all, you should check if the values you are getting in those variables are correct, and the desired.

If they are correct, then, to delete the quotes you can use the String#replace method to replace all the double quotes with an empty:

var1.replace("\"", "");

Note that here you should escape the double quote \".

Note: This answer supposes that you are comparing the Strings correctly (using String#equals).

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 method String.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