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

1. Может кто-нибудь уточнить, что подразумевается под неизменным ?
2. Почему Stringнеизменный?
3. Каковы преимущества / недостатки неизменяемых объектов?
4. Почему изменяемый объект, например, StringBuilderдолжен быть предпочтительнее, чем String и наоборот?

Хороший пример (на Java) будет очень полезен.

Неизменяемый означает, что, как только конструктор для объекта завершит выполнение, этот экземпляр не может быть изменен.

Это полезно, поскольку это означает, что вы можете передавать ссылки на объект, не беспокоясь о том, что кто-то еще изменит его содержимое. Особенно при работе с параллелизмом нет проблем с блокировкой объектов, которые никогда не меняются

например

class Foo
{
     private final String myvar;

     public Foo(final String initialValue)
     {
         this.myvar = initialValue;
     }

     public String getValue()
     {
         return this.myvar;
     }
}

Fooне нужно беспокоиться о том, что вызывающая сторона getValue()может изменить текст в строке.

Если вы представляете класс, похожий на Foo, но с членом, StringBuilderа не Stringкак член, вы можете видеть, что вызывающая сторона getValue()может изменять StringBuilderатрибут Fooэкземпляра.

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

Неизменяемый объект - это объект, в котором внутренние поля (или, по крайней мере, все внутренние поля, которые влияют на его внешнее поведение) не могут быть изменены.

Есть много преимуществ для неизменяемых строк:

Производительность: выполните следующую операцию:

String substring = fullstring.substring(x,y);

Базовый C для метода substring (), вероятно, выглядит примерно так:

// Assume string is stored like this:
struct String { char* characters; unsigned int length; };

// Passing pointers because Java is pass-by-reference
struct String* substring(struct String* in, unsigned int begin, unsigned int end)
{
    struct String* out = malloc(sizeof(struct String));
    out->characters = in->characters + begin;
    out->length = end - begin;
    return out;
}

Обратите внимание, что ни один из символов не должен быть скопирован! Если бы объект String был изменяемым (символы могли бы измениться позже), вам бы пришлось скопировать все символы, в противном случае изменения символов в подстроке будут отражены в другой строке позже.

Параллельность: если внутренняя структура неизменяемого объекта является действительной, она всегда будет действительной. Нет никаких шансов, что разные потоки могут создать недопустимое состояние в этом объекте. Следовательно, неизменяемые объекты являются потокобезопасными .

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

Однако есть и недостатки неизменности:

Производительность: Подожди, я думал, ты сказал, что производительность была неизменной! Ну, это иногда, но не всегда. Возьмите следующий код:

foo = foo.substring(0,4) + "a" + foo.substring(5);  // foo is a String
bar.replace(4,5,"a"); // bar is a StringBuilder

Обе строки заменяют четвертый символ буквой «а». Второй фрагмент кода не только более читабелен, но и быстрее. Посмотрите, как вам придется делать основной код для foo. Подстроки просты, но теперь, когда в пятой позиции уже есть символ и что-то еще может ссылаться на foo, вы не можете просто изменить его; Вы должны скопировать всю строку (конечно, некоторые из этих функций абстрагированы в функции в реальном базовом C, но суть здесь в том, чтобы показать код, который выполняется все в одном месте).

struct String* concatenate(struct String* first, struct String* second)
{
    struct String* new = malloc(sizeof(struct String));
    new->length = first->length + second->length;

    new->characters = malloc(new->length);

    int i;

    for(i = 0; i < first->length; i++)
        new->characters[i] = first->characters[i];

    for(; i - first->length < second->length; i++)
        new->characters[i] = second->characters[i - first->length];

    return new;
}

// The code that executes
struct String* astring;
char a = 'a';
astring->characters = &a;
astring->length = 1;
foo = concatenate(concatenate(slice(foo,0,4),astring),slice(foo,5,foo->length));

Обратите внимание, что concatenate вызывается дважды, что означает, что вся строка должна быть зациклена! Сравните это с кодом C для barоперации:

bar->characters[4] = 'a';

Операция с изменяемой строкой, очевидно, намного быстрее.

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

