# Kako uporabljati Java StringBuilder

Razred StringBuilder v Javi se lahko uporablja namesto tradicionalnih nizov. Za razliko od tradicionalnih nizov, StringBuilder omogoča spreminjanje niza brez ustvarjanja novega objekta. Spremembe se lahko izvedejo z različnimi metodami.

## Kaj je Java StringBuilder?

[Razred String v Javi](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-nizi/) je nespremenljiv in nima podrazredov. Ena od alternativ temu končnemu razredu je Java StringBuilder. Ustvari zaporedje znakov, ki **se lahko spremeni po ustvarjanju**. V tem smislu je Java StringBuilder podoben StringBuffer. Oba razreda imata podoben namen, vendar za razliko od možnosti buffer StringBuilder ni sinhroniziran. Zaradi tega je StringBuilder dobra izbira pri delu z enim nizom, saj je veliko hitrejši od StringBuffer. V tem vodiču vam bomo predstavili StringBuilder v Javi in vam pokazali nekaj njegovih številnih uporab.

## Kakšna je sintaksa Java StringBuilder?

Sintaksa Java StringBuilder vedno sledi istemu vzorcu, ki izgleda takole:

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

Da bi razumeli osnovne principe delovanja razreda in njegov namen, je koristno najprej pogledati tradicionalni razred String. Ko enkrat deklarirate objekt v String, tega objekta ne morete več spreminjati. Če želite narediti spremembe, morate ustvariti in shraniti povsem nov objekt. To povzroča veliko izgubo podatkov in lahko vodi do zmanjšane zmogljivosti. Če namesto tega uporabite StringBuilder v Javi, lahko spreminjate nize, **ne da bi ustvarili nove**. To zmanjša izgubo in izboljša zmogljivost.

## Kateri so konstruktorji za Java StringBuilder?

Java StringBuilder ima 4 konstruktorje, ki pomagajo **pretvoriti niz v pravi format za razred**. Uporabljajo se tudi za konfiguracijo. Tukaj so štirje konstruktorji in njihovi nameni:

- `StringBuilder()`: Ustvari prazen StringBuilder z največjo zmogljivostjo 16 znakov
- `StringBuilder(int capacity)`: Ustvari StringBuilder brez znakov, katerega maksimalna kapaciteta je definirana z argumentom capacity
- `StringBuilder(CharSequence seq)`: Ustvari nizovnik z istimi znaki kot shranjena zaporedja znakov
- `StringBuilder(String str)`: Ustvari StringBuilder z nizom, ki ga vnesete

Poglejmo primer, da vidimo, kako ti konstruktorji delujejo v praksi:

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

Ko uporabimo ukaz Java `System.out.println` za pridobitev izhoda, dobimo naslednje:

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

## Kateri metodi se uporabljata s StringBuilder v Javi?

Obstaja več metod, ki jih lahko uporabite s klaso StringBuilder v Javi. Spodaj predstavljamo nekatere najpomembnejše med njimi, skupaj s primeri kode.

### `append()`

Metoda `append()` se uporablja za dodajanje enega niza drugemu. Ima različne parametre. Tako deluje v praksi:

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

Izhod je naslednji:

```java
ABCDEFGHIJK
```

### `insert()`

Metoda `insert()` se uporablja v kombinaciji z Java StringBuilderjem za vstavljanje niza na določeno mesto. Tukaj je primer, kako deluje:

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

Tukaj je izhod:

```java
AFGHIJKBCDEFGHIJK
```

Celo število (v tem primeru 1) se uporablja za določitev položaja, na katerega bo niz vstavljen.

### `replace()`

Metoda `replace()` nadomesti niz ali del niza. Opredeljena je z uporabo `beginIndex` in `endIndex`. Tako deluje v praksi:

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

Izhod je naslednji:

```java
AFGHIJKE
```

### `reverse()`

Metoda `reverse()` se uporablja za obrnitev shranjenega niza v obratnem vrstnem redu. Tako deluje:

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

Tukaj je izhod:

```java
EDCBA
```

### `delete()`

Metodo `delete()` lahko uporabite z Java StringBuilderjem, da izbrišete celoten niz ali njegov del. Če želite izbrisati del niza, lahko to storite z `beginIndex` in `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);
	}
}
```

Tukaj je izhod:

```java
AE
```

### `capacity()`

Metoda `capacity()` vam poda **trenutno največje število znakov** za StringBuilder. Običajno je to 16. Če se poveča, se to običajno naredi s formulo »trenutno število znakov \* 2 + 2«. Torej, če je trenutno 16, se pomnoži z 2 (32) in nato doda 2. To lahko vidite v našem primeru:

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

Izhod je naslednji:

```java
16
16
34
```

### `ensureCapacity()`

Metoda `ensureCapacity()` zagotavlja, da **je število razpoložljivih znakov vsaj enako opredeljeni vrednosti**. Če to ni tako, se zmogljivost poveča z uporabo zgornje formule, »trenutno število znakov \* 2 + 2«. To lahko vidite v naslednjem primeru:

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

Tukaj je izhod:

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

Najprej vidimo standardno vrednost (16), nato to vrednost pomnoženo z 2 in seštejeno z 2 (34) in nazadnje novo vrednost pomnoženo z 2 in seštejeno z 2.


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-stringbuilder/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-stringbuilder/) for AI/LLM consumption.