# Usos práticos da função split() em Java

O método string split() em Java é utilizado para dividir strings em diferentes partes. Para isso, recorre-se a um parâmetro que funciona como separador. Também é possível utilizar um parâmetro para regular o número de substrings. É importante considerar algumas características especiais ao utilizar o método.

## Em que consiste o método Java string split()?

Uma [string Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/strings-java/) encadeia várias letras, números ou caracteres especiais. Ela existe como objeto na classe java.lang e é criada e editada com a classe string. Essa linguagem de programação permite separar as strings em diferentes partes. O método Java string split() é usado se você deseja **extrair** apenas **certas áreas de toda a string** ou decompor-la em **elementos individuais**. Vamos mostrar as diferentes opções que esse método oferece.

Se incorporar uma string split() em Java, ela retornará uma matriz de várias strings. Isso se torna o valor de retorno.

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

A sintaxe do método string split() do Java é muito simples, mas pode ser ampliada com parâmetros opcionais. A versão principal é a seguinte:

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

Aqui, observa-se que o Java **retorna um resultado na forma de uma matriz**. `String` é o objeto string. `regex` é um parâmetro de entrada usado para indicar onde a string deve ser dividida. Embora não seja obrigatório usar esse parâmetro, é recomendável utilizá-lo. Com o parâmetro opcional `limit`, a sintaxe é a seguinte:

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

`limit` indica em quantos componentes a string é dividida. O valor é um número inteiro: se for negativo ou igual a 0, todas as subcadeias serão devolvidas. Se escolher um valor positivo, apenas o número correspondente de subcadeias será apresentado.

## Exemplo do método separando com espaços

Para entender como funciona o string split() em Java, o melhor é usar um exemplo prático. Criámos uma string com quatro palavras: «Este é um exemplo». Pode dividir esta string usando o método string split(). O mais lógico é separar as palavras entre os delimitadores criados pelos **espaços entre as palavras**. Pode separar a string com o seguinte código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Esto es un ejemplo";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Agora será iniciada uma variável de string x. Em seguida, Java aplicará o método string split() a x. O parâmetro `regex` procura espaços na string e divide-a nesse ponto. O resultado é armazenado numa matriz chamada «output». Essas sub-strings são enumeradas com o loop `for`. Graças ao comando Java `System.out.println`, obterá o seguinte resultado.

```java
Esto
es
un
ejemplo
```

## A vírgula como separador com e sem espaços

Você também pode usar esse método para **subdividir listas** que foram separadas por vírgulas e armazenadas como uma string. Para isso, é preciso recorrer a um pequeno truque que dirá como as instruções que você fornecer devem ser implementadas. Imagine uma lista com os dias da semana, cada um separado por uma vírgula. As vírgulas são um bom parâmetro para `regex`. Se você as usar, o código terá a seguinte aparência:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo";
		String[] output = x.split(",");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

O resultado neste caso não será o ideal:

```java
lunes
 martes
 miércoles
 jueves
 viernes
 sábado
 domingo
```

Assim, obtém-se uma lista clara, mas todos os valores a partir de «terça-feira» têm um espaço no início. Como a divisão é sempre aplicada após a vírgula obrigatória, o string split() em Java inclui esse espaço no início da subcadeia. Para evitar esse problema, basta modificar o método com um **espaço adicional como separador**. Este seria o código:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo";
		String[] output = x.split(", ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Agora parece muito mais organizado:

```java
lunes
martes
miércoles
jueves
viernes
sábado
domingo
```

## Separar cadeias de dígitos

Este método também permite separar longas cadeias de dígitos. Como exemplo, imaginemos uma chave longa dividida por pontos e dois pontos. Se quiser separar os dígitos que vêm **depois dos dois pontos**, deve usar este código:

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

O programa irá retornar o seguinte:

```java
194.518.552.1.17
6339
```

## O método String split() do Java com o parâmetro limit

Como mencionado anteriormente, string split() também pode ser combinado com o parâmetro `limit`. Este restringe o número de componentes criados por string split(). Existem três opções de valores: valor menor que 0, igual a 0 ou maior que 0.

### limite menor que 0

Se escolher um valor menor que zero com limit, a expressão regular **será aplicada a toda a cadeia de caracteres sem restrições**. O conjunto resultante pode ter qualquer comprimento. O código será o seguinte:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", -3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Após o último conceito, «domingo», há um espaço, pelo que a matriz termina com uma string vazia. O resultado é o seguinte:

```java
lunes
martes
miércoles
jueves
viernes
sábado
domingo
```

### limite 0

Se o valor do parâmetro `limit` for 0, a expressão regular também será utilizada **com a maior frequência possível**. O comprimento da matriz não é limitado. No entanto, se o último elemento for uma string vazia, a matriz final não o terá em consideração.

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", 0);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

O resultado é o mesmo, mas a última string é descartada:

```java
martes
miércoles
jueves
viernes
sábado
domingo
```

### limite maior que 0

Se `limit` tiver um valor maior que 0, obviamente haverá diferenças. Este número determinará quantas subcadeias o Java retorna. Para o exemplo em questão, o código é o seguinte:

```java
public class Main {
	public static void main(String[] args) {
		String x = "lunes, martes, miércoles, jueves, viernes, sábado, domingo ";
		String[] output = x.split(", ", 3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Este resultado difere dos dois anteriores à primeira vista:

```java
lunes
martes
miércoles, jueves, viernes, sábado, domingo
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/divisao-de-cadeias-de-caracteres-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/divisao-de-cadeias-de-caracteres-java/) for AI/LLM consumption.