# Kā sadalīt virknes Java

Metode `split()` var tikt izmantota, lai sadalītu virknes Java. Tā satur parametru atdalītājam un papildu parametru apakšvirkņu skaitam. Ir arī dažas īpatnības, kas jāņem vērā, izmantojot šo metodi. Mēs izskaidrosim visu, kas jums jāzina.

## Kas ir `split()`?

[Java virknes](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-virknes/) savieno rakstzīmes, ciparus un īpašos simbolus. Tās pastāv kā objekti klasē java.lang un tiek izveidotas un modificētas ar String klasi. Java programmēšanas valodā virknes var arī sadalīt dažādās apakšvirknēs. Java split() tiek izmantots, lai **izvilktu noteiktus segmentus no virknes** vai sadalītu to **atsevišķās daļās**. Turpinājumā mēs parādīsim sīkāk, ko var izdarīt ar šo metodi.

Dalot Java virkni ar split(), jūs iegūsiet masīvu ar vairākām virknēm. Tas kļūst par atgriešanas vērtību.

## Kāda ir Java `split()` sintakse?

Java `split()` pamata sintakse ir ļoti vienkārša, bet to var paplašināt ar papildu parametriem. Šeit ir pamata versija:

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

Šajā piemērā **izvade būs masīva veidā**. `String` ir string objekts. `regex` ir parametrs, kas tiek izmantots, lai noteiktu, kur string ir jāsadala. Parametrs nav obligāts, bet tā izmantošana ir ieteicama.

Papildu fakultatīvais parametrs `limit` ļauj norādīt, cik daudz apakšvirknes ir jāizveido. Tā vērtība ir vesels skaitlis. Ja tā ir nulle vai negatīva, izvades rezultātā tiks iekļautas visas apakšvirknes. Ja izvēlaties pozitīvu vērtību, izvades rezultātā tiks iekļauts norādītais apakšvirkņu skaits. Ar papildu fakultatīvo parametru `limit` sintakse izskatīsies šādi:

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

## Kā lietot `split()` ar atstarpi kā atdalītāju

Apskatīsim dažus praktiskus piemērus. Vispirms izveidosim virkni, kas satur 4 vārdus: „This is an example”. Tad sadalīsim virkni, izmantojot `split()`. Intuitīvākais veids, kā sadalīt šo virkni, ir izmantot jau esošos **atstarpes starp vārdiem**. Šeit ir redzams, kā tas notiek kodā:

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

Šajā piemērā tiek inicializēta string mainīgā x. Tad uz string tiek izmantota Java `split()`. Parametrs meklē stringā atstarpes un sadala to vietās, kur tās atrod. Rezultāts tiek saglabāts masīvā ar nosaukumu “output”. `for` cilpa tiek izmantota, lai uzskaitītu apakšstringus. Java komanda `System.out.println` mums dod šādu rezultātu:

```java
This
is
an
example
```

## Kā lietot komatu kā atdalītāju, ar atstarpēm un bez tām

Jūs varat izmantot `split()` arī Java valodā ar virknēm, kas satur **ar komatiem atdalītus sarakstus**. Jums vienkārši būs jāizmanto neliels triks, jo Java valodā jūsu instrukcijas tiek īstenotas ļoti precīzi. Vispirms apskatīsim piemēru bez trika. Teiksim, ka mums ir saraksts ar nedēļas dienām, kas atdalītas ar komatiem. Šie komati ir ideāls atdalītājs, lai ievadītu `regex`. Ja mēs izveidojam kodu šādā veidā, tas izskatīsies šādi:

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

Šajā piemērā rezultāts nav pilnīgi ideāls:

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

Rezultāts mums sniedz skaidru nedēļas dienu sarakstu. Tomēr katrai vērtībai pēc svētdienas pirms dienas ir atstarpe. Tā kā mēs izmantojām tikai komatu kā atdalītāju, atstarpes palika tur arī sadalīšanas procesā. Lai iegūtu skaidrāku rezultātu, mums jāizmanto **gan komats, gan atstarpe** kā atdalītājs. Ja to izdarīsim, kods izskatīsies šādi:

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

Rezultāts tagad ir daudz skaidrāks:

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

## Kā sadalīt Java virknes ar cipariem

Jūs varat arī izmantot `split()`, lai sadalītu Java virknes, kas sastāv no cipariem. Mūsu piemērā mēs izmantosim garu atslēgu, kas ir sadalīta, izmantojot punktus un defisi. Ja mēs vēlamies atdalīt ciparus **pēc defises**, kods izskatīsies šādi:

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

Šeit ir rezultāts:

```java
194.518.552.1.17
6339
```

## Kā lietot `split()` ar ierobežojuma parametru

Dalot Java virknes ar `split()`, varat izmantot arī papildu parametru `limit`. Parametrs `limit` ierobežo izveidoto apakšvirkņu skaitu. Šeit ir trīs iespējas: piešķirt tam vērtību, kas ir mazāka par 0, 0 vai lielāka par 0.

### `split()` ar robežu mazāku par 0

Ja ievadāt vērtību `limit`, kas ir mazāka par 0, regulārais izteiksme tiks **piemērota bez ierobežojuma visai virknei**. Rezultātā iegūtais masīvs var būt jebkura garuma. Šis kods var izskatīties šādi:

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

Tā kā pēc pēdējā vārda „Saturday” ir atstarpe, masīvs beigsies ar tukšu virkni. Šeit ir izvade:

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

### `split()` ar ierobežojumu 0

Ja iestatāt parametru `limit` uz 0, regulārais izteiksme atkal tiks izmantota **tik reižu, cik vien iespējams**. Masīva garums arī netiek ierobežots. Taču, ja pēdējais elements ir tukša virkne, tas netiks iekļauts rezultātā iegūtajā masīvā.

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

Rezultāts izskatās līdzīgi kā iepriekš, bet bez pēdējās virknes:

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

### `split()` ar limitu, kas lielāks par 0

Atšķirība kļūst vēl izteiktāka, ja iestatāt robežu, kas ir lielāka par 0. Tad tā noteiks, cik daudz apakšvirknes var izvadīt.

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

Tad iegūsim rezultātu, kas būtiski atšķiras no iepriekš minētajiem:

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


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/string-sadalisana-java/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/string-sadalisana-java/) for AI/LLM consumption.