LabEx
EntrarJunte-se

Arrays e ArrayLists em Java

JavaBeginner
Pratique Agora

Introdução

Neste laboratório, vamos mergulhar em duas estruturas de dados fundamentais em Java: Arrays e ArrayLists. Essas estruturas nos permitem armazenar e manipular coleções de dados, o que é crucial para muitas tarefas de programação. Começaremos com o array básico e, em seguida, passaremos para o ArrayList, que é mais flexível. Ao final deste laboratório, você será capaz de criar, manipular e trabalhar com arrays e ArrayLists em Java.

Vamos cobrir:

  1. Criando e usando arrays
  2. Acessando e modificando elementos de arrays
  3. Introdução aos ArrayLists
  4. Adicionando, removendo e acessando elementos em ArrayLists
  5. Convertendo entre arrays e ArrayLists

Vamos começar a organizar nossos dados!

Criando e Usando Arrays

Arrays são uma estrutura de dados fundamental em Java que permite armazenar múltiplos elementos do mesmo tipo. Pense em um array como uma fileira de caixas, onde cada caixa pode conter um item de um tipo específico.

  1. Vamos abrir o arquivo chamado ArrayDemo.java no diretório do seu projeto.

    public class ArrayDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Esta é a estrutura básica do nosso programa Java. O método main é onde nosso programa começa a ser executado.

  2. Agora, vamos declarar e inicializar um array de inteiros. Adicione a seguinte linha dentro do método main:

    int[] numbers = {1, 2, 3, 4, 5};

    Esta linha cria um array de inteiros chamado numbers e o inicializa com os valores 1, 2, 3, 4 e 5. Os colchetes [] indicam ao Java que numbers é um array.

  3. Vamos imprimir os elementos do nosso array. Adicione estas linhas após a declaração do array:

    System.out.println("The elements of the array are:");
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Element at index " + i + ": " + numbers[i]);
}

    Este código usa um loop for para iterar pelo array. numbers.length nos dá o tamanho do array, e numbers[i] acessa o elemento no índice i.

    Java array elements output

  4. Salve o arquivo, compile e execute o programa:

    javac ~/project/ArrayDemo.java
java -cp ~/project ArrayDemo

    Você deve ver uma saída semelhante a esta:

    The elements of the array are:
Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

  5. Agora, vamos calcular a soma de todos os elementos no array. Adicione este código após o loop anterior:

    int sum = 0;
for (int number : numbers) {
    sum += number;
}
System.out.println("The sum of the elements is: " + sum);

    Este código usa um loop for aprimorado (também conhecido como loop for-each) para iterar pelo array. É uma maneira mais simples de percorrer todos os elementos quando você não precisa do índice.

  6. Finalmente, vamos encontrar o valor máximo no array. Adicione este código:

    int max = numbers[0];
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
System.out.println("The maximum value in the array is: " + max);

    Este código começa assumindo que o primeiro elemento é o máximo, então compara cada elemento subsequente ao máximo atual, atualizando o máximo se um valor maior for encontrado.

  7. Salve, compile e execute o programa novamente. Você deve ver a saída adicional:

    The sum of the elements is: 15
The maximum value in the array is: 5

    Java array output example

  8. Arrays em Java têm tamanho fixo, mas podemos modificar seus elementos. Vamos alterar um elemento e imprimir o array modificado. Adicione este código no final do método main:

    numbers[2] = 10;
System.out.println("\nAfter modifying the third element:");
for (int number : numbers) {
    System.out.print(number + " ");
}
System.out.println();

    Isso altera o valor do terceiro elemento (índice 2) para 10 e, em seguida, imprime o array modificado.

  9. Salve, compile e execute o programa mais uma vez. Você deve ver a saída adicional:

    After modifying the third element:
1 2 10 4 5

Parabéns! Você agora criou um array, acessou seus elementos, realizou cálculos com seus valores e modificou um elemento. Lembre-se, arrays em Java têm tamanho fixo, o que significa que, uma vez que você cria um array, não pode alterar seu comprimento. No entanto, você pode alterar os valores de seus elementos.

Introdução aos ArrayLists

Agora que trabalhamos com arrays, vamos apresentar os ArrayLists. ArrayLists fazem parte do Java Collections Framework e fornecem uma maneira mais flexível de trabalhar com listas de objetos. Ao contrário dos arrays, os ArrayLists podem crescer ou diminuir de tamanho dinamicamente.

  1. Abra o arquivo chamado ArrayListDemo.java no diretório do seu projeto.

    import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Observe a instrução import no topo. Isso informa ao Java que queremos usar a classe ArrayList em nosso programa.

  2. Agora, vamos criar um ArrayList de Strings. Adicione esta linha dentro do método main:

    ArrayList<String> fruits = new ArrayList<>();

    Isso cria um ArrayList vazio que pode conter objetos String. A parte <String> é chamada de "genérico" e especifica o tipo de elementos que o ArrayList conterá.

  3. Vamos adicionar alguns elementos ao nosso ArrayList. Adicione estas linhas:

    fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

    O método add() anexa elementos ao final da lista.

  4. Agora, vamos imprimir nosso ArrayList. Adicione este código:

    System.out.println("Fruits in the list:");
