Java Academy · leksjon

StringBuilder for effektiv konkatenering

Bruk StringBuilder til å bygge strenger effektivt i løkker og ved kompleks formatering.

Leksjon 2 av 413 trinn

StringBuilder for effektiv konkatenering er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

StringBuilder for effektiv konkatenering

StringBuilder er et foranderlig alternativ til String for trinnvis oppbygging av tekst. Den unngår opprettelsen av mange mellomliggende String-objekter.

StringBuilder kontra String-konkatenering

Når mange strenger skal konkateneres, spesielt i løkker, er StringBuilder betydelig raskere fordi den endrer en intern char-buffer i stedet for å opprette nye objekter.

// Inefficient: creates a new String every iteration
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + ","; // 1000 new String objects!
}

// Efficient: StringBuilder uses a resizable char buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(',');
}
String efficient = sb.toString(); // one final String created

StringBuilder-API-et

Viktige metoder: append, insert, delete, replace, reverse, toString, length, charAt, setCharAt.

StringBuilder sb = new StringBuilder("Hello");

sb.append(", World");     // Hello, World
sb.insert(5, "!");        // Hello!, World
sb.delete(5, 6);           // Hello, World
sb.replace(7, 12, "Java"); // Hello, Java
sb.reverse();               // avaJ ,olleH
sb.reverse();               // Hello, Java

System.out.println(sb);         // Hello, Java
System.out.println(sb.length()); // 11
System.out.println(sb.charAt(0)); // H

Kjeding av append-kall

Alle append-metoder og andre metoder som endrer objektet, returnerer this, slik at de kan kjedes sammen på en flytende måte.

StringBuilder html = new StringBuilder()
    .append("<div class=\"card\">")
    .append("<h2>").append("Product Title").append("</h2>")
    .append("<p>Price: $").append(String.format("%.2f", 29.99)).append("</p>")
    .append("<button>Add to Cart</button>")
    .append("</div>");

System.out.println(html.toString());

Startkapasitet

Angi forventet kapasitet når du oppretter StringBuilder, slik at intern resizing av arrayet unngås og ytelsen forbedres for store strenger.

// Default capacity: 16 chars
StringBuilder small = new StringBuilder();

// Pre-sized: 10 items * ~50 chars each
StringBuilder report = new StringBuilder(500);

for (int i = 1; i <= 10; i++) {
    report.append(String.format("%-3d. Record %04d: processed OK%n", i, i));
}

System.out.println(report.toString().substring(0, 30));
// "  1. Record 0001: processed OK"

deleteCharAt og målrettede slettinger

deleteCharAt fjerner ett enkelt tegn. delete(start, end) fjerner et område. Disse operasjonene har kompleksiteten O(n) på grunn av forskyvning i arrayet.

StringBuilder sb = new StringBuilder("Hello, World!");

sb.deleteCharAt(5);     // removes comma: "Hello World!"
sb.delete(5, 6);         // removes space: "HelloWorld!"

System.out.println(sb); // HelloWorld!

// Replace to fix a typo
StringBuilder typo = new StringBuilder("Helo, Java!");
typo.replace(typo.indexOf("Helo"), typo.indexOf("Helo") + 4, "Hello");
System.out.println(typo); // Hello, Java!

Oppbygging av CSV

Et praktisk mønster: bygg en CSV-linje med StringBuilder og håndter skilletegn på riktig måte.

import java.util.List;

static String toCsv(List<String> values) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.size(); i++) {
        if (i > 0) sb.append(',');
        sb.append(escapeCsv(values.get(i)));
    }
    return sb.toString();
}

static String escapeCsv(String s) {
    if (s.contains(",") || s.contains("\""))
        return "\"" + s.replace("\"", "\"\"") + "\"";
    return s;
}

System.out.println(toCsv(List.of("Alice", "Smith, Jr.", "30")));
// Alice,"Smith, Jr.",30

StringJoiner for skilletegnseparert resultat

