# Kako razdeliti nize v Javi

Metoda `split()` se lahko uporabi za razdelitev nizov v Javi. Vsebuje parameter za ločilo in neobvezni parameter za število podnizov. Pri uporabi metode je treba upoštevati tudi nekatere posebnosti. Razložimo vam vse, kar morate vedeti.

## Kaj je `split()`?

[Java nizi](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-nizi/) povezujejo znake, številke in posebne znake. Obstajajo kot objekti v razredu java.lang in se ustvarjajo in spreminjajo s pomočjo razreda String. V programskem jeziku Java lahko nize tudi razdelite na različne podnize. Java split() se uporablja za **izločanje določenih segmentov iz niza** ali za razdelitev niza na **posamezne dele**. Spodaj vam bomo podrobneje pokazali, kaj lahko storite s to metodo.

Ko razdelite niz Java z split(), dobite niz z več nizi. To postane vrnjena vrednost.

## Kakšna je sintaksa Jave `split()`?

Osnovna sintaksa Java `split()` je zelo preprosta, vendar jo je mogoče razširiti z izbirnimi parametri. Tukaj je osnovna različica:

```java
String[] split(String regex)
```

V tem primeru **bo izhod v obliki niza**. `String` je nizovni objekt. `regex` je parameter, ki se uporablja za določitev, kje naj se niz razdeli. Parameter ni obvezen, vendar je priporočljiv.

Dodatni izbirni parameter `limit` omogoča določitev števila podnizov, ki naj se ustvarijo. Njegova vrednost je celo število. Če je enaka nič ali negativna, bodo v izhod vključeni vsi podnizi. Če izberete pozitivno vrednost, boste v izhodu dobili to število podnizov. Z dodatnim izbirnim parametrom `limit` bo sintaksa izgledala takole:

```java
String[] split(String regex, int limit)
```

## Kako uporabljati `split()` s presledkom kot ločilom

Poglejmo nekaj praktičnih primerov. Najprej bomo ustvarili niz, ki vsebuje 4 besede: »To je primer«. Nato bomo niz razdelili z uporabo `split()`. Najbolj intuitiven način za razdelitev tega niza je uporaba že obstoječih **presledkov med besedami**. Tako to poteka v kodi:

```java
public class Main {
	public static void main(String[] args) {
		String x = "This is an example";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

V tem primeru je inicializirana nizovna spremenljivka x. Nato se na nizu uporabi Java `split()`. Parameter poišče presledke v nizu in ga razdeli na mestih, kjer jih najde. Rezultat se nato shrani v niz z imenom »output«. Zanko `for` se uporabi za navedbo podnizov. Java ukaz `System.out.println` nam da naslednji izpis:

```java
This
is
an
example
```

## Kako uporabljati vejico kot ločilo, z in brez presledkov

V Javi lahko uporabite tudi `split()` za nize, ki vsebujejo **sezname, ločene z vejicami**. Zaradi natančnosti izvajanja navodil v Javi boste morali uporabiti majhen trik. Najprej si oglejmo primer brez trika. Recimo, da imamo seznam dni v tednu, ločenih z vejicami. Te vejice so odličen ločevalnik za vnos v `regex`. Če kodo nastavimo na ta način, bo izgledala takole:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday";
		String[] output = x.split(",");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

V tem primeru izhod ni ravno popoln:

```java
Sunday
 Monday
 Tuesday
 Wednesday
 Thursday
 Friday
 Saturday
```

Izpis nam daje jasen seznam dni v tednu. Vendar pa vsaka vrednost po nedelji vsebuje presledek pred dnevom. Ker smo kot ločilo uporabili samo vejico, so presledki ostali tam v procesu razdeljevanja. Da bi dobili čistejši izpis, moramo **kot** ločilo uporabiti **vejico in presledek**. Če to storimo, bo koda izgledala takole:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday";
		String[] output = x.split(", ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Izhod je zdaj veliko čistejši:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

## Kako razdeliti Java nize s številkami

`split()` lahko uporabite tudi za razdelitev Java nizov, sestavljenih iz številk. V našem primeru bomo vzeli dolg ključ, ki je razdeljen s piki in dvopičjem. Če želimo ločiti številke **za dvopičjem**, bi koda izgledala takole:

```java
public class Main {
	public static void main(String[] args) {
		String x = "194.518.552.1.17:6339";
		String[] output = x.split(":");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Tukaj je izhod:

```java
194.518.552.1.17
6339
```

## Kako uporabljati `split()` z omejitvenim parametrom

Pri razdeljevanju Java nizov z `split()` lahko uporabite tudi neobvezni parameter `limit`. Parameter `limit` omejuje število ustvarjenih podnizov. Na voljo so tri možnosti: dodelitev vrednosti manjše od 0, 0 ali večje od 0.

### `split()` z omejitvijo manj kot 0

Če za `limit` vnesete vrednost, ki je manjša od 0, se bo redni izraz **uporabil brez omejitve na celoten niz**. Rezultati niz lahko ima poljubno dolžino. Ta koda bi lahko izgledala takole:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", -3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Ker je za zadnjo besedo „sobota“ presledek, se bo niz končal s prazno vrstico. Tukaj je izpis:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

### `split()` z omejitvijo 0

Če nastavite parameter `limit` na 0, se bo redni izraz ponovno uporabil **tolikokrat, kolikor je mogoče**. Dolžina niza ni omejena. Če pa je zadnji element prazen niz, ne bo vključen v končni niz.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", 0);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Izhod je podoben zgornjemu, vendar brez zadnjega niza:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

### `split()` z omejitvijo večjo od 0

Razlika postane bolj očitna, ko nastavite omejitev, večjo od 0. Takrat bo določila, koliko podnizov se lahko izpiše.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", 3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Tako bomo dobili izhod, ki se znatno razlikuje od zgornjih:

```java
Sunday
Monday
Tuesday, Wednesday, Thursday, Friday, Saturday
```


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