Строка не может измениться. Но int, char может измениться

Ответ 1

Как сказал бзабхи, строки на Java неизменяемы. Это означает, что строковый объект никогда не изменится. Это не означает, что вы не можете изменять строковые переменные, просто вы не можете изменить представление базовой строки строки. для примера:

String str = "Hello";
str += " World!";

После выполнения этих строк str укажет на новую строку в памяти. Оригинальная строка "Hello" по-прежнему существует в памяти, но, скорее всего, ее не будет долго. Предполагая, что нет никаких смягчающих обстоятельств, ничто не будет указывать на исходную строку, так что это будет сбор мусора.

Я думаю, лучший способ поставить это было бы сказать, что при выполнении строки 2 примера создается новая строка в памяти из конкатенации исходной строки и добавляемой к ней строки. Переменная str, которая является только ссылкой на ячейку памяти, затем изменяется, чтобы указать на новую переменную, которая была только что создана.

Я не очень хорошо разбираюсь в этом вопросе, но, насколько я понимаю, это то, что происходит со всеми "непримитивными" значениями. Все, что в какой-то момент происходит от Object, следует этим правилам. Примитивные значения, такие как ints, bools, chars, floats и double, позволяют изменять фактическое значение в памяти. Итак, из этого:

int num = 5;
num += 2;

изменяется фактическое значение в памяти. Вместо того, чтобы создавать новый объект и изменять ссылку, этот образец кода просто изменит значение в памяти для переменной num.

Что касается того, почему это так, это просто дизайнерское решение создателей Java. Я уверен, что кто-то будет комментировать, почему это было сделано, но это не то, что я знаю.

Ответ 2

int и char тоже не могут измениться. Как и в случае с строками, вы можете поместить другое значение в одну и ту же переменную, но само целое не изменится. 3 всегда будет 3; вы не можете изменить его как 4.

Ответ 3

String - неизменный тип (значение внутри него не может измениться). То же самое верно для всех примитивных типов (булев, байтов, char, короткий, int, long, float и double).

int    x;
String s;

x = 1;
x = 2;
s = "hello";
s = "world";
x++; // x = x + 1;
x--; // x = x - 1;

Как вы можете видеть, вы ни в коем случае не можете изменить постоянное значение (1, 2, "привет", "мир" ), но вы можете изменить, где они указывают (если вы немного измените свой ум и говорите, что int переменные точки при постоянном значении int).

Ответ 4

Я не уверен, что можно показать (на примере), что строки не могут измениться. Но вы можете это подтвердить, прочитав раздел описания Javadoc для класса String, затем прочитав раздел методов и отметив, что нет методов, которые может изменить строку.

РЕДАКТИРОВАТЬ. Существует много причин, по которым Strings предназначены для неизменности в Java. Самая важная причина в том, что неизменяемые строки легче использовать правильно, чем изменчивые. И если по какой-то причине вам понадобится изменяемый эквивалент String, вы можете использовать класс StringBuilder (или StringBuffer).

Ответ 5

Также стоит отметить, что, поскольку строки являются неизменными, что если они передаются в метод, они не могут быть изменены внутри метода, а затем эти изменения видны вне области метода.

public void changeIt(String s) {
    // I can't do anything to s here that changes the value 
    // original string object passed into this method
} 

public void changeIt(SomeObject o) {
    // if SomeObject is mutable, I can do things to it that will 
    // be visible outside of this method call
} 

Ответ 6

Эта небольшая статья, возможно, может объяснить это лучше, чем я могу: http://www.jchq.net/tutorial/09_02Tut.htm

Ответ 7

Строки неизменяемы в java. Тем не менее вы все равно можете добавлять или добавлять значения к строкам. По значениям я имею в виду примитивные типы данных или другие строки.

Однако StringBuffer изменен, т.е. его можно изменить в памяти (новый блок памяти не нужно выделять), что делает его достаточно эффективным. Также рассмотрим следующий пример:

StringBuffer mystringbuffer = new StringBuffer(5000);

for (int i = 0; i<=1000; i++)
{
    mystringbuffer.append ( 'Number ' + i + '\n');
}

System.out.print (mystringbuffer);

Вместо того, чтобы создавать тысячу строк, мы создаем один объект (mystringbuffer), который может расширяться по длине. Мы также можем установить рекомендуемый начальный размер (в данном случае 5000 байт), что означает, что буфер не должен постоянно запрашивать память при добавлении к ней новой строки.

В то время как StringBuffer не будет повышать эффективность в каждой ситуации, если ваше приложение использует строки, которые растут по длине, это будет эффективно. Код также может быть более четким с помощью StringBuffer s, потому что метод append избавляет вас от необходимости использовать длинные операторы присваивания.