# Kaip padalyti eilutes Java kalboje

Metodas `split()` gali būti naudojamas eilutėms Java kalboje skaidyti. Jis turi parametrą atskyrikliui ir pasirinktinį parametrą dalinių eilutės skaičiui. Taip pat yra keletas ypatumų, į kuriuos reikia atkreipti dėmesį naudojant šį metodą. Mes paaiškinsime viską, ką reikia žinoti.

## Kas yra `split()`?

[Java eilutės](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-stygos/) jungia simbolius, skaitmenis ir specialiuosius simbolius. Jos egzistuoja kaip objektai klasėje java.lang ir yra kuriamos bei modifikuojamos naudojant String klasę. Java programavimo kalboje taip pat galite atskirti eilutes į skirtingas poeilutes. Java split() naudojama **tam tikriems segmentams iš eilutės išgauti** arba ją suskaidyti į **atskiras dalis**. Toliau pateiksime išsamesnę informaciją apie tai, ką galite daryti naudodami šį metodą.

Skaidydami Java eilutę su split(), gausite masyvą su keliomis eilutėmis. Tai tampa grąžinamuoju reikšme.

## Kokia yra Java `split()` sintaksė?

Java `split()` pagrindinė sintaksė yra labai paprasta, tačiau ją galima išplėsti pasirinktiniais parametrais. Čia pateikiama pagrindinė versija:

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

Šiame pavyzdyje **rezultatas bus pateiktas masyvo forma**. `String` yra stygos objektas. `regex` yra parametras, naudojamas nustatyti, kur stygą reikia padalyti. Parametras nėra privalomas, bet jo naudojimas yra rekomenduojamas.

Papildomas pasirinktinis parametras `limit` leidžia nurodyti, kiek dalinių eilutės turi būti sukurtos. Jo vertė yra sveikasis skaičius. Jei ji yra nulinė arba neigiama, visos dalinės eilutės bus įtrauktos į išvestį. Jei pasirinksite teigiamą vertę, išvestyje gausite tą dalinių eilutės skaičių. Su papildomu pasirinktiniu parametru `limit` sintaksė atrodys taip:

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

## Kaip naudoti `split()` su tarpu kaip skyrikliu

Pažvelkime į keletą praktinių pavyzdžių. Pirmiausia, sukursime eilutę, kurioje yra 4 žodžiai: „Tai yra pavyzdys“. Tada padalinsime eilutę naudodami `split()`. Intuityviausias būdas padalinti šią eilutę yra naudoti jau esančias **tarpą tarp žodžių**. Štai kaip tai atrodo kode:

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

Šiame pavyzdyje inicijuojama stygos kintamasis x. Tada stygai naudojamas Java `split()`. Parametras ieško stygos tarpų ir ją suskaido tose vietose, kur juos randa. Rezultatas tada išsaugomas masyve, pavadintame „output“. `for` kilpa naudojama substrengų sąrašui sudaryti. Java komanda `System.out.println` pateikia mums tokį rezultatą:

```java
This
is
an
example
```

## Kaip naudoti kablelį kaip skyriklį su tarpais ir be tarpų

Java kalboje taip pat galite naudoti `split()` su **komomis atskirtų sąrašų** eilutėmis. Dėl to, kaip tiksliai Java kalboje įgyvendinamos jūsų instrukcijos, turėsite naudoti nedidelį triuką. Pirmiausia pažiūrėkime pavyzdį be triuko. Tarkime, turime savaitės dienų sąrašą, atskirtą kableliais. Šie kableliai yra puikus atskyriklis, kurį galima įvesti į `regex`. Jei kodą nustatysime taip, jis atrodys taip:

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

Šiame pavyzdyje rezultatas nėra visiškai tobulas:

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

Rezultatas pateikia aiškų savaitės dienų sąrašą. Tačiau kiekviena reikšmė po sekmadienio turi tarpelį prieš dieną. Kadangi kaip skyriklį naudojome tik kablelį, tarpeliai liko ir po padalijimo. Norėdami gauti aiškesnį rezultatą, turėtume naudoti **tiek kablelį, tiek tarpelį** kaip skyriklį. Jei tai padarysime, kodas atrodys taip:

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

Dabar išvestis yra daug švaresnė:

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

## Kaip padalyti Java eilutes su skaitmenimis

Taip pat galite naudoti `split()`, kad padalytumėte iš skaitmenų sudarytus Java styginius. Mūsų pavyzdyje paimsime ilgą raktą, kuris yra padalytas naudojant taškus ir dvitaškį. Jei norime atskirti skaitmenis **po dvitaškio**, kodas atrodytų taip:

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

Štai rezultatas:

```java
194.518.552.1.17
6339
```

## Kaip naudoti `split()` su ribos parametru

Skaidydami Java eilutes su `split()`, taip pat galite naudoti pasirinktinį `limit` parametrą. `limit` parametras riboja sukurtų eilutės dalių skaičių. Čia yra trys galimybės: priskirti jam mažesnę nei 0, 0 arba didesnę nei 0 vertę.

### `split()` su riba mažesne nei 0

Jei įvesite `limit` vertę, kuri yra mažesnė nei 0, reguliarioji išraiška bus **taikoma be apribojimų visam strypui**. Galutinis masyvas gali būti bet kokio ilgio. Tas kodas gali atrodyti taip:

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

Kadangi po paskutinio žodžio „Saturday“ yra tarpas, masyvas baigsis tuščiu strypu. Štai rezultatas:

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

### `split()` su riba 0

Jei nustatysite parametrą `limit` į 0, reguliarioji išraiška vėl bus naudojama **tiek kartų, kiek įmanoma**. Masyvo ilgis taip pat nėra ribojamas. Tačiau jei paskutinis elementas yra tuščia eilutė, ji nebus įtraukta į galutinį masyvą.

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

Rezultatas atrodo panašus į pirmiau pateiktą, bet be paskutinės eilutės:

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

### `split()` su riba, didesne nei 0

Skirtumas tampa akivaizdesnis, kai nustatote ribą, didesnę nei 0. Tada ji nustatys, kiek dalinių eilutės gali būti išvestos.

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

Tada gausime rezultatą, kuris žymiai skirsis nuo aukščiau pateiktų:

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


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/stringu-skaidymas-java-kalboje/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/stringu-skaidymas-java-kalboje/) for AI/LLM consumption.