Understanding explicit cast for String producing different results in c# and Java

Question

I wrote a same(..similar?) piece of code for Java 7 and C#(.net 3.5) and got a confusing output. Please help me in understanding this behavior: Java: ``` public class strTest { public static void main(String [] s) { String s1 = "abc"; String s2 = new String(new char[] {'a', 'b', 'c'}); System.out.println(s1 == s2); // false System.out.println(((Object)s1) == ((Object)s2)); // false System.out.println(s1.equals(s2)); // true } } ``` Output : false false true C#: ``` namespace ConsoleApplication1 { class Program2 { static void Main(string[] args) { String s1 = "abc"; String s2 = new String(new Char[] {'a', 'b', 'c'}); Console.WriteLine(s1 == s2); // true Console.WriteLine(((Object)s1) == ((Object)s2)); // false Console.WriteLine(s1.Equals(s2)); // true } } } ``` Output : True False True I am aware of concepts like String immutability and String pool but I guess I am missing the finer print. In java: Why did it create a new String object for s2 when it could have used the one which is re…

Accepted Answer

There are two aspects to your question: when objects are created, and how `==` comparisons work:

Object creation

In terms of interning ("pooling") - only constants are interned automatically. You can intern other strings using `Intern`/`intern`, but when you just call the string constructor that will always create a new string. (Well, except for one bizarre corner case in .NET, but we can ignore that for now.)

So in your code, `s1` and `s2` always refer to different objects.

Comparison

The cause of the difference is your use of `==`. C# supports user-defined operator overloading, and `String` overloads it like this:

```
public static bool operator ==(string x, string y)
```

which compares the contents of the string rather than the references. So when you have two operands of type `string`, `x == y` ends up doing an equality comparison rather than an identity comparison. That's why the first line of the C# output is `True`.

Java doesn't have this behaviour, which is why is prints `false`.

When the operand types are `Object`, both C# and Java will use reference equality, which is why the second line is false in both cases.

Understanding explicit cast for String producing different results in c# and Java

Solution

Problem