Why new keyword not needed for String

I am new in java.

In java, String is a class.But we do not have to use new keyword to create an object of class String where as new is used for creating objects for other classes.

I have heard about Wrapper classes like Integer,Double which are similar to this. But String is not Wrapper,isn't it?

Actually what is happening when i use

     String message = "Hai";

?? How it is different from

String message = new String("Hai");

Here is message a reference variable or something else?? Are there other classes which do not require new to create object ??

Solution 1:

With the following line you are not creating a new String object in the heap but reusing a string literal (if already available):

String message = "Hai";

"Hai" is a string literal in the string literal pool. Since, strings are immutable, they are reusable so they are pooled in the string literal pool by the JVM. And this is the recommended way, because you are reusing it.

But, with the following you are actually creating a new object (in the heap):

String message = new String("Hai");

new String("Hai") is a new String object. In this case, even if the literal "Hai" was already in the string literal pool, a new object is created. This is not recommended because chances are that you might end with more than one String objects with the same value.

Also see this post: Questions about Java's String pool

Are there other classes which do not require new to create object ??

Actually, you can not create any object in Java without using the keyword new.

e.g.

Integer i = 1;

Does, not mean that the Integer object is created without using new. It's just not required for us to use the new keyword explicitly. But under the hood, if the Integer object with value 1 does not already exist in cache (Integer objects are cached by JVM), new keyword will be used to create it.

Solution 2:

The Java language specification allows for representation of a string as a literal. You can consider it a shortcut initialization for a String that has one important side-effect that is different from regular initialization via new

String literals are all interned, which means that they are constant values stored by the Java runtime and can be shared across multiple classes. For example:

class MainClass (
    public String test = "hello";
}

class OtherClass {
   public String another = "hello";

   public OtherClass() {
       MainClass main = new MainClass();
       System.out.println(main.test == another);
   }
}

Would print out "true" since, both String instances actually point to the same object. This would not be the case if you initialize the strings via the new keyword.

Solution 3:

String and Integer creation are different.

String s = "Test";

Here the '=' operator is overloaded for string. So is the '+' operator in "some"+"things". Where as,

Integer i = 2;

Until Java 5.0 this is compile time error; you cant assign primitive to its wrapper. But from Java 5.0 this is called auto-boxing where primitives are auto promoted to their wrappers wherever required.

String h1 = "hi";

will be different from

String h2 = new String("hi");

The reason is that the JVM maintains a string table for all string literals. so there will be an entry in the table for "hi" , say its address is 1000.

But when you explicitly create a string object, new object will be created, say its address is 2000. Now the new object will point to the entry in the string table which is 1000.

Hence when you say

h1 == h2

it compares

1000 == 2000

So it is false

Why new keyword not needed for String

Solution 1:

Solution 2:

Solution 3:

Related

Recent Posts