# Java: il metodo String split() nella pratica

Il metodo Java String `split()` è utile per suddividere le stringhe in varie sottostringhe. Durante questa operazione si specifica un parametro che agisce da separatore e uno (opzionale) che regola il numero di sottostringhe. Di seguito ti spieghiamo come funziona questo metodo e ti illustriamo alcuni aspetti da tenere in considerazione.

## Cos’è il metodo Java String `split()`?

Una [stringa Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string/) è un oggetto che rappresenta più caratteri, numeri o caratteri speciali. Esiste nella classe java.lang e viene creata e modificata mediante la classe String. Con questo [linguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/) hai la possibilità di suddividere queste stringhe in più sottostringhe. Il metodo Java String split() si usa per estrarre **determinate porzioni di un’intera stringa** o per suddividerla in **singole parti**. Ti mostriamo le diverse opzioni a tua disposizione.

Usando il metodo Java String split() si ottiene un array composto da più stringhe. Questo viene definito valore di ritorno.

## Sintassi e funzionamento del metodo

Sostanzialmente la sintassi del metodo Java String split() è molto semplice e, se necessario, può essere completata con un parametro. La variante di base è la seguente:

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

L’output ci mostra che **il valore di ritorno è un array**. `String` è l’oggetto della stringa. Il parametro `regex` è un input utilizzato per indicare i punti in cui la stringa dovrà essere suddivisa. I parametri non devono essere usati necessariamente, ma sono sempre consigliati. Con il parametro opzionale `limit` il codice avrà questa sintassi:

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

`limit` specifica quante sottostringhe andranno create. Il suo valore è un numero intero. Se questo è negativo o pari a zero, l’output visualizza tutte le sottostringhe. Se invece si sceglie un valore positivo, le sottostringhe visualizzate corrisponderanno a quel numero.

## Esempio di metodo con spazi e trattini

Per capire meglio come funziona Java String `split()` vediamo da vicino un esempio pratico. A questo scopo, creiamo una stringa composta da quattro parole: “Questo è un esempio”. Ora usiamo il metodo split() per suddividere la stringa. Il modo più logico è quello di dividerla in base agli **spazi tra una parola e l’altra**. Per suddividere la stringa puoi usare il seguente codice:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Questo è un esempio";
		String[] risultato = x.split(" ");
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

A questo scopo viene iniziata solo una variabile di String x. Successivamente, Java usa il metodo String `split()` su x. Il parametro `regex` cerca gli spazi all’interno della stringa e la divide in quei punti. Il risultato viene quindi salvato in un array denominato “risultato”. Queste sottostringhe vengono eseguite con il ciclo `for`. Con l’aiuto del [comando Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/comandi-java/) `System.out.println` si ottiene il seguente output:

```java
Questo
è
un
esempio
```

## Virgola come elemento di separazione: con e senza spazio

Puoi usare questo metodo anche per **separare elenchi** divisi da una virgola e salvati come stringa. Tuttavia, occorre adottare un piccolo accorgimento in grado di mostrare direttamente come vengono messe in pratica le istruzioni. Consideriamo un elenco dei giorni della settimana, ciascuno separato da virgole. Queste virgole rappresentano un buon parametro da utilizzare per `regex`. Usandolo, il codice si scrive così:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunedì, martedì, mercoledì, giovedì, venerdì, sabato, domenica";
		String[] risultato = x.split(",");
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

Ma in questo caso il risultato non sarà proprio ideale:

```java
lunedì
 martedì
 mercoledì
 giovedì
 venerdì
 sabato
 domenica
```

Infatti, otteniamo un elenco ordinato, ma notiamo che tutti i valori da “martedì” in poi sono preceduti da uno spazio. Questo succede perché la divisione viene eseguita direttamente dopo la virgola corrispondente e Java String `split()` include lo spazio come prima posizione nella relativa sottostringa. È possibile risolvere questo piccolo problema semplicemente modificando il parametro, ovvero **aggiungendo uno spazio supplementare come separatore**. Lo snippet di codice sarà il seguente:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunedì, martedì, mercoledì, giovedì, venerdì, sabato, domenica";
		String[] risultato = x.split(", ");
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

Ora l’output risulta molto più ordinato:

```java
lunedì
martedì
mercoledì
giovedì
venerdì
sabato
domenica
```

## Suddividere le sequenze di numeri

Nel caso di lunghe sequenze di numeri esiste un altro modo per suddividere la stringa. In questo contesto immaginiamo una lunga sequenza di numeri divisa da punti e da due punti. Ora, se desideriamo elencare separatamente i numeri **dopo i due punti**, dovremo digitare il seguente snippet di codice:

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

L’output sarà il seguente:

```java
194.518.552.1.17
6339
```

## Il metodo Java String `split()` con il parametro limit

Come già accennato, Java String `split()` conosce anche il parametro opzionale `limit`. Questo limita il numero di sottostringhe create con il metodo. In questo caso ci sono tre possibilità: un valore inferiore a 0, un valore uguale a 0 e un valore superiore a 0.

### limit inferiore a 0

Se assegniamo al parametro limit un valore più piccolo di 0, l’espressione regolare **sarà applicata su tutta la sequenza di caratteri**. L’array che si crea può avere una lunghezza variabile. Questo il codice:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunedì, martedì, mercoledì, giovedì, venerdì, sabato, domenica ";
		String[] risultato = x.split(", ", -3);
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

Poiché dopo il termine “domenica” c’è ancora uno spazio, in questo caso l’array termina con una stringa vuota. Questo l’output:

```java
lunedì
martedì
mercoledì
giovedì
venerdì
sabato
domenica
```

### limit 0

Assegnando il valore 0 al parametro `limit`, l’espressione regolare viene **ripetuta continuativamente**. Neanche la lunghezza dell’array è limitata. Se l’ultimo elemento corrisponde a una stringa vuota, questa non viene tenuta in considerazione per l’array finale.

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunedì, martedì, mercoledì, giovedì, venerdì, sabato, domenica ";
		String[] risultato = x.split(", ", 0);
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

L’output è identico, ma l’ultima stringa viene eliminata;

```java
lunedì
martedì
mercoledì
giovedì
venerdì
sabato
domenica
```

### limit superiore a 0

Il risultato è molto differente se assegniamo a `limit` un valore superiore a 0. Questo determina il numero di sottostringhe dell’output. Nel nostro esempio, il codice è il seguente:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunedì, martedì, mercoledì, giovedì, venerdì, sabato, domenica ";
		String[] risultato = x.split(", ", 3);
		for (String y : risultato) {
			System.out.println(y);
		}
	}
}
```

In questo caso l’output è chiaramente diverso rispetto ai due esempi precedenti:

```java
lunedì
martedì
mercoledì, giovedì, venerdì, sabato, domenica
```


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string-split/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string-split/) for AI/LLM consumption.