Как происходит выделение памяти для строки (String) в Java?

А, вот эта тема про строки в Java — это вообще отдельная песня, блядь! Ну сидит такой разработчик, думает: "О, строка, что тут может быть сложного?" А потом бац — утечка памяти, производительность хуже некуда, и он сидит, чешет репу: "Какого хуя?". Давай разжёвывать, как есть.

Смотри, есть у нас два главных места, где строки могут болтаться: куча (heap) и пул строк (String Pool). Пул — это такая хитрая затея внутри кучи, где лежат уникальные строки-литералы, чтобы не плодить сущностей, как говорится.

1. Создание через литерал — самый простой путь, но не дурак.

String s1 = "Hello";

Тут Java ведёт себя, как хитрая жопа. Она сначала лезет в String Pool и ищет: "А нет ли у нас уже такого 'Hello'?". Если нашла — просто даёт ссылку на старый объект, экономит память. Не нашла — создаёт новый в пуле и ссылку туда же кладёт. Всё, чтобы не клонировать одно и то же до овердохуища.

2. А теперь держись за стул: создание через new.

String s2 = new String("Hello");

Вот тут начинается магия, блядь. Несмотря на то, что литерал "Hello" уже, возможно, плавает в пуле, эта команда всегда создаёт новый, отдельный объект в обычной куче. Зачем? Ну, потому что new есть new, ёпта! Он же не может просто так взять и не создать объект, это же его работа! Хотя внутри он, конечно, использует тот самый литерал из пула для инициализации. Но s2 будет смотреть на свой собственный, новый кусок памяти. Вот такие пироги.

3. А если мы строку пытаемся менять?

String s3 = s1 + " World"; // "Hello World"

А вот тут, друг, помни: строки в Java — неизменяемые (immutable). Это священная корова, блядь! Любая операция, которая якобы меняет строку — конкатенация, substring (в старых версиях Java вообще ад творился) — на деле создаёт абсолютно новый объект String в куче. Старый остаётся как был. Поэтому если ты в цикле накручиваешь строку через +, ты по сути устраиваешь мусорную свалку из временных объектов. Компилятор иногда умный, литералы склеит заранее, но на него надейся, а сам не плошай.

Так что же делать, если нужно часто менять?

• StringBuilder — твой быстрый друг, не потокобезопасный, но зато шустрый. Для большинства случаев — то, что надо.
• StringBuffer — его старший брат, который всё умеет так же, но потоки не сломает. Чуть медленнее из-за синхронизации.

И ещё два важных нюанса, чтоб не облажаться:

• Сравнение: s1.equals(s2) — сравнивает, что внутри, по символам. s1 == s2 — сравнивает, ссылаются ли они на один и тот же объект в памяти. Перепутаешь — будешь долго искать баг, волнение ебать.
• Метод intern(): Это ручное управление пулом. Вызываешь s2.intern() — и Java запихивает строку из s2 в пул (если её там ещё нет) и возвращает ссылку на неё из пула. Мощный инструмент, но без фанатизма, а то можно и память перегрузить.

Короче, строка в Java — это вам не хуй с горы, это целая философия. Понял принцип — и половина проблем с памятью и производительностью сама рассосётся.