# Kaip naudoti Java StringBuilder

Java StringBuilder klasė gali būti naudojama vietoj tradicinių strypų. Skirtingai nuo tradicinių strypų, StringBuilder leidžia keisti strypą nesukuriant naujo objekto. Keitimai gali būti atliekami naudojant įvairius metodus.

## Kas yra Java StringBuilder?

[Java kalbos stygos klasė](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-stygos/) yra nekintama ir neturi jokių paklasių. Viena iš alternatyvų šiai galutinei klasei yra Java kalbos StringBuilder. Ji sukuria simbolių seką, kurią **galima keisti po jos sukūrimo**. Šiuo atžvilgiu Java StringBuilder yra panašus į StringBuffer. Abi klasės turi panašų tikslą, tačiau, skirtingai nuo buferio parinkties, StringBuilder nėra sinchronizuotas. Dėl to StringBuilder yra geras pasirinkimas dirbant su vienu sriegiu, nes jis yra daug greitesnis nei StringBuffer. Šiame pamokymuose supažindinsime jus su Java StringBuilder ir parodysime keletą jo naudojimo pavyzdžių.

## Kokia yra Java StringBuilder sintaksė?

Java StringBuilder sintaksė visada atitinka tą patį modelį, kuris atrodo taip:

```java
public final class StringBuilder
	extends Object
		implements Serializable, CharSequence
```

Norint suprasti, kaip veikia klasė ir kokiam tikslui ji skirta, verta pirmiausia pažvelgti į tradicinę String klasę. Deklaravus objektą String, jo jau nebegalima keisti. Jei norite atlikti pakeitimus, turėsite sukurti ir išsaugoti visiškai naują objektą. Tai sukelia didelį duomenų švaistymą ir gali sumažinti našumą. Jei vietoj to naudojate StringBuilder Java kalboje, galite keisti eilutes **nesukurdami naujos**. Tai sumažina švaistymą ir pagerina našumą.

## Kokie yra Java StringBuilder konstruktoriai?

Java StringBuilder turi 4 konstruktorius, kurie padeda **konvertuoti eilutę į tinkamą klasės formatą**. Jie taip pat naudojami konfigūracijai. Čia yra keturi konstruktoriai ir jų paskirtis:

- `StringBuilder()`: Sukuria tuščią StringBuilder su maksimaliu 16 simbolių talpa
- `StringBuilder(int capacity)`: Sukuria StringBuilder be simbolių, kurio maksimalus talpos dydis apibrėžiamas naudojant talpos argumentą
- `StringBuilder(CharSequence seq)`: Sukuria stygos kūrėją su tais pačiais simboliais, kaip ir saugoma simbolių seka
- `StringBuilder(String str)`: Sukuria StringBuilder su jūsų įvestu styginiu

Pažvelkime į pavyzdį, kad pamatytume, kaip šie konstruktoriai veikia praktikoje:

```java
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());
	}
}
```

Kai naudojame Java komandą `System.out.println`, kad gautume išvestį, gauname štai ką:

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

## Kokie metodai naudojami su StringBuilder Java kalboje?

Yra keletas metodų, kuriuos galima naudoti su Java StringBuilder klase. Toliau pateikiame keletą svarbiausių iš jų su kodo pavyzdžiais.

### `append()`

`append()` metodas naudojamas vienai eilutei pridėti prie kitos. Jis turi įvairius parametrus. Štai kaip jis veikia praktikoje:

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

Rezultatas yra toks:

```java
ABCDEFGHIJK
```

### `insert()`

`insert()` metodas naudojamas kartu su Java StringBuilder, kad įterptų eilutę į tam tikrą vietą. Štai pavyzdys, kaip tai veikia:

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

Štai rezultatas:

```java
AFGHIJKBCDEFGHIJK
```

Sveikasis skaičius (šiuo atveju 1) naudojamas norint apibrėžti vietą, kurioje bus įterpta eilutė.

### `replace()`

`replace()` metodas pakeičia eilutę arba jos dalį. Jis apibrėžiamas naudojant `beginIndex` ir `endIndex`. Taip tai veikia praktikoje:

```java
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);
	}
}
```

Rezultatas atrodo taip:

```java
AFGHIJKE
```

### `reverse()`

`reverse()` metodas naudojamas norint išsaugotą eilutę išdėstyti atvirkštine tvarka. Štai kaip tai veikia:

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

Štai rezultatas:

```java
EDCBA
```

### `delete()`

Naudodami Java StringBuilder, galite naudoti `delete()` metodą, kad ištrintumėte visą arba dalį eilutės. Jei norite ištrinti dalį eilutės, galite tai padaryti naudodami `beginIndex` ir `endIndex`.

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

Štai rezultatas:

```java
AE
```

### `capacity()`

`capacity()` metodas pateikia **dabartinį maksimalų simbolių skaičių** StringBuilder. Paprastai jis yra 16. Jei jis padidinamas, tai paprastai daroma naudojant formulę „dabartinis simbolių skaičius \* 2 + 2“. Taigi, jei šiuo metu jis yra 16, jis bus padaugintas iš 2 (32) ir tada prie jo bus pridėta 2. Tai matote mūsų pavyzdyje:

```java
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());
	}
}
```

Rezultatas atrodo taip:

```java
16
16
34
```

### `ensureCapacity()`

`ensureCapacity()` metodas užtikrina, kad **galimų simbolių skaičius būtų ne mažesnis už nustatytą vertę**. Jei taip nėra, talpa bus padidinta pagal aukščiau pateiktą formulę „dabartinis simbolių skaičius \* 2 + 2“. Tai matyti iš šio pavyzdžio:

```java
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());
	}
}
```

Štai rezultatas:

```java
16
16
34
34
70
```

Pirmiausia matome standartinę vertę (16), tada tą vertę padaugintą iš 2 ir pridėtą prie 2 (34), ir galiausiai tą naują vertę padaugintą iš 2 ir pridėtą prie 2.


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-stringbuilder/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-stringbuilder/) for AI/LLM consumption.