Hur man använder Java:s StringBuil­der

Javas StringBuil­der-klass kan användas istället för tra­di­tio­nel­la strängar. Till skillnad från tra­di­tio­nel­la strängar kan du med StringBuil­der göra ändringar i en sträng utan att skapa ett nytt objekt. Änd­ring­ar­na kan göras med hjälp av olika metoder.

Vad är Java:s StringBuil­der?

Sträng­klas­sen i Java är oför­än­der­lig och har inga un­der­klas­ser. Ett al­ter­na­tiv till denna slut­gil­ti­ga klass är Javas StringBuil­der. Den skapar en sekvens av tecken som kan ändras efter att den har skapats. På så sätt liknar Javas StringBuil­der StringBuf­fer. De två klasserna har ett liknande syfte, men till skillnad från bufferten är StringBuil­der inte syn­kro­ni­se­rad. Det gör StringBuil­der till ett bra val när man arbetar med enstaka trådar, eftersom den är mycket snabbare än StringBuf­fer. I den här hand­led­ning­en pre­sen­te­rar vi StringBuil­der i Java och visar några av dess många an­vänd­nings­om­rå­den.

Vad är syntaxen för Java:s StringBuil­der?

Syntaxen för Java:s StringBuil­der följer alltid samma mönster, som ser ut så här:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

För att förstå grunderna i hur klassen fungerar och vilket syfte den tjänar, är det bra att först titta på den tra­di­tio­nel­la String-klassen. När du har de­kla­re­rat ett objekt i String kan du inte längre ändra det objektet. Om du vill göra ändringar måste du skapa och spara ett helt nytt objekt. Detta skapar mycket dataspill och kan leda till försämrad prestanda. Om du istället använder StringBuil­der i Java kan du göra ändringar i strängar utan att skapa en ny. Detta minskar slöseriet och för­bätt­rar pre­stan­dan.

Vilka är kon­struk­tö­rer­na för Java:s StringBuil­der?

Java:s StringBuil­der har fyra kon­struk­to­rer som hjälper till att kon­ver­te­ra strängen till rätt format för klassen. De används också för kon­fi­gu­ra­tion. Här är de fyra kon­struk­to­rer­na och deras syften:

• StringBuilder(): Skapar en tom StringBuil­der med en maximal kapacitet på 16 tecken
• StringBuilder(int capacity): Skapar en StringBuil­der utan tecken vars maximala kapacitet de­fi­nie­ras med hjälp av ka­pa­ci­tets­ar­gu­men­tet
• StringBuilder(CharSequence seq): Skapar en sträng­byg­ga­re med samma tecken som den lagrade tecken­se­kven­sen
• StringBuilder(String str): Skapar en StringBuil­der med den sträng du anger

Låt oss titta på ett exempel för att se hur dessa kon­struk­tö­rer fungerar i praktiken:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("First constructor  = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Second constructor  = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Third constructor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Fourth constructor = " + str4.toString());
	}
}

När vi använder Java-kommandot System.out.println för att få utdata får vi följande:

First constructor = ABC
Second constructor = 5
Third constructor = ABCDEFGHIJK
Fourth constructor = ABCDEFGHIJK

Vilka metoder används med StringBuil­der i Java?

Det finns ett antal metoder som kan användas med Java-klassen StringBuil­der. Nedan pre­sen­te­rar vi några av de vik­ti­gas­te, med ko­dex­em­pel.

append()

Metoden append() används för att lägga till en sträng till en annan. Den har olika pa­ra­met­rar. Så här fungerar den i praktiken:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.append("FGHIJK");
	System.out.println(str);
	}
}

Re­sul­ta­tet blir följande:

ABCDEFGHIJK

insert()

Metoden insert() används i kom­bi­na­tion med Javas StringBuil­der för att infoga en sträng på en specifik plats. Här är ett exempel på hur det fungerar:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.insert(1,"FGHIJK");
	System.out.println(str);
	}
}

Här är re­sul­ta­tet:

AFGHIJKBCDEFGHIJK

Heltalet (i detta fall 1) används för att definiera den position där strängen ska infogas.

replace()

Metoden replace() ersätter en sträng eller en del av en sträng. Den de­fi­nie­ras med hjälp av beginIndex och endIndex. Så här fungerar det i praktiken:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.replace(1,4,"FGHIJK");
	System.out.println(str);
	}
}

Re­sul­ta­tet ser ut som följer:

AFGHIJKE

reverse()

Metoden reverse() används för att placera den lagrade strängen i omvänd ordning. Så här fungerar det:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.reverse();
	System.out.println(str);
	}
}

Här är re­sul­ta­tet:

EDCBA

delete()

Du kan använda metoden delete() med Java:s StringBuil­der för att radera hela eller delar av en sträng. Om du vill radera en del av strängen kan du göra det med beginIndex och endIndex.

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

Här är re­sul­ta­tet:

AE

capacity()

Metoden capacity() ger dig det aktuella maximala tec­ke­nan­ta­let för StringBuil­der. Normalt är det 16. Om det ökas görs det van­ligt­vis med formeln ”aktuellt tec­ke­nan­tal * 2 + 2”. Så om det för när­va­ran­de är 16 mul­ti­pli­ce­ras det med 2 (32) och sedan läggs 2 till. Du kan se det i vårt exempel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("This is another example");
	System.out.println(str.capacity());
	}
}

Re­sul­ta­tet ser ut som följer:

16
16
34

ensureCapacity()

Metoden ensureCapacity() sä­ker­stäl­ler att antalet till­gäng­li­ga tecken är minst lika stort som det de­fi­ni­e­ra­de värdet. Om så inte är fallet ökas ka­pa­ci­te­ten med hjälp av formeln ovan, ”aktuellt tec­ke­nan­tal * 2 + 2”. Det kan du se i följande exempel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("This is another example");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

Här är re­sul­ta­tet:

16
16
34
34
70

Först ser vi stan­dard­vär­det (16), sedan det värdet mul­ti­pli­ce­rat med 2 och adderat till 2 (34), och slutligen det nya värdet mul­ti­pli­ce­rat med 2 och adderat till 2.