Stringi w Javie: tworzenie, łączenie i metody klasy String

Czym jest String

String przechowuje ciąg znaków, czyli tekst, np. imię, zdanie albo linię odczytaną z pliku. Na poprzedniej stronie String pojawił się na liście typów referencyjnych; tutaj naprawdę zaczniesz z nim pracować. Literał napisu zapisujesz w cudzysłowie podwójnym (apostrofy są zarezerwowane dla pojedynczego 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() zwraca liczbę znaków: 3 dla "Ada". To wywołanie metody, więc potrzebuje nawiasów.

Łączenie napisów

Operator + skleja napisy. Jeśli po którejś stronie + jest napis, druga strona jest automatycznie zamieniana na tekst, więc możesz bez dodatkowej pracy mieszać liczby i wartości logiczne:

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");
    }
}

Jedna pułapka: ponieważ + działa od lewej do prawej, "" + 1 + 2 daje "12" (napis + int, potem napis + int), a 1 + 2 + "" daje "3" (dwie liczby int najpierw się dodają, a potem stają się tekstem). W razie wątpliwości otocz działania arytmetyczne nawiasami.

Stringi są niezmienne

To najważniejsza rzecz do zrozumienia w stringach Javy: String nigdy nie zmienia się po utworzeniu. Każda metoda, która "modyfikuje" napis, w rzeczywistości zwraca zupełnie nowy napis i zostawia oryginał nietknięty. Jeśli więc zapomnisz przechwycić zwracaną wartość, nic się nie stanie:

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

        s.toUpperCase();              // wynik wyrzucony: błąd!
        System.out.println(s);        // nadal "hello"

        s = s.toUpperCase();          // przechwyć nowy napis
        System.out.println(s);        // teraz "HELLO"
    }
}

Pierwsze wywołanie oblicza "HELLO" i od razu je wyrzuca. Widoczny efekt ma tylko druga linia, która przypisuje wynik z powrotem do s. Prawie każdy raz się na tym potyka.

Porównywanie napisów

Do porównania zawartości dwóch napisów używaj .equals(). Sięgnięcie po == to klasyczny błąd początkujących: == pyta "czy to ten sam obiekt w pamięci?", a nie "czy zawierają ten sam tekst?":

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 to tutaj false, bo new String(...) wymusza osobny obiekt. Wartości napisów zawsze porównuj przez .equals() (albo .equalsIgnoreCase(), żeby zignorować wielkość liter). Przydatna sztuczka, żeby uniknąć awarii, gdy jedna strona może być null, to wywołanie .equals na literale: "yes".equals(input) nigdy nie rzuca wyjątku, nawet gdy input to null.

Codzienne metody String

Ponieważ napisy są niezmienne, każda z tych metod zwraca nowy napis (albo wartość) zamiast zmieniać oryginał. To te, po które będziesz sięgać cały czas:

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"
    }
}

Zwróć uwagę na łańcuchowanie: s.trim().toUpperCase() działa, bo trim() zwraca napis, na którym potem wywołujesz toUpperCase(). substring to kolejne podstawowe narzędzie: przyjmuje indeks początkowy (włącznie) i opcjonalny indeks końcowy (wyłącznie):

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"
    }
}

Indeksy liczy się od zera, więc substring(0, 4) bierze znaki od 0 do 3. Prośba o indeks poza końcem rzuca StringIndexOutOfBoundsException, jeden z wyjątków czasu działania, przed którymi można się zabezpieczyć. Zauważ też, że split(",") powyżej zwraca tablicę, w której length to pole bez nawiasów, w odróżnieniu od metody .length() na napisie.

Budowanie napisów w pętli

Łączenie przez + sprawdza się przy kilku kawałkach, ale w dużej pętli jest wolne: każde + tworzy nowy napis i kopiuje wszystko. Gdy składasz tekst w pętli, użyj StringBuilder, który zmienia bufor w miejscu i tworzy końcowy napis raz, na samym końcu:

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 zwraca ten sam builder, więc wywołania można łączyć w łańcuch. Na końcu wywołaj .toString(), żeby dostać zwykły String. Przy jednorazowym łączeniu zostań przy +; do zbierania wielu kawałków właściwym narzędziem jest StringBuilder.

Dalej: formatowanie napisów

Konkatenacja robi się nieporęczna, gdy potrzebujesz wyrównanych kolumn, stałej liczby miejsc po przecinku albo liczb dopełnionych zerami. String.format i printf w Javie używają szablonu z miejscami oznaczonymi %, żeby czysto obsłużyć to wszystko. O tym jest następna strona.