# Kuidas jagada stringe Java-s

Meetodit `split()` saab kasutada stringide jagamiseks Java-s. See sisaldab parameetrit eraldaja jaoks ja valikulist parameetrit alamstringide arvu jaoks. Meetodi kasutamisel tuleb arvestada ka mõningate eripäradega. Selgitame kõike, mida peate teadma.

## Mis on `split()`?

[Java stringid](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-stringid/) ühendavad tähemärke, numbreid ja erimärke. Need eksisteerivad objektidena klassis java.lang ja neid luuakse ja muudetakse klassiga String. Java programmeerimiskeeles saab stringe ka erinevateks alajaotusteks jagada. Java funktsiooni split() kasutatakse **stringist teatud segmentide eraldamiseks** või stringi **üksikuteks osadeks** jagamiseks. Allpool näitame teile üksikasjalikumalt, mida selle meetodiga teha saab.

Kui jagate Java stringi split() abil, saate massiivi mitme stringiga. See muutub tagastatavaks väärtuseks.

## Mis on Java `split()` süntaks?

Java `split()` põhiline süntaks on väga lihtne, kuid seda saab laiendada valikuliste parameetritega. Siin on põhiline versioon:

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

Selles näites **on väljund massiivi kujul**. `String` on string-objekt. `regex` on parameeter, mida kasutatakse stringi jagamise koha määramiseks. Parameeter ei ole kohustuslik, kuid soovitatav.

Lisavalikuline parameeter `limit` võimaldab määrata, kui palju alajaotusi tuleks luua. Selle väärtus on täisarv. Kui see on null või negatiivne, lisatakse väljundisse kõik alajaotused. Kui valite positiivse väärtuse, saate väljundisse selle arvu alajaotusi. Lisavalikulise parameetriga `limit` on süntaks järgmine:

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

## Kuidas kasutada `split()` koos tühikuga eraldajana

Vaadakem mõningaid praktilisi näiteid. Esiteks loome stringi, mis sisaldab 4 sõna: „This is an example”. Seejärel jagame stringi `split()` abil. Kõige intuitiivsem viis stringi jagamiseks on kasutada **sõnade vahel** juba olemasolevaid **tühikuid**. Siin on näide, kuidas see koodis toimub:

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

Selles näites algväärtustatakse string-muutuja x. Seejärel kasutatakse stringi suhtes Java `split()`. Parameeter otsib stringist tühikuid ja jagab selle kohtades, kus neid leiab. Tulemus salvestatakse massiivi nimega „output”. Silmust `for` kasutatakse alamstringide loetlemiseks. Java käsk `System.out.println` annab meile järgmise väljundi:

```java
This
is
an
example
```

## Kuidas kasutada koma eraldajana, tühikute ja tühikute vahel

Java-keeles saab `split()` kasutada ka **komadega eraldatud loenditega** stringide puhul. Selleks on vaja kasutada väikest trikki, kuna Java-keeles rakendatakse juhiseid väga täpselt. Esmalt vaatame näidet ilma trikita. Oletame, et meil on komadega eraldatud nädalapäevade nimekiri. Need komad on ideaalsed eraldajad, et sisestada `regex`-sse. Kui me seadistame koodi selliselt, näeb see välja järgmine:

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

Selles näites ei ole väljund päris täiuslik:

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

Väljund annab meile selge loetelu nädalapäevadest. Siiski sisaldab iga pühapäevale järgnev väärtus tühikut enne päeva. Kuna kasutasime eraldajana ainult koma, jäid tühikud jagamise protsessis sinna alles. Puhtama väljundi saamiseks peaksime eraldajana kasutama **nii koma kui ka tühikut**. Kui teeme seda, näeb kood välja järgmine:

```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äljund on nüüd palju puhtam:

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

## Kuidas jagada Java stringid numbritega

Võite kasutada `split()` ka numbritest koosnevate Java-stringide jagamiseks. Meie näites võtame pika võtme, mis on jagatud punktide ja kooloniga. Kui soovime eraldada numbrid **kooloni järel**, näeks kood välja järgmine:

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

Siin on väljund:

```java
194.518.552.1.17
6339
```

## Kuidas kasutada `split()` koos piiranguparameetriga

Java-stringide jagamisel `split()` võite kasutada ka valikulist parameetrit `limit`. Parameeter `limit` piirab loodavate alastringide arvu. Siin on kolm võimalust: määrata sellele väärtus väiksem kui 0, 0 või suurem kui 0.

### `split()`, mille piir on väiksem kui 0

Kui sisestate väärtuse `limit`, mis on väiksem kui 0, **rakendatakse** regulaaravaldist **piiranguta kogu stringile**. Saadud massiiv võib olla mis tahes pikkusega. See kood võib välja näha järgmine:

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

Kuna viimase sõna „Saturday” järel on tühik, lõpeb massiiv tühja stringiga. Siin on väljund:

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

### `split()` piiranguga 0

Kui seadistate parameetri `limit` väärtuseks 0, kasutatakse regulaaravaldist taas **nii palju kordi kui võimalik**. Massiivi pikkus ei ole samuti piiratud. Kuid kui viimane element on tühi string, ei lisata seda tulemusmassiivi.

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

Väljund on sarnane eespool tooduga, kuid ilma viimase stringita:

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

### `split()`, mille piir on suurem kui 0

Erinevus muutub selgemaks, kui seadistate piirväärtuse suuremaks kui 0. Siis määrab see, kui palju alamstringe saab väljastada.

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

Siis saame tulemuse, mis erineb oluliselt eespool toodutest:

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


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