Java Language
String

Introduktion

Syntax

• ny StringBuilder ()

• ny StringBuilder (int-kapacitet)

• ny StringBuilder (CharSequence seq)

• ny StringBuilder (StringBuilder builder)

• ny StringBuilder (String string)

• ny StringJoiner (CharSequence-avgränsare)

• ny StringJoiner (CharSequence-avgränsare, CharSequence-prefix, CharSequence-suffix)

Anmärkningar

 StringBuilder v = new StringBuilder('I'); //'I' is a character, "I" is a String.
 System.out.println(v.capacity()); --> output 73
 System.out.println(v.toString()); --> output nothing

Upprepa en sträng n gånger

Problem: Skapa en String innehåller n upprepningar av en String s .

Det triviala tillvägagångssättet skulle upprepade gånger sammanfoga String

final int n = ...
final String s = ...
String result = "";

for (int i = 0; i < n; i++) {
    result += s;
}

Detta skapar n nya strängfall som innehåller 1 till n upprepningar av s vilket resulterar i en körtid på O(s.length() * n²) = O(s.length() * (1+2+...+(n-1)+n)) .

För att undvika detta bör StringBuilder användas, vilket gör det möjligt att skapa String i O(s.length() * n) istället:

final int n = ...
final String s = ...

StringBuilder builder = new StringBuilder();

for (int i = 0; i < n; i++) {
    builder.append(s);
}

String result = builder.toString();

Jämför StringBuffer, StringBuilder, Formatter och StringJoiner

StringBuffer , StringBuilder , Formatter och StringJoiner klasserna är Java SE-verktygsklasser som främst används för att montera strängar från annan information:

• StringBuffer klassen har funnits sedan Java 1.0 och tillhandahåller en mängd olika metoder för att bygga och ändra en "buffert" som innehåller en sekvens av tecken.

• StringBuilder klassen lades till i Java 5 för att hantera prestandaproblem med den ursprungliga StringBuffer klassen. API: erna för de två klasserna är i stort sett desamma. Den viktigaste skillnaden mellan StringBuffer och StringBuilder är att den förra är trådsäker och synkroniserad och den senare inte.

Detta exempel visar hur StringBuilder kan användas:

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

( StringBuffer klassen används på samma sätt: ändra bara StringBuilder till StringBuffer ovan)

StringBuffer och StringBuilder klasserna är lämpliga för både montering och modifiering av strängar; dvs de tillhandahåller metoder för att ersätta och ta bort tecken samt lägga till dem i olika. De påminnande två klasserna är specifika för uppgiften att montera strängar.

• Formatter klassen lades till i Java 5 och modelleras löst på sprintf funktionen i C-standardbiblioteket. Det tar en formatsträng med inbäddade formatspecifikationer och en sekvens av andra argument och genererar en sträng genom att konvertera argumenten till text och ersätta dem i stället för formatspecifikationerna. Detaljerna i formatspecifikationerna säger hur argumenten konverteras till text.

• StringJoiner klassen lades till i Java 8. Det är en formaterare för speciellt syfte som kortfattat formaterar en sekvens av strängar med separatorer mellan dem. Det är designat med ett flytande API och kan användas med Java 8-strömmar.

Här är några typiska exempel på Formatter användning:

// This does the same thing as the StringBuilder example above
int one = 1;
String color = "red";
Formatter f = new Formatter();
System.out.print(f.format("One=%d, colour=%s%n", one, color));
// Prints "One=1, Colour=red" followed by the platform's line separator

// The same thing using the `String.format` convenience method
System.out.print(String.format("One=%d, color=%s%n", one, color));

StringJoiner klassen är inte idealisk för ovanstående uppgift, så här är ett exempel på formatering av en rad strängar.

StringJoiner sj = new StringJoiner(", ", "[", "]");
for (String s : new String[]{"A", "B", "C"}) {
    sj.add(s);
}
System.out.println(sj);
// Prints "[A, B, C]"

Användningsfallen för de fyra klasserna kan sammanfattas:

• StringBuilder lämplig för alla strängmontering ELLER strängmodifieringsuppgifter.
• StringBuffer användning (endast) när du behöver en tråd-säker version av StringBuilder .
• Formatter ger mycket rikare strängformateringsfunktioner, men är inte lika effektiv som StringBuilder . Detta beror på att varje samtal till Formatter.format(...) innebär:
  • analysera format ,
  • skapa och fylla en varargs- grupp och
  • autoboxar alla primitiva argument.
• StringJoiner tillhandahåller kortfattad och effektiv formatering av en sekvens av strängar med separatorer, men är inte lämplig för andra formateringsuppgifter.