// This will have awful performance if you don't use mutable strings
String join(String[] strings, String separator)
{
    StringBuilder mutable;
    boolean first = true;

    for(int i = 0; i < strings.length; i++)
    {
        if(!first) first = false;
        else mutable.append(separator);

        mutable.append(strings[i]);
    }

    return mutable.toString();
}

Поскольку mutableобъект является локальной ссылкой, вам не нужно беспокоиться о безопасности параллелизма (когда-либо к нему обращается только один поток). А поскольку на него больше нигде нет ссылок, он размещается только в стеке, поэтому он освобождается после завершения вызова функции (вам не нужно беспокоиться о сборке мусора). И вы получаете все преимущества производительности как изменчивости, так и неизменности.

На самом деле String не является неизменным, если вы используете определение Википедии, предложенное выше.

Состояние String меняет пост-конструкцию. Взгляните на метод hashcode (). String кэширует значение хеш-кода в локальном поле, но не вычисляет его до первого вызова hashcode (). Эта ленивая оценка хеш-кода ставит String в интересное положение как неизменного объекта, состояние которого изменяется, но нельзя наблюдать, как он изменился без использования отражения.

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

Если состояние изменяется в неизменяемом объекте после того, как он был создан, но никто не может видеть его (без отражения), остается ли объект неизменным?

Неизменяемые объекты - это объекты, которые нельзя изменить программно. Они особенно хороши для многопоточных сред или других сред, где более чем один процесс может изменять (изменять) значения в объекте.

Однако, чтобы уточнить, StringBuilder на самом деле является изменяемым объектом, а не неизменным. Обычная строка Java является неизменной (это означает, что после ее создания вы не можете изменить базовую строку без изменения объекта).

Например, предположим, что у меня есть класс ColoredString, который имеет значение String и цвет String:

public class ColoredString {

    private String color;
    private String string;

    public ColoredString(String color, String string) {
        this.color  = color;
        this.string = string;
    }

    public String getColor()  { return this.color;  }
    public String getString() { return this.string; }

    public void setColor(String newColor) {
        this.color = newColor;
    }

}

В этом примере ColoredString называется изменяемой, поскольку вы можете изменить (изменить) одно из его ключевых свойств, не создавая новый класс ColoredString. Причина, по которой это может быть плохо, например, допустим, у вас есть приложение с графическим интерфейсом, которое имеет несколько потоков, и вы используете ColoredStrings для печати данных в окне. Если у вас есть экземпляр ColoredString, который был создан как

new ColoredString("Blue", "This is a blue string!");

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

blueString.setColor("Red");

Вы бы внезапно и, вероятно, неожиданно, теперь получили «Красную» строку, когда хотели «Голубую». Из-за этого неизменные объекты почти всегда предпочтительнее при передаче экземпляров объектов вокруг. Когда у вас есть случай, когда изменяемые объекты действительно необходимы, тогда вы обычно защищаете объект, только передавая копии из вашей конкретной области контроля.

Напомним, что в Java java.lang.String является неизменным объектом (его нельзя изменить после создания), а java.lang.StringBuilder является изменяемым объектом, поскольку его можно изменить без создания нового экземпляра.

1. В больших приложениях обычно строковые литералы занимают большие биты памяти. Таким образом, чтобы эффективно обрабатывать память, JVM выделяет область, называемую «пул констант строки». ( Обратите внимание, что в памяти даже строка без ссылки содержит символ char [], int для своей длины и другой для своего hashCode. Для числа напротив, требуется максимум восемь непосредственных байтов )
2. Когда complier сталкивается с литералом String, он проверяет пул, чтобы увидеть, существует ли уже идентичный литерал. И если он найден, ссылка на новый литерал направляется на существующую строку, и новый объект-литерал String не создается (существующая строка просто получает дополнительную ссылку).
3. Следовательно: изменяемость строк сохраняет память ...
4. Но когда любая из переменных меняет значение, на самом деле - это только их ссылка, а не значение в памяти (следовательно, оно не повлияет на другие переменные, ссылающиеся на него), как показано ниже ....

String s1 = "Старая строка";

//s1 variable, refers to string in memory
        reference                 |     MEMORY       |
        variables                 |                  |

           [s1]   --------------->|   "Old String"   |

Строка s2 = s1;

//s2 refers to same string as s1
                                  |                  |
           [s1]   --------------->|   "Old String"   |
           [s2]   ------------------------^

