Clash Royale CLAN TAG

Strings are objects in Java, so why don't we use 'new' to create them?

We normally create objects using the new keyword, like:

new

Object obj = new Object();


Strings are objects, yet we do not use new to create them:

new

String str = "Hello World";


Why is this? Can I make a String with new?

new

new String(...)

14 Answers
14

In addition to what was already said, String literals [ie, Strings like "abcd" but not like new String("abcd")] in Java are interned - this means that every time you refer to "abcd", you get a reference to a single String instance, rather than a new one each time. So you will have:

"abcd"

new String("abcd")

String

String a = "abcd";
String b = "abcd";

a == b; //True


but if you had

String a = new String("abcd");
String b = new String("abcd");


then it's possible to have

a == b; // False


(and in case anyone needs reminding, always use .equals() to compare Strings; == tests for physical equality).

.equals()

==

Interning String literals is good because they are often used more than once. For example, consider the (contrived) code:

for (int i = 0; i < 10; i++) {
System.out.println("Next iteration");
}


If we didn't have interning of Strings, "Next iteration" would need to be instantiated 10 times, whereas now it will only be instantiated once.

Strings are "special" objects in Java. The Java designers wisely decided that Strings are used so often that they needed their own syntax as well as a caching strategy. When you declare a string by saying:

String myString = "something";


myString is a reference to String object with a value of "something". If you later declare:

String myOtherString = "something";


Java is smart enough to work out that myString and myOtherString are the same and will store them in a global String table as the same object. It relies on the fact that you can't modify Strings to do this. This lowers the amount of memory required and can make comparisons faster.

If, instead, you write

String myOtherString = new String("something");


Java will create a brand new object for you, distinct from the myString object.

String a = "abc"; // 1 Object: "abc" added to pool

String b = "abc"; // 0 Object: because it is already in the pool

String c = new String("abc"); // 1 Object

String d = new String("def"); // 1 Object + "def" is added to the Pool

String e = d.intern(); // (e==d) is "false" because e refers to the String in pool

String f = e.intern(); // (f==e) is "true"

//Total Objects: 4 ("abc", c, d, "def").


Hope this clears a few doubts. :)

It's a shortcut. It wasn't originally like that, but Java changed it.

This FAQ talks about it briefly. The Java Specification guide talks about it also. But I can't find it online.

String is subject to a couple of optimisations (for want of a better phrase). Note that String also has operator overloading (for the + operator) - unlike other objects. So it's very much a special case.

In Java, Strings are a special case, with many rules that apply only to Strings. The double quotes causes the compiler to create a String object. Since String objects are immutable, this allows the compiler to intern multiple strings, and build a larger string pool. Two identical String constants will always have the same object reference. If you don't want this to be the case, then you can use new String(""), and that will create a String object at runtime. The intern() method used to be common, to cause dynamically created strings to be checked against the string lookup table. Once a string in interned, the object reference will point to the canonical String instance.

String a = "foo";
String b = "foo";
System.out.println(a == b); // true
String c = new String(a);
System.out.println(a == c); // false
c = c.intern();
System.out.println(a == c); // true


When the classloader loads a class, all String constants are added to the String pool.

Syntactic sugar. The

String s = new String("ABC");


syntax is still available.

String small = new String(huge.substring(int, int));

char

huge

You can still use new String("string"), but it would be harder to create new strings without string literals ... you would have to use character arrays or bytes :-) String literals have one additional property: all same string literals from any class point to same string instance (they are interned).

new String("string")

There's almost no need to new a string as the literal (the characters in quotes) is already a String object created when the host class is loaded. It is perfectly legal to invoke methods on a literal and don, the main distinction is the convenience provided by literals. It would be a major pain and waste of tine if we had to create an array of chars and fill it char by char and them doing a new String(char array).

Feel free to create a new String with

String s = new String("I'm a new String");


The usual notation s = "new String"; is more or less a convenient shortcut - which should be used for performance reasons except for those pretty rare cases, where you really need Strings that qualify for the equation

s = "new String";

(string1.equals(string2)) && !(string1 == string2)


EDIT

In response to the comment: this was not intended to be an advise but just an only a direct response to the questioners thesis, that we do not use the 'new' keyword for Strings, which simply isn't true. Hope this edit (including the above) clarifies this a bit. BTW - there's a couple of good and much better answers to the above question on SO.

new String(...)

The literal pool contains any Strings that were created without using the keyword new.

new

There is a difference : String without new reference is stored in String literal pool and String with new says that they are in heap memory.

String with new are elsewhere in memory just like any other object.

Because String is an immutable class in java.

Now why it is immutable?
As String is immutable so it can be shared between multiple threads and we dont need to synchronize String operation externally.
As String is also used in class loading mechanism. So if String was mutable then java.io.writer could have been changed to abc.xyz.mywriter

TString obj1 = new TString("Jan Peter");
TString obj2 = new TString("Jan Peter");

if (obj1.Name == obj2.Name)
System.out.println("True");
else
System.out.println("False");


Output:

True

I created two separate objects, both have a field(ref) 'Name'. So even in this case "Jan Peter" is shared, if I understand the way java deals..

Don't create strings as objects. It slows down execution speed.
The new keyword complicates the code and can produce some unexpected results

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.