Dividir string em ArrayList Java: Guia com Delimitadores

Introdução

Na programação Java, manipular strings e trabalhar com coleções como ArrayList são habilidades essenciais. Este tutorial guia você através do processo de dividir uma string em um ArrayList usando um delimitador em Java. Ao final deste laboratório, você entenderá como quebrar dados de texto em pedaços gerenciáveis e armazená-los em uma coleção flexível, permitindo que você lide com várias tarefas de processamento de dados em suas aplicações Java.

Compreendendo Strings e ArrayLists em Java

Antes de mergulharmos na divisão de strings, vamos entender os dois componentes-chave com os quais trabalharemos neste laboratório.

Strings em Java

Uma String em Java é uma sequência de caracteres. É uma das classes mais comumente usadas na programação Java. Strings são imutáveis, o que significa que, uma vez criadas, seus valores não podem ser alterados.

Por exemplo:

String greeting = "Hello, World!";

ArrayLists em Java

Um ArrayList é uma implementação de array redimensionável em Java. Ao contrário dos arrays regulares que têm um tamanho fixo, os ArrayLists podem crescer ou diminuir dinamicamente. Eles fazem parte do Java Collections Framework e fornecem vários métodos para manipular os elementos armazenados.

Para usar ArrayList, precisamos importá-lo do pacote java.util:

import java.util.ArrayList;

Criando um ArrayList:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

Agora, vamos criar um novo arquivo Java para começar a trabalhar com esses conceitos. Siga estes passos:

Abra a WebIDE no seu ambiente LabEx
Navegue até o diretório do projeto (ele deve estar aberto por padrão)
Crie um novo arquivo chamado StringSplitDemo.java clicando no ícone "New File" no editor
Adicione o seguinte código básico para criar uma classe Java simples:

public class StringSplitDemo {
    public static void main(String[] args) {
        // We will add our code here
        System.out.println("String Split Demo");
    }
}

Salve o arquivo pressionando Ctrl+S
Abra o terminal na IDE (se ainda não estiver aberto) e compile o arquivo Java:

javac StringSplitDemo.java

Execute o programa:

java StringSplitDemo

Você deve ver a saída:

String Split Demo

Isso confirma que sua configuração básica do Java está funcionando corretamente. No próximo passo, aprenderemos como dividir uma string usando o método split().

Dividindo Strings Usando o Método split()

Java fornece um método embutido chamado split() na classe String que nos permite dividir uma string em partes com base em um delimitador. O método retorna um array de strings contendo as substrings divididas pelo delimitador.

O Método split()

O método split() recebe uma expressão regular como parâmetro e retorna um array de substrings:

String[] split(String regex)

Vamos modificar nosso arquivo StringSplitDemo.java para incluir código que divide uma string. Abra o arquivo no editor e atualize-o da seguinte forma:

public class StringSplitDemo {
    public static void main(String[] args) {
        // Create a string with comma-separated values
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Original string: " + csvData);

        // Split the string using comma as delimiter
        String[] fruits = csvData.split(",");

        // Print the resulting array
        System.out.println("\nAfter splitting:");
        System.out.println("Number of elements: " + fruits.length);

        // Display each element of the array
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Element " + i + ": " + fruits[i]);
        }
    }
}

Salve o arquivo e execute o programa:

javac StringSplitDemo.java
java StringSplitDemo

Você deve ver uma saída semelhante a:

Original string: apple,banana,orange,grape,mango

After splitting:
Number of elements: 5
Element 0: apple
Element 1: banana
Element 2: orange
Element 3: grape
Element 4: mango

Isso demonstra como o método split() divide a string original em cada vírgula e coloca cada substring em um array. O array fruits agora contém cinco elementos, cada um representando um nome de fruta da nossa string original separada por vírgulas.

No próximo passo, converteremos este array em um ArrayList para maior flexibilidade na manipulação dos dados.

Convertendo uma String Dividida para um ArrayList

Agora que dividimos nossa string em um array, vamos convertê-lo para um ArrayList. ArrayLists oferecem mais flexibilidade do que arrays, incluindo redimensionamento dinâmico e métodos convenientes para adicionar, remover e manipular elementos.

Convertendo um Array para ArrayList

Existem várias maneiras de converter um array para um ArrayList em Java:

Usando Arrays.asList() e o construtor ArrayList
Usando um loop para adicionar cada elemento individualmente
Usando a Java 8 Stream API

Vamos atualizar nosso arquivo StringSplitDemo.java para incluir a conversão para ArrayList. Precisaremos importar as classes necessárias do pacote java.util:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSplitDemo {
    public static void main(String[] args) {
        // Create a string with comma-separated values
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Original string: " + csvData);

        // Split the string using comma as delimiter
        String[] fruits = csvData.split(",");

        // Print the resulting array
        System.out.println("\nAfter splitting into array:");
        System.out.println("Number of elements: " + fruits.length);

        // Display each element of the array
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Array Element " + i + ": " + fruits[i]);
        }

        // Method 1: Convert to ArrayList using Arrays.asList() and the ArrayList constructor
        ArrayList<String> fruitList1 = new ArrayList<>(Arrays.asList(fruits));

        // Method 2: Convert to ArrayList using a loop
        ArrayList<String> fruitList2 = new ArrayList<>();
        for (String fruit : fruits) {
            fruitList2.add(fruit);
        }

        // Display the ArrayList created using Method 1
        System.out.println("\nAfter converting to ArrayList (Method 1):");
        System.out.println("Number of elements: " + fruitList1.size());

        for (int i = 0; i < fruitList1.size(); i++) {
            System.out.println("ArrayList Element " + i + ": " + fruitList1.get(i));
        }

        // Demonstrate adding a new element to the ArrayList
        fruitList1.add("pineapple");
        System.out.println("\nAfter adding a new element to ArrayList:");
        System.out.println("Number of elements: " + fruitList1.size());
        System.out.println("New element: " + fruitList1.get(fruitList1.size() - 1));
    }
}

Salve o arquivo e execute o programa:

javac StringSplitDemo.java
java StringSplitDemo

Você deve ver uma saída semelhante a:

Original string: apple,banana,orange,grape,mango

After splitting into array:
Number of elements: 5
Array Element 0: apple
Array Element 1: banana
Array Element 2: orange
Array Element 3: grape
Array Element 4: mango

After converting to ArrayList (Method 1):
Number of elements: 5
ArrayList Element 0: apple
ArrayList Element 1: banana
ArrayList Element 2: orange
ArrayList Element 3: grape
ArrayList Element 4: mango

After adding a new element to ArrayList:
Number of elements: 6
New element: pineapple

Este exemplo demonstra como converter um array de strings em um ArrayList e mostra uma das vantagens de usar um ArrayList: a capacidade de adicionar facilmente novos elementos à coleção.

Observe as diferenças entre arrays e ArrayLists:

Arrays têm um tamanho fixo, enquanto ArrayLists podem crescer dinamicamente
ArrayLists fornecem métodos como add(), remove() e get() para manipular elementos
ArrayLists só podem armazenar objetos, não tipos primitivos (embora Java lide automaticamente com a conversão usando autoboxing)

No próximo passo, exploraremos diferentes delimitadores para dividir strings.

Trabalhando com Diferentes Delimitadores

Nos passos anteriores, usamos uma vírgula como nosso delimitador para dividir a string. No entanto, o método split() aceita qualquer expressão regular como delimitador, permitindo-nos dividir strings com base em vários padrões.

Vamos criar um novo arquivo Java para experimentar diferentes delimitadores. Crie um arquivo chamado DelimiterDemo.java com o seguinte conteúdo:

import java.util.ArrayList;
import java.util.Arrays;

