# Kā lietot Java StringBuilder

Java StringBuilder klasi var izmantot tradicionālo virkņu vietā. Atšķirībā no tradicionālajām virknēm, StringBuilder ļauj veikt izmaiņas virknē, neizveidojot jaunu objektu. Izmaiņas var veikt, izmantojot dažādas metodes.

## Kas ir Java StringBuilder?

[Java valodas string klase](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-virknes/) ir nemainīga un tai nav apakšklases. Viena no alternatīvām šai galīgajai klasei ir Java valodas StringBuilder. Tā izveido rakstzīmju secību, kuru **var mainīt pēc tās izveidošanas**. Šādā veidā Java StringBuilder ir līdzīgs StringBuffer. Abām klasēm ir līdzīgs mērķis, bet atšķirībā no bufera opcijas StringBuilder nav sinhronizēts. Tas padara StringBuilder par labu izvēli, strādājot ar vienu pavedienu, jo tas ir daudz ātrāks nekā StringBuffer. Šajā apmācībā iepazīstināsim jūs ar StringBuilder Java un parādīsim dažus no tā daudzajiem lietojumiem.

## Kāda ir Java StringBuilder sintakse?

Java StringBuilder sintakse vienmēr atbilst vienam un tam pašam modelim, kas izskatās šādi:

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

Lai saprastu, kā darbojas šī klase un kādam nolūkam tā kalpo, vispirms ir lietderīgi apskatīt tradicionālo String klasi. Kad esat deklarējis objektu String, jūs vairs nevarat mainīt šo objektu. Ja vēlaties veikt izmaiņas, jums ir jāizveido un jāglabā pilnīgi jauns objekts. Tas rada lielu datu izšķērdēšanu un var samazināt veiktspēju. Ja tā vietā izmantojat StringBuilder Java, varat veikt izmaiņas virknēs **, neizveidojot jaunu**. Tas samazina atkritumus un uzlabo veiktspēju.

## Kādi ir Java StringBuilder konstruktori?

Java StringBuilder ir 4 konstruktori, kas palīdz **pārvērst virkni pareizā formātā klasē**. Tie tiek izmantoti arī konfigurācijai. Šeit ir četri konstruktori un to mērķi:

- `StringBuilder()`: Izveido tukšu StringBuilder ar maksimālo kapacitāti 16 rakstzīmes
- `StringBuilder(int capacity)`: Izveido StringBuilder bez rakstzīmēm, kura maksimālā kapacitāte ir definēta, izmantojot kapacitātes argumentu
- `StringBuilder(CharSequence seq)`: Izveido string builder ar tādiem pašiem simboliem kā saglabātajā simbolu secībā
- `StringBuilder(String str)`: Izveido StringBuilder ar ievadīto virkni

Apskatīsim piemēru, lai redzētu, kā šie konstruktori darbojas praksē:

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

Kad izmantojam Java komandu `System.out.println`, lai iegūtu rezultātu, mēs saņemam šādu rezultātu:

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

## Kādas metodes tiek izmantotas ar StringBuilder Java valodā?

Ir vairākas metodes, kuras var izmantot ar Java StringBuilder klasi. Zemāk mēs iepazīstinām ar dažām no svarīgākajām, pievienojot koda piemērus.

### `append()`

`append()` metode tiek izmantota, lai pievienotu vienu virkni citai. Tai ir dažādi parametri. Šeit ir redzams, kā tā darbojas praksē:

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

Rezultāts ir šāds:

```java
ABCDEFGHIJK
```

### `insert()`

`insert()` metode tiek izmantota kopā ar Java StringBuilder, lai ievietotu virkni konkrētā vietā. Šeit ir piemērs, kā tas darbojas:

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

Šeit ir rezultāts:

```java
AFGHIJKBCDEFGHIJK
```

Visa skaitlis (šajā gadījumā 1) tiek izmantots, lai definētu pozīciju, kurā tiks ievietota virkne.

### `replace()`

`replace()` metode aizstāj virkni vai virknes daļu. Tā ir definēta, izmantojot `beginIndex` un `endIndex`. Tā darbojas praksē:

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

Rezultāts izskatās šādi:

```java
AFGHIJKE
```

### `reverse()`

`reverse()` metode tiek izmantota, lai saglabāto virkni izvietotu apgrieztā secībā. Tā darbojas šādi:

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

Šeit ir rezultāts:

```java
EDCBA
```

### `delete()`

Jūs varat izmantot `delete()` metodi ar Java StringBuilder, lai dzēstu visu vai daļu no virknes. Ja vēlaties dzēst daļu no virknes, to var izdarīt ar `beginIndex` un `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);
	}
}
```

Šeit ir rezultāts:

```java
AE
```

### `capacity()`

`capacity()` metode sniedz **pašreizējo maksimālo rakstzīmju skaitu** StringBuilder. Parasti tas ir 16. Ja tas tiek palielināts, parasti to dara, izmantojot formulu “pašreizējais rakstzīmju skaits \* 2 + 2”. Tātad, ja pašlaik tas ir 16, tas tiek reizināts ar 2 (32) un tad tam tiek pieskaitīts 2. To var redzēt mūsu piemērā:

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

Rezultāts izskatās šādi:

```java
16
16
34
```

### `ensureCapacity()`

`ensureCapacity()` metode nodrošina, ka **pieejamo rakstzīmju skaits ir vismaz tikpat liels kā definētā vērtība**. Ja tas tā nav, kapacitāte tiks palielināta, izmantojot iepriekš minēto formulu „pašreizējais rakstzīmju skaits \* 2 + 2”. To var redzēt šajā piemērā:

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

Šeit ir rezultāts:

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

Vispirms redzam standarta vērtību (16), tad šo vērtību, kas reizināta ar 2 un pieskaitīta 2 (34), un visbeidzot šo jauno vērtību, kas reizināta ar 2 un pieskaitīta 2.


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-stringbuilder/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-stringbuilder/) for AI/LLM consumption.