Reputation: 4236
String reference to the same object if you declare them without the use of "new" keyword as follows:
String s1 = "Some string";
String s2 = "Some string";
System.out.println(s1 == s2);
//prints true because
//they reference to the same object
However, contrary to what I expected doing this with array doesn't work:
char[] anArray = {'A', 'r', 'r', 'a', 'y'};
char[] oneArray = {'A', 'r', 'r', 'a', 'y'};
System.out.println("anArray == oneArray : " + (anArray == oneArray));
//prints false
We haven't explicitly mentioned that they are "new" arrays so why doesn't they reference to the same object on the heap?
Upvotes: 4
Views: 288
Reputation: 14257
Because arrays, unlike strings, are mutable. You usually don't want to change an object referenced from one variable through a supposedly independent object referenced by another variable.
char[] firstArray = {'A', 'r', 'r', 'a', 'y'};
char[] secondArray = {'A', 'r', 'r', 'a', 'y'};
firstArray[0] = 'X';
firstArray[1] = '-';
System.out.println(firstArray);
System.out.println(secondArray);
What would the output be if arrays were "interned" (i.e. if same literals pointed to same instances):
X-ray
X-ray
What actually happens: each literal creates a new instance:
X-ray
Array
Upvotes: 8
Reputation: 1075855
We haven't explicitly mentioned that they are "new" arrays so why doesn't they reference to the same object on the heap?
The real question here is: Why would they? It would be a real pain if, in the general case, equivalent objects were conflated by the JVM. Many classes have mutable instances; it's a bit of a problem if you have mutable instances (and arrays are mutable) and the JVM combines them into a single instance without your asking it to.
So by extension, the real question is: Why do your s1
and s2
refer to the same object?
The answer is: Because strings are a special case that the JDK and JVM have special handling for. Strings in Java were designed to be shared where possible, to save on memory size and churn, and so:
They're immutable (although you can break that via reflection if you try hard enough), and so sharing instances is acceptable (since you're not going to change them, officially).
Strings have the ability to be intern
ed, putting them in the JVM-managed string pool.
String literals are automatically intern
ed.
Your s1
and s2
wouldn't refer to the same string if it weren't for #3. Example (live copy):
String s1 = "Some string";
int a = 1;
String s2 = (a == 1 ? "Some" : "Foo") + " string";
System.out.println("Same? " + (s1 == s2));
System.out.println("Equivalent? " + s1.equals(s2));
Output:
Same? false Equivalent? true
The string generated by the expression and assigned to s2
can't be automatically intern
ed, so it ends up referring to a diffrent string object.
If you had a class with immutable instances, you could implement intern
for them as well. Strings are only special in that it's done for us by the Java specification and runtime.
Upvotes: 4
Reputation: 441
Strings in java are saved in a string table. When you create two of the exact same strings they will reference the same object. If you want to know if the value of a string is the same as another you will have to do String.Equals().
As Arrays are not saved in a array table they will reference different objects. of you want to know if the content of two arrays are the same you will have to itterate through the arrays with String.Equals().
Upvotes: 1
Reputation: 36304
System.out.println(s1 == s2);
returns true
only because we have a String constants pool that checks for Such literals (or interned Strings) and reuses the same Strings. Arrays were never designed for this.
Actually :
String s1 = new String("Some string");
String s2 = new String("Some string");
will give false
for System.out.println(s1 == s2);
.
Upvotes: 3