Java Academy · Lektion

StringBuilder til effektiv sammenkædning

Brug StringBuilder til effektivt at opbygge strenge i løkker og ved kompleks formatering.

Lektion 2 af 413 trin

StringBuilder til effektiv sammenkædning er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

StringBuilder til effektiv sammenkædning

StringBuilder er et foranderligt alternativ til String, når du opbygger tekst trin for trin. Det undgår at oprette mange mellemliggende String-objekter.

StringBuilder kontra sammenkædning af String

Når du sammenkæder mange String-objekter, især i løkker, er StringBuilder markant hurtigere, fordi den ændrer en intern char-buffer i stedet for at oprette 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

Vigtige metoder: append, insert, delete, replace, reverse, toString, length, charAt og 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

Kædning af append-kald

Alle append-metoder og andre metoder, der ændrer objektet, returnerer this, så du kan kæde kald flydende sammen.

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());

Oprindelig kapacitet

Angiv på forhånd en forventet kapacitet for StringBuilder for at undgå ændring af størrelsen på det interne array. Det forbedrer ydeevnen for lange String.

// 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 sletning af bestemte tegn

deleteCharAt fjerner ét tegn. delete(start, end) fjerner et område. Begge operationer har kompleksiteten O(n), fordi elementerne i arrayet skal flyttes.

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!

Opbygning af CSV

Et praktisk mønster er at opbygge en CSV-linje med StringBuilder og håndtere separatorer korrekt.

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 til output adskilt af separatorer

StringJoiner gør det nemt at samle elementer med en separator og eventuelt et præfiks og suffiks — du behøver ikke håndtere separatorerne manuelt.

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, synkroniserede version af StringBuilder. Den er langsommere på grund af låsning. Brug StringBuilder i enkelttrådede situationer (99 % af tilfældene).

// 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

Vending og kontrol af palindromer

StringBuilders indbyggede reverse() gør det elegant at kontrollere, om en tekst er et palindrom.

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

Fra virkeligheden: SQL-forespørgselsbygger

Opbygning af en dynamisk SQL-forespørgsel med StringBuilder, hvor WHERE-betingelser tilføjes efter behov.

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

Hurtigt tjek

Hvorfor er sammenkædning af String med + ineffektiv i løkker?

Besvar den i den interaktive lektion

Opsummering: StringBuilder til effektiv sammenkædning

Det vigtigste:

StringBuilder er foranderlig — append, insert og delete ændrer en intern buffer
Brug StringBuilder i løkker for at undgå oprettelse af String med kompleksiteten O(n²)
Alle metoder, der ændrer objektet, returnerer this — det muliggør flydende kædning af kald
Angiv StringBuilders forventede kapacitet på forhånd for at reducere intern ændring af størrelsen
StringJoiner og String.join er praktiske til output, der er adskilt af separatorer
StringBuffer er det synkroniserede (trådsikre), men langsommere alternativ

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “StringBuilder til effektiv sammenkædning” gratis?

Ja — hele teksten til “StringBuilder til effektiv sammenkædning” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “StringBuilder til effektiv sammenkædning”?

Brug StringBuilder til effektivt at opbygge strenge i løkker og ved kompleks formatering. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “StringBuilder til effektiv sammenkædning”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Strenges uforanderlighed og string pool
StringBuilder til effektiv sammenkædning
Tekstblokke og String.format
Regulære udtryk med Pattern og Matcher

← Tilbage til Java Academy