for (String fruit : fruits) {
    System.out.println(fruit);
}

    Isso usa um loop for aprimorado para iterar pelo ArrayList, semelhante ao que fizemos com arrays.

    Dicas: Você pode compilar e executar seu programa a qualquer momento para ver a saída. Ou, você pode continuar adicionando mais código e executá-lo no final.

  5. ArrayLists têm muitos métodos úteis. Vamos tentar alguns. Adicione este código:

    System.out.println("\nNumber of fruits: " + fruits.size());
System.out.println("The second fruit is: " + fruits.get(1));

    size() retorna o número de elementos no ArrayList, e get(index) recupera o elemento no índice especificado.

  6. Também podemos substituir elementos em um ArrayList usando o método set(). Adicione este código:

    // Before: [Apple, Banana, Cherry]
fruits.set(1, "Blueberry");    // Replaces "Banana" with "Blueberry"
System.out.println("\nAfter replacing the second fruit:");
System.out.println(fruits);     // [Apple, Blueberry, Cherry]

    set(index, element) substitui o elemento no índice especificado por um novo elemento. O tamanho do ArrayList permanece o mesmo.

  7. Ao contrário dos arrays, os ArrayLists nos permitem inserir elementos em qualquer posição usando o método add(index, element). Isso é diferente de set(), que vimos anteriormente. Vamos ver como add() funciona:

    // Before: [Apple, Blueberry, Cherry]
fruits.add(1, "Blackberry");
System.out.println("\nAfter inserting Blackberry at index 1:");
System.out.println(fruits);
// After: [Apple, Blackberry, Blueberry, Cherry]

    Vamos entender o que aconteceu:

    • add(1, "Blackberry") insere "Blackberry" no índice 1
    • Os elementos existentes no índice 1 e além (Blueberry, Cherry) são automaticamente deslocados uma posição para a direita
    • O tamanho do ArrayList aumenta em 1
    • Isso é diferente de set(), que substituiria o elemento existente sem deslocar ou alterar o tamanho

    Para ajudar a visualizar a diferença:

    // Using add(index, element) - inserts and shifts
fruits.add(1, "Blackberry");    // [Apple, Blackberry, Blueberry, Cherry]

// Using set(index, element) - replaces without shifting
fruits.set(1, "Blackberry");    // [Apple, Blackberry, Cherry]

  8. Também podemos remover elementos de um ArrayList. Adicione este código:

    fruits.remove("Cherry");
System.out.println("\nAfter removing Cherry:");
System.out.println(fruits);

    Isso remove a primeira ocorrência de "Cherry" do ArrayList. Quando um elemento é removido, quaisquer elementos subsequentes são deslocados para a esquerda para preencher a lacuna.

  9. Finalmente, vamos verificar se certos elementos estão em nosso ArrayList:

    System.out.println("\nDoes the list contain Apple? " + fruits.contains("Apple"));
System.out.println("Does the list contain Cherry? " + fruits.contains("Cherry"));

    O método contains() verifica se o ArrayList contém um elemento específico e retorna um valor booleano.

  10. Salve o arquivo, compile e execute o programa:

    javac ~/project/ArrayListDemo.java
java -cp ~/project ArrayListDemo

    Você deve ver uma saída semelhante a esta:

    Fruits in the list:
Apple
Banana
Cherry

Number of fruits: 3
The second fruit is: Banana

After replacing the second fruit:
[Apple, Blueberry, Cherry]

After inserting Blackberry at index 1:
[Apple, Blackberry, Blueberry, Cherry]

After removing Cherry:
[Apple, Blackberry, Blueberry]

Does the list contain Apple? true
Does the list contain Cherry? false

Parabéns! Você agora criou um ArrayList, adicionou e removeu elementos, acessou elementos por índice e usou vários métodos ArrayList. Você aprendeu as distinções importantes entre operações como add(), que insere e desloca elementos, e set(), que substitui elementos. ArrayLists oferecem mais flexibilidade do que arrays, pois podem crescer e diminuir conforme necessário. Isso os torna muito úteis quando você não sabe com antecedência com quantos elementos estará trabalhando.

Convertendo entre Arrays e ArrayLists

Às vezes, você pode precisar converter entre arrays e ArrayLists. Java fornece métodos convenientes para fazer isso. Vamos explorar como converter um array em um ArrayList e vice-versa.

  1. Abra o arquivo chamado ConversionDemo.java no diretório do seu projeto.

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

public class ConversionDemo {
    public static void main(String[] args) {
        // We'll add our code here
    }
}

    Observe as instruções de importação no topo. Estamos importando classes que precisaremos para nossas conversões.

  2. Vamos começar convertendo um array em um ArrayList. Adicione este código dentro do método main:

    String[] colorArray = {"Red", "Green", "Blue"};
List<String> colorList = Arrays.asList(colorArray);

