String s = “”; String s2 = someUserInputVariale.toLowercase(); // where the user entered in “” Something like that would cause s == s2 to evaluate to false. Lots of code sill create new Strings without exposing the call to new String().
This is generally (i.e., always) a bad idea. As you suspected, the comparison from 3 to 3.0000001 will indeed fail. What most people do, if an int-float comparison is really necessary, is pick some threshold of tolerance and go with that, like so: int x = 3; float y = 3.0; // some code here … Read more
In general, it’s not at all safe to compare the hashCode instead of using equals. When equals returns false, hashCode may return the same value, per the contract of hashCode.
The compiler does some optimizations in your case so that s1 and s2 are really the same object. You can work around that by using String s1 = new String( “Hello” ); String s2 = new String( “Hello” ); Then you have two distinct objects with the same text content.
Because the definition of “equals” for Arrays is that they refer to the same array. This is consistent with Java’s array equality, using Object.Equals, so it compares references. If you want to check pairwise elements, then use sameElements Array(‘a’,’b’).sameElements(Array(‘a’,’b’)) or deepEquals, which has been deprecated in 2.8, so instead use: Array(‘a’,’b’).deep.equals(Array(‘a’,’b’).deep) There’s a good Nabble … Read more
I found an article addressing your question: .NET Security Blog: Why == and the Equals Method Return Different Results for Floating Point Values According to IEC 60559:1989, two floating point numbers with values of NaN are never equal. However, according to the specification for the System.Object::Equals method, it’s desirable to override this method to provide … Read more
There’s a big difference between overloading == and overriding Equals. When you have the expression if (x == y) { The method that will be used to compare variables x and y is decided at compile time. This is operator overloading. The type used when declaring x and y is used to define which method … Read more
When you do System.out.println(“Object and literal compare by double equal to :: ” + s1 == s2); you are first concatenating the string “Object and literal compare by double equal to :: ” with the string s1, which will give “Object and literal compare by double equal to :: jai” then, you are checking if … Read more
This is because you’re lucky. The == operator in Java checks for reference equality: it returns true if the pointers are the same. It does not check for contents equality. Identical strings found at compile-time are collapsed into a single String instance, so it works with String literals, but not with strings generated at runtime. … Read more
The first example has a compile time constant “fg” that is referenced by two variables. Since this is a compile time constant, the two variables reference the one object. The references are equal. Read into the topic of string interning for more on this behavior. As a starter, consider: For example, if you assign the … Read more