public class DelimiterDemo {
    public static void main(String[] args) {
        // 1. Splitting by a single character
        String commaString = "red,green,blue,yellow";
        ArrayList<String> colors = new ArrayList<>(Arrays.asList(commaString.split(",")));

        System.out.println("1. Splitting by comma:");
        for (String color : colors) {
            System.out.println("  " + color);
        }

        // 2. Splitting by space
        String spaceString = "Java Python C++ JavaScript Ruby";
        ArrayList<String> languages = new ArrayList<>(Arrays.asList(spaceString.split(" ")));

        System.out.println("\n2. Splitting by space:");
        for (String language : languages) {
            System.out.println("  " + language);
        }

        // 3. Splitting by multiple characters
        String pipeColonString = "name|John:age|30:city|New York";
        ArrayList<String> personData = new ArrayList<>(Arrays.asList(pipeColonString.split("[|:]")));

        System.out.println("\n3. Splitting by multiple characters (| or :):");
        for (String data : personData) {
            System.out.println("  " + data);
        }

        // 4. Splitting by digits
        String digitsString = "apple123banana456cherry";
        ArrayList<String> fruits = new ArrayList<>(Arrays.asList(digitsString.split("\\d+")));

        System.out.println("\n4. Splitting by digits:");
        for (String fruit : fruits) {
            System.out.println("  " + fruit);
        }

        // 5. Limiting the number of splits
        String limitString = "one-two-three-four-five";
        ArrayList<String> limitedParts = new ArrayList<>(Arrays.asList(limitString.split("-", 3)));

        System.out.println("\n5. Limiting the number of splits (limit=3):");
        for (String part : limitedParts) {
            System.out.println("  " + part);
        }
    }
}

Salve o arquivo e execute o programa:

javac DelimiterDemo.java
java DelimiterDemo

Você deve ver uma saída semelhante a:

1. Splitting by comma:
  red
  green
  blue
  yellow

2. Splitting by space:
  Java
  Python
  C++
  JavaScript
  Ruby

3. Splitting by multiple characters (| or :):
  name
  John
  age
  30
  city
  New York

4. Splitting by digits:
  apple
  banana
  cherry

5. Limiting the number of splits (limit=3):
  one
  two
  three-four-five

Entendendo Diferentes Tipos de Delimitadores

Delimitador de Caractere Único: A forma mais simples, como vírgulas ou espaços.
```
string.split(",")
```
Delimitadores de Classe de Caracteres: Dividir por qualquer caractere em um conjunto.
```
string.split("[|:]")  // Dividir por '|' ou ':'
```
Delimitadores de Expressão Regular: Para padrões mais complexos.
```
string.split("\\d+")  // Dividir por um ou mais dígitos
```
Limitando Divisões: O segundo parâmetro limita o número de divisões.
```
string.split("-", 3)  // Máx. 3 partes (2 divisões)
```

Caracteres Especiais em Expressões Regulares

Ao usar expressões regulares como delimitadores, certos caracteres têm significados especiais e devem ser escapados com uma barra invertida (\). Como a própria barra invertida precisa ser escapada em strings Java, você acaba com barras invertidas duplas (\\).

Alguns caracteres especiais comuns:

\d - Corresponde a qualquer dígito (em Java, escreva como \\d)
\s - Corresponde a qualquer caracttere de espaço em branco (em Java, escreva como \\s)
. - Corresponde a qualquer caractere (em Java, escreva como \\.)
+, *, ? - Quantificadores (em Java, escreva como \\+, \\*, \\?)

Esses exemplos demonstram a versatilidade do método split() para lidar com vários formatos de string e requisitos em seus aplicativos Java.

Resumo

Neste laboratório, você aprendeu como dividir strings em ArrayLists usando delimitadores em Java. Você adquiriu experiência prática com:

Compreensão e trabalho com Strings e ArrayLists em Java
Usando o método split() para dividir strings com base em delimitadores
Convertendo arrays de strings para ArrayLists para uma manipulação de dados mais flexível
Trabalhando com diferentes tipos de delimitadores, incluindo caracteres únicos, classes de caracteres e expressões regulares
Controlando o processo de divisão com parâmetros de limite

Essas habilidades de manipulação de strings são fundamentais na programação Java e o ajudarão em vários cenários, incluindo análise de dados de arquivos, processamento de entrada do usuário e trabalho com formatos de texto estruturados como CSV ou JSON.

Ao combinar o poder das expressões regulares com coleções Java como ArrayList, você pode processar e transformar dados de string de forma eficiente para atender aos requisitos de seus aplicativos.

Como dividir uma string em um ArrayList usando um delimitador em Java

Introdução

Compreendendo Strings e ArrayLists em Java

Strings em Java

ArrayLists em Java

Dividindo Strings Usando o Método split()

O Método split()

Convertendo uma String Dividida para um ArrayList

Convertendo um Array para ArrayList

Trabalhando com Diferentes Delimitadores

Entendendo Diferentes Tipos de Delimitadores

Caracteres Especiais em Expressões Regulares

Resumo