Строки в Java: создание, конкатенация и использование методов String

Что такое строка (String)

String содержит последовательность символов - текст, например имя, предложение или строку, прочитанную из файла. На предыдущей странице вы видели String среди ссылочных типов; здесь же вы будете работать с ней на практике. Строковый литерал записывается в двойных кавычках (одинарные кавычки зарезервированы для одного char):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() возвращает количество символов - 3 для "Ada". Это вызов метода, поэтому ему нужны скобки.

Объединение строк

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

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Одна тонкость: поскольку + вычисляется слева направо, "" + 1 + 2 даёт "12" (строка + int, затем строка + int), а 1 + 2 + "" даёт "3" (сначала складываются два целых числа, а потом результат превращается в текст). Если сомневаетесь, заключайте арифметику в скобки.

Строки неизменяемы

Это самое важное, что нужно понять о строках в Java: String никогда не меняется после создания. Каждый метод, который «изменяет» строку, на самом деле возвращает совершенно новую строку и оставляет исходную нетронутой. Поэтому, если вы забудете сохранить возвращаемое значение, ничего не произойдёт:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // результат выброшен - баг!
        System.out.println(s);        // всё ещё "hello"

        s = s.toUpperCase();          // сохраняем новую строку
        System.out.println(s);        // теперь "HELLO"
    }
}

Первый вызов вычисляет "HELLO" и тут же отбрасывает его. Видимый эффект даёт только вторая строка, в которой результат присваивается обратно в s. На этом хоть раз спотыкается почти каждый.

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

Используйте .equals(), чтобы сравнить содержимое двух строк. Тянуться к == - классическая ошибка новичка: == спрашивает «это один и тот же объект в памяти?», а не «содержат ли они одинаковый текст?»:

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

Здесь a == b равно false, потому что new String(...) создаёт отдельный объект. Всегда сравнивайте значения строк через .equals() (или .equalsIgnoreCase(), чтобы игнорировать регистр). Удобный приём, чтобы избежать сбоя, когда одна из сторон может быть null, - вызывать .equals на литерале: "yes".equals(input) никогда не выбросит исключение, даже если input равно null.

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

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

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Обратите внимание на цепочку вызовов: s.trim().toUpperCase() работает, потому что trim() возвращает строку, на которой вы затем вызываете toUpperCase(). substring - ещё один рабочий инструмент: он принимает начальный индекс (включительно) и необязательный конечный индекс (исключительно):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Индексы начинаются с нуля, поэтому substring(0, 4) берёт символы с 0 по 3. Запрос индекса за пределами конца строки выбрасывает StringIndexOutOfBoundsException.

Построение строк в цикле

Конкатенация через + подходит для нескольких частей, но делать это внутри большого цикла медленно - каждый + создаёт новую строку и копирует всё целиком. Когда вы собираете текст в цикле, используйте StringBuilder, который изменяет буфер на месте и формирует итоговую строку только один раз в конце:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append возвращает тот же builder, поэтому вызовы можно объединять в цепочку. В конце вызовите .toString(), чтобы получить обычный String. Для разовых объединений придерживайтесь +; для накопления множества частей StringBuilder - правильный инструмент.

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

Конкатенация становится громоздкой, как только вам нужны выровненные столбцы, фиксированное число знаков после запятой или числа с дополнением (padding). Методы Java String.format и printf используют шаблон с заполнителями %, чтобы аккуратно справиться со всем этим - это тема следующей страницы.