Какую знаешь особенность строк?

Особенности строк в Java

Строки в Java имеют множество уникальных и важных особенностей, которые отличают их от других типов данных. Рассмотрим ключевые характеристики.

1. Immutability (Неизменяемость)

Главная особенность строк в Java — они полностью неизменяемы. Один раз созданная строка не может быть изменена.

String str = "Hello";
str = str + " World"; // Создаётся новая строка
// str1 теперь указывает на новый объект, старый остаётся неизменным

String str2 = "Hello";
System.out.println(str == str2); // true — одна и та же строка в памяти

String str3 = new String("Hello");
System.out.println(str == str3); // false — разные объекты
System.out.println(str.equals(str3)); // true — одинаковое содержимое

Причины неизменяемости:

• Потокобезопасность
• Безопасность (в HashMaps и как keys)
• Оптимизация (кэширование)
• Упрощение отладки

2. String Pool (Пул строк)

Java хранит строковые литералы в специальной области памяти — String Pool.

// Строки-литералы идут в String Pool
String s1 = "hello";
String s2 = "hello";
String s3 = "hello";

System.out.println(s1 == s2); // true — одна и та же ссылка
System.out.println(s1 == s3); // true — одна и та же ссылка

// Строки через конструктор создаются в heap
String s4 = new String("hello");
String s5 = new String("hello");

System.out.println(s4 == s5); // false — разные объекты
System.out.println(s4.equals(s5)); // true — одинаковое содержимое

// intern() добавляет строку в пул
String s6 = new String("hello").intern();
System.out.println(s1 == s6); // true — теперь s6 из пула

3. Performance проблемы при конкатенации

// Плохо: каждое + создаёт новую строку
String result = "";
for (int i = 0; i < 10000; i++) {
    result += "value" + i; // 10000 новых объектов!
}
// Сложность: O(n²)

// Хорошо: StringBuilder переиспользует буфер
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append("value").append(i);
}
String result = sb.toString(); // O(n)

4. StringBuilder vs StringBuffer

// StringBuilder — потокоНЕбезопасный, но быстрый
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
String result = sb.toString();

// StringBuffer — потокобезопасный, медленнее
StringBuffer sbf = new StringBuffer();
sbf.append("Hello").append(" ").append("World");
String result = sbf.toString();

5. Сравнение строк

// Неправильно: использовать ==
String a = new String("hello");
String b = new String("hello");
if (a == b) { } // false! Это сравнивает ссылки, не содержимое

// Правильно: использовать equals()
if (a.equals(b)) { } // true — сравнивает содержимое

// Для игнорирования регистра
if (a.equalsIgnoreCase("HELLO")) { } // true

// compareTo() для сортировки
int comparison = a.compareTo(b); // 0 если равны, <0 или >0 иначе

6. String Interning

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");

System.out.println(s1 == s2); // true — из пула
System.out.println(s1 == s3); // false — s3 в heap

String s4 = s3.intern(); // Помещаем в пул
System.out.println(s1 == s4); // true — теперь из пула

7. Хеширование строк

// Строки кэшируют свой hash code
String str = "hello";
int hash1 = str.hashCode();
int hash2 = str.hashCode();

System.out.println(hash1 == hash2); // true — один раз вычислен

// Безопасное использование в HashMap
Map<String, Integer> map = new HashMap<>();
map.put("key1", 1);
map.put("key2", 2);
// Благодаря неизменяемости, hash не изменится

8. Regex и String методы

String text = "Hello World 123";

// matches() — проверка по regex
boolean isNumber = "123".matches("[0-9]+"); // true

// replaceAll() — замена по regex
String replaced = text.replaceAll("[0-9]", "X"); // "Hello World XXX"

// split() — разбиение по regex
String[] parts = text.split("\s+"); // ["Hello", "World", "123"]

// substring() — вырезание части
String sub = text.substring(0, 5); // "Hello"

9. String vs char[]

// Если нужна безопасность пароля, используй char[]
char[] password = "secret123".toCharArray();
// Потом очистить
java.util.Arrays.fill(password, '\0');

// String будет в памяти, пока не сборится мусор
String secretString = "secret123";
// Нельзя очистить явно

10. Method chaining с String

String result = "  hello world  "
    .trim() // "hello world"
    .toUpperCase() // "HELLO WORLD"
    .replace("WORLD", "JAVA"); // "HELLO JAVA"

System.out.println(result); // "HELLO JAVA"

11. Конкатенация vs format vs concat

String name = "Alice";
int age = 30;

// Конкатенация (+)
String s1 = "Name: " + name + ", Age: " + age;

// concat()
String s2 = "Name: ".concat(name).concat(", Age: ").concat(String.valueOf(age));

// format()
String s3 = String.format("Name: %s, Age: %d", name, age);

// StringJoiner
StringJoiner joiner = new StringJoiner(", ", "Name: ", "");
joiner.add(name);
String s4 = joiner.toString();

12. Intern для экономии памяти

// Если у вас много одинаковых строк, можно экономить память
List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    list.add(("prefix" + i).intern()); // Сохраняет память для дублей
}

Сравнение методов создания

Лучшие практики

1. Используйте == для сравнения с null:

if (str == null) { }

1. Используйте equals() для сравнения содержимого:

if (str.equals(other)) { }

1. Используйте StringBuilder для конкатенации:

StringBuilder sb = new StringBuilder();
for (...) {
    sb.append(...);
}

1. Кэшируйте результаты вычислений:

private static final String CONSTANT = "value";

1. Используйте isEmpty() вместо length() == 0:

if (str.isEmpty()) { }

1. Используйте trim() для удаления пробелов:

String clean = str.trim();

1. Безопасно сравнивайте:

if (Objects.equals(s1, s2)) { } // Handles nulls

Performance советы

// Плохо
String result = "";
result = result + "a"; // Создаёт новую строку каждый раз

// Хорошо
StringBuilder sb = new StringBuilder();
sb.append("a");

// Очень хорошо
String result = "a"; // Литерал в пуле

Вывод: Главные особенности строк в Java:

1. Неизменяемость — основа всех других свойств
2. String Pool — оптимизация для литералов
3. Потокобезопасность — благодаря immutability
4. Performance — нужно использовать StringBuilder для конкатенации
5. Правильное сравнение — equals() для содержимого, == для ссылок Понимание этих особенностей критично для написания эффективного Java кода.