# Kuidas kasutada Java StringBuilderit

Java StringBuilder-klassi saab kasutada traditsiooniliste stringide asemel. Erinevalt traditsioonilistest stringidest võimaldab StringBuilder teha stringis muudatusi ilma uut objekti loomata. Muudatusi saab teha erinevate meetodite abil.

## Mis on Java StringBuilder?

[Java string-klass](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-stringid/) on muutumatu ja sellel pole alamklasse. Üks alternatiiv sellele lõplikule klassile on Java StringBuilder. See loob märkide jada, mida **saab pärast loomist muuta**. Selles mõttes on Java StringBuilder sarnane StringBufferiga. Kahel klassil on sarnane otstarve, kuid erinevalt puhvri valikust ei ole StringBuilder sünkroniseeritud. See teeb StringBuilderist hea valiku ühe niidiga töötamisel, kuna see on palju kiirem kui StringBuffer. Selles õpetuses tutvustame teile Java StringBuilderit ja näitame mõningaid selle paljudest kasutusvõimalustest.

## Mis on Java StringBuilderi süntaks?

Java StringBuilderi süntaks järgib alati sama mustrit, mis näeb välja järgmine:

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

Selleks, et mõista klassi toimimise põhimõtteid ja eesmärki, on kasulik esmalt tutvuda traditsioonilise String-klassiga. Kui olete String-klassis objekti deklareerinud, ei saa seda enam muuta. Kui soovite teha muudatusi, peate looma ja salvestama täiesti uue objekti. See tekitab palju andmejäätmeid ja võib vähendada jõudlust. Kui kasutate Java-s selle asemel StringBuilderit, saate stringe muuta **ilma uut loomata**. See vähendab raiskamist ja parandab jõudlust.

## Millised on Java StringBuilderi konstruktorid?

Java StringBuilderil on 4 konstruktorit, mis aitavad **teisendada stringi klassi jaoks sobivasse formaati**. Neid kasutatakse ka konfigureerimiseks. Siin on neli konstruktorit ja nende otstarbed:

- `StringBuilder()`: Loob tühja StringBuilderi, mille maksimaalne mahutavus on 16 tähemärki
- `StringBuilder(int capacity)`: Loob StringBuilderi ilma tähemärkideta, mille maksimaalne mahutavus on määratud argumendiga capacity
- `StringBuilder(CharSequence seq)`: Loob string builder’i, millel on samad tähemärgid kui salvestatud tähemärkide jadas
- `StringBuilder(String str)`: Loob StringBuilder’i sisestatud stringiga

Vaatame näidet, et näha, kuidas need konstruktorid praktikas toimivad:

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

Kui kasutame Java käsku `System.out.println` väljundi saamiseks, saame järgmise tulemuse:

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

## Milliseid meetodeid kasutatakse Java keeles StringBuilderiga?

Java StringBuilder-klassiga saab kasutada mitmeid meetodeid. Allpool tutvustame mõningaid olulisemaid neist koos koodinäidetega.

### `append()`

Meetodit `append()` kasutatakse ühe stringi teisele lisamiseks. Sellel on mitmesuguseid parameetreid. Siin on näide, kuidas see praktikas toimib:

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

Väljund on järgmine:

```java
ABCDEFGHIJK
```

### `insert()`

`insert()` meetodit kasutatakse koos Java StringBuilderiga, et lisada string kindlasse kohta. Siin on näide selle toimimisest:

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

Siin on väljund:

```java
AFGHIJKBCDEFGHIJK
```

Täisarvu (antud juhul 1) kasutatakse selleks, et määrata koht, kuhu string lisatakse.

### `replace()`

Meetod `replace()` asendab stringi või stringi osa. See on defineeritud kasutades `beginIndex` ja `endIndex`. Praktikas toimib see järgmiselt:

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

Väljund näeb välja järgmine:

```java
AFGHIJKE
```

### `reverse()`

Meetodit `reverse()` kasutatakse salvestatud stringi tagurpidi järjestamiseks. See toimib järgmiselt:

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

Siin on väljund:

```java
EDCBA
```

### `delete()`

Java StringBuilderiga saab `delete()` meetodit kasutada stringi täielikuks või osaliseks kustutamiseks. Kui soovite stringi osaliselt kustutada, saate seda teha `beginIndex` ja `endIndex` abil.

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

Siin on väljund:

```java
AE
```

### `capacity()`

Meetod `capacity()` annab teile StringBuilderi **praeguse maksimaalse tähemärkide arvu**. Tavaliselt on see 16. Kui seda suurendatakse, tehakse seda tavaliselt valemi „praegune tähemärkide arv \* 2 + 2” abil. Seega, kui see on praegu 16, korrutatakse see 2-ga (32) ja lisatakse sellele 2. Seda näete meie näites:

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

Väljund näeb välja järgmine:

```java
16
16
34
```

### `ensureCapacity()`

`ensureCapacity()` meetod tagab, et **kättesaadavate tähemärkide arv on vähemalt määratud väärtusega võrdne**. Kui see nii ei ole, suurendatakse mahutavust ülaltoodud valemi abil: „praegune tähemärkide arv \* 2 + 2”. Seda näete järgnevas näites:

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

Siin on väljund:

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

Esmalt näeme standardväärtust (16), seejärel seda väärtust korrutatuna 2-ga ja liidetuna 2-ga (34) ning lõpuks seda uut väärtust korrutatuna 2-ga ja liidetuna 2-ga.


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-stringbuilder/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-stringbuilder/) for AI/LLM consumption.