StringJoiner forenkler sammenføying av elementer med et skilletegn og eventuelt prefiks og suffiks – manuell håndtering av skilletegn er ikke nødvendig.

import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.add("Alice");
sj.add("Bob");
sj.add("Charlie");
System.out.println(sj.toString()); // [Alice, Bob, Charlie]

// Equivalent with String.join
String joined = String.join(", ", "Alice", "Bob", "Charlie");
System.out.println(joined); // Alice, Bob, Charlie

// Streams: collect with joining collector
import java.util.stream.*;
List.of("a", "b", "c").stream()
    .collect(Collectors.joining(", ", "(", ")"));
// (a, b, c)

StringBuilder kontra StringBuffer

StringBuffer er den trådsikre, synkroniserte varianten av StringBuilder. Den er tregere på grunn av låsing. Bruk StringBuilder i kontekster med én tråd (99 % av tilfellene).

// StringBuffer: thread-safe but slower (synchronized methods)
StringBuffer buf = new StringBuffer();
buf.append("Thread-safe");
buf.append(" but slow");

// StringBuilder: not thread-safe but faster
StringBuilder sb = new StringBuilder();
sb.append("Fast");
sb.append(" single-threaded");

// When to use StringBuffer:
// - Multiple threads write to the same buffer
// - Almost always a design smell — redesign to avoid sharing

Reversering og palindromkontroll

Den innebygde reverse()-metoden i StringBuilder gjør kontroll av palindromer elegant.

static boolean isPalindrome(String s) {
    String cleaned = s.toLowerCase()
        .replaceAll("[^a-z0-9]", ""); // remove non-alphanumeric
    String reversed = new StringBuilder(cleaned).reverse().toString();
    return cleaned.equals(reversed);
}

System.out.println(isPalindrome("A man, a plan, a canal: Panama")); // true
System.out.println(isPalindrome("race a car"));                      // false
System.out.println(isPalindrome("Was it a car or a cat I saw?"));    // true

I praksis: SQL-spørringsbygger

Bygg en dynamisk SQL-spørring med StringBuilder, der WHERE-klausuler legges til betinget.

static String buildQuery(String category, Double minPrice, Double maxPrice) {
    StringBuilder sql = new StringBuilder("SELECT * FROM products WHERE 1=1");
    if (category != null)
        sql.append(" AND category = '" + category + "'");
    if (minPrice != null)
        sql.append(" AND price >= ").append(minPrice);
    if (maxPrice != null)
        sql.append(" AND price <= ").append(maxPrice);
    sql.append(" ORDER BY name");
    return sql.toString();
}

System.out.println(buildQuery("Electronics", 50.0, null));
// SELECT * FROM products WHERE 1=1 AND category = 'Electronics' AND price >= 50.0 ORDER BY name

Kort sjekk

Hvorfor er konkatenering av strenger med + lite effektivt i løkker?

Besvar den i den interaktive leksjonen

Oppsummering: StringBuilder for effektiv konkatenering

Viktigste punkter:

StringBuilder er foranderlig – append/insert/delete endrer en intern buffer
Bruk StringBuilder i løkker for å unngå String-opprettelse med kompleksiteten O(n²)
Alle metoder som endrer objektet, returnerer this – noe som muliggjør flytende kjeding
Angi forventet kapasitet for StringBuilder på forhånd for å redusere intern resizing
StringJoiner og String.join er praktiske for skilletegnseparert resultat
StringBuffer er det synkroniserte (trådsikre), men tregere alternativet

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «StringBuilder for effektiv konkatenering» gratis?

Ja – hele teksten i «StringBuilder for effektiv konkatenering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «StringBuilder for effektiv konkatenering»?

Bruk StringBuilder til å bygge strenger effektivt i løkker og ved kompleks formatering. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «StringBuilder for effektiv konkatenering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Uforanderlige strenger og String Pool
StringBuilder for effektiv konkatenering
Tekstblokker og String.format
Regulære uttrykk med Pattern og Matcher

← Tilbake til Java Academy