what is the Difference bet开发者_开发知识库ween
String str=new String("Thamilan");
and
String str="Thamilan";
in java J2ME.
In first case new object will be created always, in second case object from a string pool can be reused. Read more about String pool here: What is String pool?
The difference is that the new String creates a new object with the same value as the literal passed in:
String s = "abc";
String t = new String("abc");
System.out.println(s==t); //false
String u = "abc";
String v = "abc";
System.out.println(u==v); //true
This is because the literal are always from the internal pool.
You might want to look at the intern method - here is its description:
Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class String. When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned. It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true. All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification
An answer from Java String declaration
String str = new String("SOME")
always create a new object on the heap
String str="SOME"
uses the String pool
Try this small example:
String s1 = new String("hello");
String s2 = "hello";
String s3 = "hello";
System.err.println(s1 == s2);
System.err.println(s2 == s3);
To avoid creating unnecesary objects on the heap use the second form.
String t = new String("abc");
statement 1 will create an object on Heap, and additionally places an string literal in the pool having the same value.
The reference variable t will refer to the object on the heap.
String t = "abc";
However statement 2 will only create an object in string constant pool if the object having same value is not present in the pool and t will refer the object placed in the string constant pool.
In 'Effective Java' it says never to write code like this:
String s = new String("string");
Because it creates unnecessary String objects. But instead it should be written like this:
String s = "string";
精彩评论