What is the difference between strings allocated using new operator & without new operator in java J2ME?

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.

1. 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.

2. 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";