String s = new String(“xyz”). How many objects has been made after this line of code execute?

Question

The commonly agreed answer to this interview question is that two objects are created by the code. But I don\'t think so; I wrote some code to confirm.

publi         


        

Answer 1

Just because all your hash codes are the same does not mean that you are looking at the same object. Two objects are created. Let's break this down.

String s = new String(“xyz”);

In the part ' new String("xyz") ', an address is returned to the new string "xyz". When you say ' String s = ', this assigns that returned address to this object, so that they point to the same place, but the new string and string s are two seperate objects.

Answer 2

String s = new String("xyz");

how many objects has been created in above code?

Only one object has been created in above code, that's in heap memory.

not two object.....

If two objects are created, one is in a heap memory(new operator) and another one is in String constant pool(string literal), if your store below value using String literal ,

String s1 = "xyz";

it will not returns reference of object s in string constant pool. it will create new object in String Constant Pool as s1.

How?

we can check it by using == operator (s == s1) to check the reference type. If s is already stored in String Constant Pool it give the true, in this case output is false.

So the conclusion is one object is created in above code.

Answer 3

Two objects will be created for this:

String s = new String("abc");

One in the heap and the other in the "string constant pool" (SCP). The reference s will pointing to s always, and GC is not allowed in the SCP area, so all objects on SCP will be destroyed automatically at the time of JVM shutdown.

For example:

Here by using a heap object reference we are getting the corresponding SCP object reference by call of intern()

String s1 = new String("abc");
String s2 = s1.intern(); // SCP object reference
System.out.println(s1==s2); // false
String s3 = "abc";
System.out.println(s2==s3); //True s3 reference to SCP object here

Answer 4

Confused with what exactly happens after the new String("<>") is being called, I found this thread. Your hashcode comparison understanding is not technically correct though.

int hashCode() has been overriden in String class and it returns a value depending on the content of the String literal.

String s1 = new String("Hello"); String s2 = new String("Hello");

So s1.hashCode() = s2.hashCode() = anyStringOfContent_"Hello".hashCode()

**/** Cache the hash code for the string */
private int hash; // Default to 0
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            **h = 31 * h + val[i];**
        }
        hash = h;
    }
    return h;
}**

Now just to explain why is this done, you can actually read the Kathy Sierra book which has a great explanation why developers have done in this manner (basically any objects returning true to equals() method should return same hashCode() value).

Answer 5

There is a concept called string pool in Java. A string pool (string intern pool) is a special storage area in the Java heap. When a string is created and if the string already exists in the pool, the reference of the existing string will be returned, instead of creating a new object and returning its reference.

So String s = new String(“xyz”) it will create two objects.

1. The first object will be created in the Java permanent heap memory as part of the argument we are passing - "XYZ". And it will be created in the String Literal Pool.

2. The second object will be created within the Java heap memory - which will be created as part of the new operator.

Answer 6

There are so many random answers and so I am confident that my interviewer will also be not very sure :) :)

I researched a lot and found that hashcode is not the memory address and the variables while debugging don't give the memory address. So, those parameters might confuse.