s1 = "Новая строка";

//s1 deletes reference to old string and points to the newly created one
           [s1]   -----|--------->|   "New String"   |
                       |          |                  |
                       |~~~~~~~~~X|   "Old String"   |
           [s2]   ------------------------^

Исходная строка «в памяти» не изменилась, но ссылочная переменная была изменена так, чтобы она ссылалась на новую строку. И если бы у нас не было s2, «Старая строка» все равно была бы в памяти, но мы не сможем получить к ней доступ ...

«неизменный» означает, что вы не можете изменить значение. Если у вас есть экземпляр класса String, любой вызываемый вами метод, который, кажется, изменяет значение, фактически создаст другую String.

String foo = "Hello";
foo.substring(3);
<-- foo here still has the same value "Hello"

Чтобы сохранить изменения, вы должны сделать что-то вроде этого foo = foo.sustring (3);

Неизменность и изменчивость могут быть смешными, когда вы работаете с коллекциями. Подумайте, что произойдет, если вы используете изменяемый объект в качестве ключа для карты, а затем измените значение (совет: подумайте об equalsи hashCode).

java.time

Это может быть немного поздно, но чтобы понять, что такое неизменный объект, рассмотрим следующий пример из нового Java 8 Date and Time API ( java.time ). Как вы, наверное, знаете, все объекты даты из Java 8 являются неизменяемыми, поэтому в следующем примере

LocalDate date = LocalDate.of(2014, 3, 18); 
date.plusYears(2);
System.out.println(date);

Вывод:

2014-03-18

Это печатает тот же год, что и начальная дата, потому что plusYears(2)возвращает новый объект, поэтому старая дата остается неизменной, потому что это неизменный объект. После создания вы не можете его изменить, а переменная даты все еще указывает на него.

Таким образом, этот пример кода должен захватывать и использовать новый объект, созданный и возвращенный этим вызовом plusYears.

LocalDate date = LocalDate.of(2014, 3, 18); 
LocalDate dateAfterTwoYears = date.plusYears(2);

date.toString ()… 2014-03-18

dateAfterTwoYears.toString ()… 2016-03-18

Мне очень нравится объяснение из SCJP Sun Certified Programmer для Java 5 Учебное пособие .

Чтобы повысить эффективность использования памяти Java, JVM выделяет специальную область памяти, которая называется «Строка константных пулов». Когда компилятор встречает литерал String, он проверяет пул, чтобы увидеть, существует ли уже идентичная строка. Если совпадение найдено, ссылка на новый литерал направляется на существующую строку, и новый объект литерала строки не создается.

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

Существуют три основные причины, по которым вы всегда можете использовать неизменяемые объекты, и все это поможет уменьшить количество ошибок, которые вы вносите в свой код:

• Намного легче рассуждать о том, как работает ваша программа, когда вы знаете, что состояние объекта не может быть изменено другим методом.
• Неизменяемые объекты автоматически поточнобезопасны (при условии, что они опубликованы безопасно), поэтому никогда не будут причиной этих трудных для обнаружения ошибок многопоточности
• Неизменяемые объекты всегда будут иметь одинаковый хэш-код, поэтому их можно использовать в качестве ключей в HashMap (или аналогичных). Если хеш-код элемента в хеш-таблице должен был измениться, запись в таблице будет фактически потеряна, так как попытки найти его в таблице приведут к тому, что он будет искать не в том месте. Это основная причина того, что объекты String являются неизменяемыми - они часто используются в качестве ключей HashMap.

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

Одно из значений связано с тем, как значение хранится в компьютере. Например, для строки .Net это означает, что строку в памяти нельзя изменить. Когда вы думаете, что изменяете ее, вы фактически создаете новую строка в памяти и указание существующей переменной (которая является просто указателем на фактическую коллекцию символов где-то еще) на новую строку.

String s1="Hi";
String s2=s1;
s1="Bye";

System.out.println(s2); //Hi  (if String was mutable output would be: Bye)
System.out.println(s1); //Bye

s1="Hi": объект s1был создан со значением «Привет» в нем.

s2=s1 : объект s2создается со ссылкой на объект s1.

