0Pricing
Java Academy · Lekcja

Dlaczego napisy są niemutowalne

Poznaj niemutowalność napisów

Dlaczego napisy są niemutowalne to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Napisy nie mogą się zmieniać

W Javie obiekt typu String jest niemutowalny: po utworzeniu jego znaki nie mogą się zmienić. Każda metoda, która pozornie modyfikuje napis, w rzeczywistości zwraca zupełnie nowy napis.

Metody zwracają nowe napisy

toUpperCase(), replace() i podobne metody nie modyfikują oryginału. Tworzą nowy obiekt typu String, pozostawiając oryginał bez zmian.

public class Main {
    public static void main(String[] args) {
        String original = "hello";
        String upper = original.toUpperCase();
        System.out.println("original: " + original);
        System.out.println("upper: " + upper);
    }
}

Ponowne przypisanie to nie mutacja

Po zapisaniu s = s + "!" zmienna wskazuje teraz nowy napis. Stary obiekt pozostaje niezmieniony i może zostać usunięty przez garbage collector.

public class Main {
    public static void main(String[] args) {
        String s = "hi";
        String firstRef = s;
        s = s + "!";
        System.out.println("s: " + s);
        System.out.println("firstRef: " + firstRef);
    }
}

Dlaczego niemutowalność?

Niemutowalność zapewnia konkretne korzyści:

  • Bezpieczeństwo wątkowe: napisy można współdzielić bez blokad
  • Buforowanie: kody skrótów i wpisy w puli pozostają poprawne
  • Bezpieczeństwo: napis przekazany do metody nie może zostać zmieniony bez Państwa wiedzy

Pula napisów

Identyczne literały napisów mogą współdzielić jeden obiekt w puli napisów. Jest to bezpieczne wyłącznie dlatego, że napisy nigdy się nie zmieniają. W tym przykładzie oba literały wskazują ten sam obiekt z puli.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

new String przerywa współdzielenie

Użycie new String(...) wymusza utworzenie osobnego obiektu, dlatego równość referencji jest inna, mimo że zawartość jest taka sama. Zawartość należy zawsze porównywać za pomocą equals.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = new String("java");
        System.out.println("== : " + (a == b));
        System.out.println("equals: " + a.equals(b));
    }
}

Koszt konkatenacji

Każdy operator + użyty na napisach tworzy nowy obiekt. Wykonywanie tego w pętli powoduje alokowanie wielu krótkotrwałych napisów, co marnuje czas i pamięć.

public class Main {
    public static void main(String[] args) {
        String result = "";
        for (int i = 1; i <= 5; i++) {
            result = result + i;
        }
        System.out.println(result);
    }
}

Wzrost kwadratowy

Ponieważ każda konkatenacja kopiuje wszystkie wcześniejsze znaki, tworzenie długiego napisu za pomocą + w pętli słabo się skaluje — w przybliżeniu jak O(n do kwadratu). To jest główny problem z wydajnością.

public class Main {
    public static void main(String[] args) {
        String s = "";
        for (int i = 0; i < 1000; i++) {
            s += "x";
        }
        System.out.println("Length: " + s.length());
    }
}

Niemutowalne wartości są przewidywalne

Przekazanie napisu do metody jest bezpieczne: metoda nie może zmienić Państwa kopii. W tym przykładzie metoda tworzy nowy napis, a wartość wywołującego pozostaje bez zmian.

public class Main {
    static void shout(String s) {
        s = s + "!!!";
        System.out.println("inside: " + s);
    }
    public static void main(String[] args) {
        String msg = "hello";
        shout(msg);
        System.out.println("outside: " + msg);
    }
}

Zapowiedź rozwiązania

Gdy trzeba wydajnie budować napisy, Java udostępnia klasę StringBuilder, która jest mutowalnym odpowiednikiem String. Modyfikuje ona zawartość w miejscu, zamiast za każdym razem alokować nowe obiekty.

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

Porównanie obu podejść

W przypadku kilku konkatenacji operator + jest całkowicie poprawny i czytelny. Przy wielu konkatenacjach w pętli należy preferować StringBuilder. Wybór zależy od ilości tworzonego tekstu.

public class Main {
    public static void main(String[] args) {
        String simple = "a" + "b" + "c";
        StringBuilder sb = new StringBuilder("a");
        sb.append("b").append("c");
        System.out.println(simple);
        System.out.println(sb);
    }
}

Szybkie sprawdzenie

Co właściwie dzieje się podczas wywołania s.toUpperCase() na obiekcie typu String?

Podsumowanie

Nauczyli się Państwo, dlaczego napisy są niemutowalne:

  • Zawartość obiektu String nigdy się nie zmienia
  • Metody zwracają nowe napisy
  • Niemutowalność zapewnia bezpieczeństwo wątkowe, współdzielenie obiektów w puli i bezpieczeństwo
  • Konkatenacja za pomocą + w pętlach słabo się skaluje
  • StringBuilder jest mutowalnym rozwiązaniem

Często zadawane pytania

Czy lekcja „Dlaczego napisy są niemutowalne” jest bezpłatna?

Tak — pełny tekst „Dlaczego napisy są niemutowalne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Dlaczego napisy są niemutowalne”?

Poznaj niemutowalność napisów Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Dlaczego napisy są niemutowalne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Dlaczego napisy są niemutowalne
  2. Budowanie napisów za pomocą StringBuilder
  3. Metody StringBuilder
  4. StringBuilder a StringBuffer
← Powrót do Java Academy