Что такое String?

Что такое String

String — это встроенный класс в Java (java.lang.String), который представляет неизменяемую последовательность символов. Это один из наиболее часто используемых классов в языке и имеет специальную поддержку в JVM.

Ключевые характеристики

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

Одна из главных особенностей String — его нельзя изменить после создания:

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

String s1 = "Java";
String s2 = s1.toUpperCase(); // Создаётся новый объект "JAVA"
// s1 остаётся "Java"

Это гарантирует потокобезопасность и позволяет использовать String в качестве ключей в HashMap.

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

Java поддерживает специальный пул строк в памяти для оптимизации:

String s1 = "Hello";      // Создаётся новый объект в пуле
String s2 = "Hello";      // Ссылается на тот же объект из пула
String s3 = new String("Hello"); // Создаётся новый объект в heap

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

Строковые литералы (в двойных кавычках) помещаются в пул автоматически при компиляции.

3. Хранение в памяти

В Java 9+ String хранится как массив байт с оптимизацией для памяти:

// До Java 9
private final char[] value;

// С Java 9+
private final byte[] value;
private final byte coder;  // 0 = LATIN1, 1 = UTF-16

Создание String

// 1. String литерал
String s1 = "Hello World";

// 2. Конструктор с другой строкой
String s2 = new String("Hello World");

// 3. Из массива символов
char[] chars = {'H', 'e', 'l', 'l', 'o'};
String s3 = new String(chars);

// 4. Из массива байт
byte[] bytes = "Hello".getBytes();
String s4 = new String(bytes);

// 5. Повторение символа
String s5 = "a".repeat(5); // "aaaaa" (Java 11+)

Основные методы String

String str = "Hello World";

// Информация о строке
int len = str.length();           // 11
char ch = str.charAt(0);          // 'H'
int index = str.indexOf('o');     // 4

// Подстроки
String sub = str.substring(0, 5); // "Hello"

// Сравнение
boolean eq = str.equals("Hello World");        // true
boolean eqIgnore = str.equalsIgnoreCase("hello world"); // true
int compare = str.compareTo("abc");            // положительное число

// Преобразование
String upper = str.toUpperCase();   // "HELLO WORLD"
String lower = str.toLowerCase();   // "hello world"
String trim = " test ".trim();      // "test"

// Замена
String replaced = str.replace("World", "Java"); // "Hello Java"
String replaced2 = str.replaceAll("l+", "L");   // "HeLo WorLd"

// Разделение и объединение
String[] parts = str.split(" ");    // ["Hello", "World"]
String joined = String.join("-", parts); // "Hello-World"

// Проверки
boolean starts = str.startsWith("Hello");  // true
boolean ends = str.endsWith("World");      // true
boolean contains = str.contains("lo");     // true
boolean empty = str.isEmpty();             // false

String vs StringBuilder vs StringBuffer

// String — неизменяемый, потокобезопасный
String s = "Hello";
s = s + " World"; // Создаёт новые объекты!

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

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

Форматирование строк

// String.format
String formatted = String.format("Привет, %s! У вас %d сообщений", 
                                 "Иван", 5);

// System.out.printf
System.out.printf("Число: %.2f%n", 3.14159);

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

1. Используй == для проверки идентичности, equals() — для проверки содержимого
2. Избегай конкатенации в циклах — используй StringBuilder
3. Помни о неизменяемости при многократном преобразовании строк
4. Используй intern() только если действительно нужно
5. Для логирования используй String.format вместо конкатенации

Итоги

String — фундаментальный класс Java, предоставляющий неизменяемость, потокобезопасность, эффективное хранение благодаря пулу строк и богатый API для работы с текстом.