what is the advantage of string object as compared to string literal

i want to know where to use string object(in which scenario in my java code). ok i understood the diff btwn string literal and string object, but i want to know that since java has given us the power to make string object, there must be some reason, at some po开发者_开发百科int string object creation would be useful. so i want to know in which scenario can we prefer string object in place of string literal.

In most situations, you should use String literals to avoid creating unnecessary objects. This is actually Item 5: Avoid creating unnecessary objects of Effective Java:

Item 5: Avoid creating unnecessary objects

It is often appropriate to reuse a single object instead of creating a new functionally equivalent object each time it is needed. Reuse can be both faster and more stylish. An object can always be reused if it is immutable (Item 15). As an extreme example of what not to do, consider this statement:

String s = new String("stringette"); // DON'T DO THIS!

The statement creates a new String instance each time it is executed, and none of those object creations is necessary. The argument to the String constructor ("stringette") is itself a String instance, functionally identical to all of the objects created by the constructor. If this usage occurs in a loop or in a frequently invoked method, millions of String instances can be created needlessly. The improved version is simply the following:

String s = "stringette";

This version uses a single String instance, rather than creating a new one each time it is executed. Furthermore, it is guaranteed that the object will be reused by any other code running in the same virtual machine that happens to con- tain the same string literal [JLS, 3.10.5]

There is however one situation where you want to use the new String(String) constructor: when you want to force a substring to copy to a new underlying character array like in:

String tiny = new String(huge.substring(0, 10));

This will allow the big underlying char[] from the original huge String to be recycled by the GC.

Don't use a new String object if you know what the string is. For example:

String str = new String("foo"); // don't do this

You are thus creating an unnecessary object - once you have a String object created from the literal, and then you create another one, taking the first one as constructor argument.

Contrary to your question, there is a DISADVANTAGE of using a String object compared to String literal.

When you declare a String literal, String s = "foo", the compiler will check for an existing "foo" object on the heap and assign 's' to already existing "foo".

However, if you create a String object, String s = new String("foo"), an entirely new object will be created on the heap (even if there is already an existing "foo"). Strings being immutable this is totally unnecessary.

Here is good reference: http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html

String a = "ABC";
String b = new String("ABC");
String c = "ABC";

a == b // false
a == c // true

a.equals(b) // true
a.equals(c) // true

The point is that a & c point to the same "ABC" object (JVM magic). Using "new String" creates a new object each time. IMO, using string object is a disadvantage, not an advantage. However, as another poster said, string object is useful for converting byte[], char[], StringBuffer - if you need to do that.

String literals are converted to String objects, and as others pointed out, creating explicit String objects is unnecessary and inperformant, as it defeats String pooling.

However, there is one situation where you want to create new Strings explicitly: If you use just a small part of a very long String. String.substring() prevents the original String from getting GC'd, so you can save memory when you write

String s = new String(veryLongString.substring(1,3));

instead of

String s = veryLongString.substring(1,3);

literal strings are objects created in a String Pool and if they have the same value, they are referencing to the same object.

System.out.println("abc"=="abc"); // the output is true

Meanwhile, string object are real objects in memory and if they have the same value, there's no guarantee that they are referencing to the same object.

String a = new String("abc");
String b = new String("abc");
System.out.println(a==b); // the output is false