s1="Bye": значение предыдущего s1объекта не изменяется, поскольку s1имеет тип String, а тип String является неизменяемым типом, вместо этого компилятор создает новый объект String со значением «Bye» и s1ссылкой на него. здесь, когда мы печатаем s2значение, результатом будет «Привет», а не «Пока», поскольку s2ссылка на предыдущий s1объект имеет значение «Привет».

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

String s1 = "  abc  ";
String s2 = s1.trim();

В приведенном выше коде строка s1 не изменилась, другой объект ( s2) был создан с помощью s1.

Неизменяемые просто означают неизменяемые или неизменяемые. После создания строкового объекта его данные или состояние не могут быть изменены.

Рассмотрим приведенный ниже пример,

class Testimmutablestring{  
  public static void main(String args[]){  
    String s="Future";  
    s.concat(" World");//concat() method appends the string at the end  
    System.out.println(s);//will print Future because strings are immutable objects  
  }  
 }  

Давайте разберемся с диаграммой ниже,

На этой диаграмме вы можете увидеть новый объект, созданный как «Мир будущего». Но не меняйте «Будущее». Because String is immutable, s, все еще обратитесь к "Будущему". Если вам нужно позвонить "Мир будущего",

String s="Future";  
s=s.concat(" World");  
System.out.println(s);//print Future World

Почему строковые объекты неизменяемы в Java?

Потому что Java использует концепцию строкового литерала. Предположим, есть 5 ссылочных переменных, все ссылаются на один объект «Будущее». Если одна ссылочная переменная изменит значение объекта, это повлияет на все ссылочные переменные. Вот почему строковые объекты неизменны в Java.

Однажды созданный, не может быть изменен. Рассмотрим класс, экземпляр которого может использоваться в качестве ключа для хеш-таблицы или аналогичного. Ознакомьтесь с рекомендациями по Java.

Неизменные объекты

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

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

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

Следующие подразделы берут класс, экземпляры которого являются изменяемыми, и получают класс с неизменяемыми экземплярами из него. При этом они дают общие правила для такого рода преобразования и демонстрируют некоторые преимущества неизменных объектов.

Источник

Поскольку принятый ответ не отвечает на все вопросы. Я вынужден дать ответ через 11 лет и 6 месяцев.

Может кто-нибудь уточнить, что подразумевается под неизменным?

Надеюсь, вы имели в виду неизменный объект (потому что мы могли бы подумать об неизменной ссылке ).

Объект является неизменным : если он создан, он всегда представляет одно и то же значение (не имеет метода, который изменяет значение).

Почему Stringнеизменный?

Соблюдайте приведенное выше определение, которое можно проверить, изучив исходный код Sting.java .

Каковы преимущества / недостатки неизменяемых объектов? неизменяемые типы:

• безопаснее от ошибок.

• легче понять.

• и более готов к изменениям.

Почему изменяемый объект, такой как StringBuilder, должен быть предпочтительнее, чем String и наоборот?

Сужение вопроса. Зачем нам нужен изменчивый StringBuilder в программировании? Обычно его используют для объединения большого количества строк, например:

String s = "";
for (int i = 0; i < n; ++i) {
    s = s + n;
}

Используя неизменяемые строки, это делает много временных копий - первое число строки («0») фактически копируется n раз в процессе построения финальной строки, второе число копируется n-1 раз, и так на. На самом деле копирование всего этого времени занимает O (n2), хотя мы объединяли только n элементов.

StringBuilder предназначен для минимизации этого копирования. Он использует простую, но умную внутреннюю структуру данных, чтобы вообще не копировать до самого конца, когда вы запрашиваете окончательную строку с вызовом toString ():

StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
  sb.append(String.valueOf(n));
}
String s = sb.toString();

Хорошая производительность - одна из причин, почему мы используем изменяемые объекты. Еще одно удобное совместное использование: две части вашей программы могут общаться более удобно, разделяя общую изменчивую структуру данных.

Больше можно найти здесь: https://web.mit.edu/6.005/www/fa15/classes/09-immutability/#useful_immutable_types

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

Язык программирования AD, который становится все более популярным, имеет понятие «неизменяемость» через ключевое слово «инвариант». Прочтите статью об этом доктора Добба - http://dobbscodetalk.com/index.php?option=com_myblog&show=Invariant-Strings.html&Itemid=29 . Это прекрасно объясняет проблему.