0Pricing
Java Academy · Lekcja

Budowanie napisów za pomocą StringBuilder

Wydajne konkatenowanie

Budowanie napisów za pomocą StringBuilder to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 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.

Mutowalny konstruktor napisów

StringBuilder jest mutowalną sekwencją znaków. W przeciwieństwie do String można zmieniać jego zawartość w miejscu, co sprawia, że tworzenie tekstu jest wydajne.

Tworzenie obiektu StringBuilder

Można utworzyć pusty obiekt za pomocą new StringBuilder() albo przekazać początkowy tekst, aby od razu rozpocząć pracę z zawartością.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder named = new StringBuilder("Hello");
        System.out.println("empty length: " + sb.length());
        System.out.println("named: " + named);
    }
}

Dołączanie tekstu

Metoda append dodaje zawartość na końcu. Przyjmuje napisy, liczby, znaki, wartości logiczne i inne typy.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Count: ");
        sb.append(5);
        sb.append(' ');
        sb.append(true);
        System.out.println(sb);
    }
}

Łączenie wywołań metod

append zwraca ten sam obiekt buildera, dlatego wywołania można płynnie łączyć w jednym wyrażeniu.

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

Budowanie w pętli

To jest główny przypadek użycia. Należy dodawać zawartość wewnątrz pętli bez tworzenia za każdym razem nowego obiektu, a następnie jednokrotnie wykonać konwersję na końcu.

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

Konwersja na napis

Po zakończeniu modyfikowania buildera należy wywołać toString(), aby otrzymać zwykły, niemutowalny obiekt String.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("result");
        String finalText = sb.toString();
        System.out.println(finalText.toUpperCase());
    }
}

Łączenie separatorem

Można tworzyć listy rozdzielane przecinkami, dodając separator między elementami i odpowiednio obsługując ostatni element.

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ann", "Ben", "Cara"};
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < names.length; i++) {
            sb.append(names[i]);
            if (i < names.length - 1) {
                sb.append(", ");
            }
        }
        System.out.println(sb);
    }
}

Odczytywanie długości

length() informuje, ile znaków zawiera obecnie builder. Wartość ta aktualizuje się podczas wywoływania append.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("12345");
        System.out.println("Length: " + sb.length());
    }
}

Dostęp do znaków

Za pomocą charAt(index) można odczytać pojedynczy znak na podstawie jego pozycji, podobnie jak w przypadku obiektu typu String.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Coddy");
        System.out.println("First: " + sb.charAt(0));
        System.out.println("Last: " + sb.charAt(sb.length() - 1));
    }
}

Pojemność a długość

Builder przechowuje wewnętrzny bufor, czyli pojemność, która automatycznie się zwiększa. Można podać początkową pojemność, aby ograniczyć zmianę rozmiaru, gdy znany jest rozmiar końcowy.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("short");
        System.out.println("Length: " + sb.length());
        System.out.println("Capacity at least: " + (sb.capacity() >= 100));
    }
}

Praktyczne użycie buildera

Połączmy wszystko: wydajnie zbudujmy niewielki napis raportu za pomocą łańcucha wywołań append i pętli.

public class Main {
    public static void main(String[] args) {
        int[] sales = {100, 250, 75};
        StringBuilder report = new StringBuilder("Sales Report\n");
        int total = 0;
        for (int i = 0; i < sales.length; i++) {
            report.append("Day ").append(i + 1).append(": ").append(sales[i]).append('\n');
            total += sales[i];
        }
        report.append("Total: ").append(total);
        System.out.println(report);
    }
}

Szybkie sprawdzenie

Dlaczego StringBuilder jest wydajniejszy niż wielokrotna konkatenacja za pomocą + w pętli?

Podsumowanie

Nauczyli się Państwo budować napisy za pomocą StringBuilder:

  • Jest mutowalną sekwencją znaków
  • append dodaje zawartość i obsługuje łączenie wywołań
  • Idealnie nadaje się do budowania tekstu w pętlach
  • Należy wywołać toString(), aby otrzymać końcowy obiekt String
  • Początkowa pojemność pozwala uniknąć zmiany rozmiaru

Często zadawane pytania

Czy lekcja „Budowanie napisów za pomocą StringBuilder” jest bezpłatna?

Tak — pełny tekst „Budowanie napisów za pomocą StringBuilder” 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 „Budowanie napisów za pomocą StringBuilder”?

Wydajne konkatenowanie Ć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 2 z 4.

Ile czasu zajmuje lekcja „Budowanie napisów za pomocą StringBuilder”?

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