Кстати есть небольшая разница в
String s = "123";
и
String s = new String("123");

Например

    String s1 = "123";
    String s2 = "123";
    String s3 = new String("123");
    System.out.println(s1 == s2);
    System.out.println(s1 == s3);

Результат
true
false

Здравствуйте, dshe, Вы писали:


D>Может быть, я опять покажусь педантичным, но в цитируемом источнике есть неточности. Во второй строке новый объект не создается. К этому моменту он уже имеется созданный и лежит в пуле строк. А в пул строк он попадает в момент загрузки класса (если его там еще не было). В доказательство справедливости этого можно выполнить такой код
D>

D>String a, b;
D>a = "hello";
D>b = "hello";
D>System.out.println(a == b);
D>

D>Если бы всякий раз, когда встречается строковый литерал, создавался бы новый объект, результатом выполнения данного кода был бы вывод false. Тем не менее код выводит true, а это означает, что новый объект не создается.

Все там правильно. Цитирую дальше:
----------------------------------
Поскольку каждый строковый литерал порождает новый объект, что есть очень
ресурсоемкая операция в Java, то зачастую компилятор стремится оптимизировать эту
работу.

Во-первых, если используются несколько литералов с одинаковым значением, то для всех
них будет создан один и тот же объект.

Здравствуйте, zubr, Вы писали:

Z>Здравствуйте, LearnJava, Вы писали:
Z>

Z>String a = new String("A");
Z>String b = a; //b указывает на "A"
Z>b = "B"; //b указывает новую строку "B"
Z>

LJ>>Имеется код:
LJ>>

LJ>>public class TestConsole
LJ>>{
LJ>>  public static void main(String[] args)
LJ>>  {    
LJ>>    Foo ob = new Foo();
LJ>>//в следующей строке получаем указатель на "123"
LJ>>    String str = ob.getString();
LJ>>    System.out.println(ob.getString());
LJ>>//здесь мы меняем указатель внешней переменной - создаем новый String объект! при этом ob.m_Str указывает на старый объект.
LJ>>    str = "321";
LJ>>    System.out.println(ob.getString());
LJ>>  }   
LJ>>}
LJ>>

Z>P.S.: смотрим в JLS

вроде правильно говоришь, только я бы тебе минус поставил бы. надо человеку объяснить как идет передача ссылочных переменных.

P.S.: смотрим в JLS

Дело в том что спецификация JVM гарантирует что для всех равных константых строк будет использоваться один и тот же обьект.
Поэтому в первом случае результат сравнения ссылок true.
Во втором же создается новый обьект. в котором как видно из кода содержится либо такой же массив байт.
Либо новый массив с таким же как и у исходной строки содержимым.
Т.е при использовании

String str1 = "bla";
String str2 = "bla";

обьект один, а при использовании

String str1 = "bla";
String str2 = new String(str1);

обьектов два.
впрочем при сравнении их методом equals результат будет true.

   /**
     * Initializes a newly created <code>String</code> object so that it
     * represents the same sequence of characters as the argument; in other
     * words, the newly created string is a copy of the argument string. Unless 
     * an explicit copy of <code>original</code> is needed, use of this 
     * constructor is unnecessary since Strings are immutable. 
     *
     * @param   original   a <code>String</code>.
     */
    public String(String original) {
     this.count = original.count;
     if (original.value.length > this.count) {
         // The array representing the String is bigger than the new
         // String itself.  Perhaps this constructor is being called
         // in order to trim the baggage, so make a copy of the array.
         this.value = new char[this.count];
         System.arraycopy(original.value, original.offset,
                  this.value, 0, this.count);
     } else {
         // The array representing the String is the same
          // size as the String, so no point in making a copy.
         this.value = original.value;
     }
    }