# Kuinka jakaa merkkijonoja Java-kielellä

Menetelmää `split()` voidaan käyttää merkkijonojen jakamiseen Java-kielessä. Se sisältää parametrin erottimelle ja valinnaisen parametrin alimerkkijonojen lukumäärälle. Menetelmän käytössä on myös joitakin erityispiirteitä, jotka on syytä huomioida. Selitämme kaiken, mitä sinun tarvitsee tietää.

## Mikä on `split()`?

[Java-merkkijonot](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-merkkijonot-1/) yhdistävät merkkejä, numeroita ja erikoismerkkejä. Ne ovat java.lang-luokan objekteja, ja niitä luodaan ja muokataan String-luokan avulla. Java-ohjelmointikielessä merkkijonot voidaan myös jakaa eri alimerkkijonoihin. Java-kielen split()-funktiota käytetään **tiettyjen segmenttien erottamiseen merkkijonosta** tai merkkijonon jakamiseen **yksittäisiin osiin**. Seuraavassa esitämme tarkemmin, mitä tällä menetelmällä voidaan tehdä.

Kun jaat Java-merkkijonon split()-funktiolla, saat taulukon, jossa on useita merkkijonoja. Tämä tulee palautusarvoksi.

## Mikä on Java `split()`:n syntaksi?

Java `split()` n perusrakenteet ovat hyvin yksinkertaisia, mutta niitä voidaan laajentaa valinnaisilla parametreilla. Tässä on perusversio:

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

Tässä esimerkissä **tulos on taulukon muodossa**. `String` on merkkijono-objekti. `regex` on parametri, jota käytetään määrittämään, mistä merkkijono tulisi jakaa. Parametri ei ole pakollinen, mutta sen käyttö on suositeltavaa.

Lisäparametrilla `limit` voit määrittää, kuinka monta alimerkkijonoa luodaan. Sen arvo on kokonaisluku. Jos se on nolla tai negatiivinen, kaikki alimerkkijonot sisällytetään tulosteeseen. Jos valitset positiivisen arvon, tulosteeseen lisätään kyseinen määrä alimerkkijonoja. Lisäparametrilla `limit` syntaksi on seuraava:

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

## Kuinka käyttää `split()` välilyönnillä erottimena

Katsotaanpa muutamia käytännön esimerkkejä. Ensin luomme merkkijonon, joka sisältää neljä sanaa: “This is an example”. Sitten jaamme merkkijonon käyttämällä luk `split()`. Intuitiivisin tapa jakaa tämä merkkijono on käyttää **sanojen välisiä** jo olemassa olevia **välilyöntejä**. Näin se tapahtuu koodissa:

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

Tässä esimerkissä alustetaan merkkijonomuuttuja x. Sitten merkkijonoon käytetään Java-komentoa `split()`. Parametri etsii merkkijonosta välilyöntejä ja jakaa sen välilyöntien kohdista. Tulos tallennetaan sitten taulukkoon nimeltä “output”. Silmukkaa `for` käytetään alimerkkijonojen luettelointiin. Java-komento `System.out.println` antaa seuraavan tuloksen:

```java
This
is
an
example
```

## Kuinka käyttää pilkkua erottimena, välilyönnillä ja ilman välilyöntejä

Voit käyttää `split()` myös Java-kielessä merkkijonoissa, jotka sisältävät **pilkuilla erotettuja luetteloita**. Sinun on vain käytettävä pientä temppua, koska ohjeesi toteutetaan Java-kielessä hyvin tarkasti. Katsotaan ensin esimerkki ilman temppua. Oletetaan, että meillä on luettelo viikonpäivistä, jotka on erotettu toisistaan pilkuilla. Nämä pilkut ovat täydellinen erottimena `regex` syöttämiseen. Jos asetamme koodin tällä tavalla, se näyttää seuraavalta:

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

Tässä esimerkissä tulos ei ole aivan täydellinen:

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

Tuloksena saamme selkeän luettelon viikonpäivistä. Kuitenkin jokaisen sunnuntain jälkeisen arvon edessä on välilyönti. Koska käytimme erottimena vain pilkkua, välilyönnit jäivät paikalleen jakamisprosessin aikana. Saadaksemme siistimmän tuloksen, meidän tulisi käyttää **sekä pilkkua että välilyöntiä** erottimena. Jos teemme niin, koodi näyttää seuraavalta:

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

Tulostus on nyt paljon selkeämpi:

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

## Kuinka jakaa Java-merkkijonot numeroilla

Voit myös käyttää `split()` jakamaan Java-merkkijonoja, jotka koostuvat numeroista. Esimerkissämme otamme pitkän avaimen, joka on jaettu pisteillä ja kaksoispisteellä. Jos haluamme erottaa **kaksoispisteen jälkeiset** numerot, koodi näyttäisi tältä:

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

Tässä on tulos:

```java
194.518.552.1.17
6339
```

## Kuinka käyttää `split()` rajoitusparametrilla

Kun jaat Java-merkkijonoja `split()`lla, voit käyttää myös valinnaista `limit`. `limit` rajoittaa luotavien alimerkkijonojen määrää. Tähän on kolme vaihtoehtoa: voit määrittää sille arvon, joka on pienempi kuin 0, 0 tai suurempi kuin 0.

### `split()`, jonka raja-arvo on alle 0

Jos syötät arvoon `limit` alle 0 olevan arvon, säännöllinen lauseke **sovelletaan ilman rajoitusta koko merkkijonoon**. Tuloksena oleva taulukko voi olla minkä tahansa pituinen. Koodi voi näyttää seuraavalta:

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

Koska viimeisen sanan “Saturday” jälkeen on välilyönti, taulukko päättyy tyhjään merkkijonoon. Tässä on tulos:

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

### `split()`, raja-arvo 0

Jos asetat parametrin `limit` arvoksi 0, säännöllistä lauseketta käytetään jälleen **niin monta kertaa kuin mahdollista**. Taulukon pituutta ei myöskään rajoiteta. Jos viimeinen elementti on tyhjä merkkijono, sitä ei kuitenkaan sisällytetä tuloksena olevaan taulukkoon.

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

Tulostus näyttää samanlaiselta kuin yllä, mutta ilman viimeistä merkkijonoa:

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

### `split()`, jonka raja-arvo on suurempi kuin 0

Ero tulee selvemmin esiin, kun asetat rajaksi arvon, joka on suurempi kuin 0. Silloin se määrittää, kuinka monta alimerkkijonoa voidaan tulostaa.

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

Sitten saamme tuloksen, joka eroaa merkittävästi yllä olevista:

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


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/merkkijonon-jakaminen-java-kielessae/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/merkkijonon-jakaminen-java-kielessae/) for AI/LLM consumption.