System.out.println("Array converted to ArrayList:");
System.out.println(colorList);

    Arrays.asList() converte um array em uma List. Observe que isso cria uma lista de tamanho fixo apoiada pelo array original.

  3. Vamos modificar o ArrayList e ver o que acontece com o array original. Adicione este código:

    colorList.set(1, "Yellow");

System.out.println("\nAfter modifying the ArrayList:");
System.out.println(colorList);
System.out.println("Original array after ArrayList modification:");
System.out.println(Arrays.toString(colorArray));

    Arrays.toString() é um método conveniente para imprimir um array.

  4. Agora, vamos converter um ArrayList em um array. Adicione este código:

    ArrayList<Integer> numberList = new ArrayList<>();
numberList.add(1);
numberList.add(2);
numberList.add(3);

Integer[] numberArray = numberList.toArray(new Integer[0]);

System.out.println("\nArrayList converted to array:");
System.out.println(Arrays.toString(numberArray));

    Usamos o método toArray() do ArrayList para convertê-lo em um array. Passamos new Integer[0] como argumento, que atua como uma dica para o tipo e tamanho do array a ser criado.

  5. Finalmente, vamos modificar o array e ver se isso afeta o ArrayList. Adicione este código:

    numberArray[0] = 100;
System.out.println("\nAfter modifying the array:");
System.out.println("Array: " + Arrays.toString(numberArray));
System.out.println("ArrayList: " + numberList);

  6. Salve o arquivo, compile e execute o programa:

    javac ~/project/ConversionDemo.java
java -cp ~/project ConversionDemo

    Você deve ver uma saída semelhante a esta:

    Array converted to ArrayList:
[Red, Green, Blue]

After modifying the ArrayList:
[Red, Yellow, Blue]
Original array after ArrayList modification:
[Red, Yellow, Blue]

ArrayList converted to array:
[1, 2, 3]

After modifying the array:
Array: [100, 2, 3]
ArrayList: [1, 2, 3]

Esta demonstração mostra como arrays e ArrayLists podem ser convertidos um no outro. É importante observar a diferença de comportamento:

  • Quando você converte um array em uma List usando Arrays.asList(), a List resultante é apoiada pelo array original. Isso significa que as alterações na List serão refletidas no array e vice-versa.
  • Quando você converte um ArrayList em um array usando toArray(), você cria um novo array que é independente do ArrayList. As alterações neste novo array não afetarão o ArrayList original.

Compreender essas conversões e seus comportamentos é crucial ao trabalhar com diferentes tipos de coleção em Java, especialmente ao interagir com APIs ou bibliotecas que podem preferir um tipo em vez do outro.

Resumo

Neste laboratório, exploramos duas estruturas de dados fundamentais em Java: Arrays e ArrayLists. Vamos recapitular o que aprendemos:

  1. Arrays:

    • Criamos e inicializamos arrays usando a sintaxe int[] numbers = {1, 2, 3, 4, 5};
    • Aprendemos como acessar elementos de array usando a notação de índice, como numbers[0]
    • Iteramos sobre arrays usando loops for tradicionais e loops for aprimorados
    • Realizamos cálculos com elementos de array, como encontrar a soma e o valor máximo
    • Vimos que os arrays têm um tamanho fixo, mas podemos modificar seus elementos

  2. ArrayLists:

    • Criamos ArrayLists usando ArrayList<String> fruits = new ArrayList<>();
    • Aprendemos como adicionar elementos com add(), remover elementos com remove() e acessar elementos com get()
    • Usamos métodos como size(), set() e contains() para trabalhar com ArrayLists
    • Vimos que os ArrayLists podem crescer e diminuir dinamicamente, oferecendo mais flexibilidade do que os arrays

  3. Convertendo entre Arrays e ArrayLists:

    • Convertemos arrays em ArrayLists usando Arrays.asList()
    • Convertemos ArrayLists em arrays usando o método toArray()
    • Observamos os diferentes comportamentos ao modificar coleções convertidas

Arrays e ArrayLists são ferramentas essenciais na programação Java. Arrays são ótimos para trabalhar com um número fixo de elementos e podem ser mais eficientes em termos de uso de memória. ArrayLists, por outro lado, oferecem mais flexibilidade e um conjunto rico de métodos para manipular a coleção.

À medida que você continua sua jornada em Java, você se encontrará usando arrays e ArrayLists com frequência. A escolha entre eles geralmente depende de suas necessidades específicas - se você souber o número exato de elementos com os quais estará trabalhando, um array pode ser preferível. Se você precisar de uma coleção dinâmica que possa crescer ou diminuir, ou se precisar dos métodos adicionais fornecidos pelos ArrayLists, então um ArrayList seria a melhor escolha.

Relacionados Java Cursos
Java para Iniciantes

Java para Iniciantes

java
Exercícios de Programação Java

Exercícios de Programação Java

java
Inserção em Massa de Dados na Grade de Cursos

Inserção em Massa de Dados na Grade de Cursos

java