# Como usar o método Java string split()

Em Java, uma string pode ser dividida em várias substrings graças ao método Java `string split()`, que aceita um parâmetro como delimitador. Um parâmetro opcional, por sua vez, determina o número de substrings resultantes. Existem algumas peculiaridades importantes ao utilizar esse método.

## O que é o método Java `string split()`?

Uma [string em Java](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-strings/) concatena vários caracteres, dígitos ou caracteres especiais. Ela existe como um objeto na classe `java.lang` e é criada e manipulada usando a classe `String`. A [linguagem de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web") permite dividir essas strings em várias substrings. O método Java `string split()` é usado quando você deseja **extrair certas partes de uma string completa** ou **dividi-la em suas partes individuais**. Vamos mostrar as diferentes possibilidades que este método oferece.

Ao usar o método Java `string split()`, você recebe um array contendo várias strings como valor de retorno.

## Sintaxe e funcionalidade do método Java `string split()`

A sintaxe do método Java `string split()` é bastante simples, mas pode ser expandida com um parâmetro opcional. Esta é a versão básica:

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

Aqui, é indicado que o **retorno é na forma de um array**. `String` é o objeto String. `regex` é um parâmetro de entrada que determina onde a string deve ser dividida. Embora você não seja obrigado a usar este parâmetro, recomenda-se sua utilização. Com o parâmetro opcional `limit`, a sintaxe fica assim:

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

`limit` especifica quantas substrings devem ser criadas. Seu valor é um inteiro. Se for negativo ou igual a 0, todas as substrings serão retornadas. Se for um valor positivo, apenas aquele número de substrings será retornado.

## Java `string split()` com espaço como delimitador

A melhor maneira de entender o método Java `string split()` é ver sua utilização em um exemplo prático. Vamos criar uma string composta por quatro palavras: “Este é um exemplo”. Você pode dividir essa string usando o método. O mais óbvio é dividir ao longo dos espaços entre as palavras. Com o seguinte código, você realiza essa divisão:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Este é um exemplo";
		String[] saída = x.split(" ");
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

Aqui iniciamos uma variável do tipo String chamada `x`. Em seguida, aplicamos o método `String.split()` em `x`. O método `split()` procura espaços na string e a divide nesses pontos. O resultado é armazenado em um array chamado `saída`. Com o laço `for`, esses substrings são listados. Utilizando o [comando Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos em Java") `System.out.println`, você obtém a seguinte saída:

```java
Este
é
um
exemplo
```

## Java `string split()`com vírgula como delimitador (com e sem espaços)

Você também pode utilizar o método para **dividir listas** que foram armazenadas como strings separadas por vírgulas. Aqui, você precisará usar um pequeno truque para garantir que suas instruções sejam executadas corretamente. Vamos considerar uma lista de dias da semana separados por vírgulas. Essas vírgulas são um bom parâmetro para o `regex`. O código ficaria assim:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo";
		String[] saída = x.split(",");
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

A saída, neste caso, pode não ser exatamente a que você deseja:

```java
Segunda-feira
 Terça-feira
 Quarta-feira
 Quinta-feira
 Sexta-feira
 Sábado
 Domingo
```

Assim, você ainda obterá uma lista organizada, mas todos os valores a partir de “Terça-feira” terão um espaço em branco indesejado no início. Como a separação é feita diretamente após a vírgula, o método Java `string split()` inclui esse espaço como a primeira posição na substring. Para contornar esse pequeno problema, basta ajustar o método usando um **espaço adicional como delimitador**. Este é o código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo";
		String[] saída = x.split(", ");
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

Agora a saída será mais organizada:

```java
Segunda-feira
Terça-feira
Quarta-feira
Quinta-feira
Sexta-feira
Sábado
Domingo
```

## Cadeias numéricas separadas

Outra forma de separação é no caso de longas cadeias de números. Como exemplo, vamos considerar uma chave longa que está dividida por pontos e dois-pontos. Se você deseja listar separadamente os números **após o dois-pontos**, este é o código adequado:

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

A saída então ficará assim:

```java
194.518.552.1.17
6339
```

## Método Java `string split()` e parâmetro limit

Como mencionado, o Java string split() também possui o parâmetro opcional `limit`. Este parâmetro limita o número de substrings que são criadas pelo método. Existem três possibilidades para o valor de `limit`: um valor menor que 0, um valor igual a 0 ou um valor maior que 0.

### limit menor que 0

Se você escolher um valor para `limit` que seja menor que 0, a expressão regular será **aplicada à cadeia de caracteres inteira sem restrições**. O array resultante pode ter um comprimento arbitrário. O código exemplificativo seria:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo ";
		String[] saída = x.split(", ", -3);
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

Como há um espaço após o último termo “Domingo”, o array termina com uma string vazia. A saída correspondente é:

```java
Segunda-feira
Terça-feira
Quarta-feira
Quinta-feira
Sexta-feira
Sábado
Domingo
```

### limit igual a 0

Se você escolher o valor 0 para o parâmetro `limit`, a expressão regular será **aplicada ao máximo possível**. A extensão do array também não tem limite. No entanto, se o último elemento for uma string vazia, ele não será incluído no array final.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo ";
		String[] saída = x.split(", ", 0);
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

A saída parecerá a mesma, mas a última string será descartada neste caso.

```java
Segunda-feira
Terça-feira
Quarta-feira
Quinta-feira
Sexta-feira
Sábado
Domingo
```

### limit maior que 0

Obviamente, há diferenças quando você define um valor maior que 0 para `limit`. Isso determina quantas substrings serão geradas. Para o nosso exemplo, isso se apresenta da seguinte forma:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo ";
		String[] saída = x.split(", ", 3);
		for (String y : saída) {
			System.out.println(y);
		}
	}
}
```

Agora recebemos uma saída que já se diferencia à primeira vista das duas anteriores:

```java
Segunda-feira
Terça-feira
Quarta-feira, Quinta-Feira, Sexta-Feira, Sábado, Domingo
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-string-split/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-string-split/) for AI/LLM consumption.