Vamos iniciar nossa introdução à estrutura de dados List. Abaixo está um fluxograma ilustrando a Hierarquia de Coleções e Listas. Pode parecer um diagrama grande e complexo, mas vamos analisá-lo passo a passo.

Nesta seção, você explorará um tipo específico de coleção chamado listas. Você examinará mais de perto diferentes tipos de listas, incluindo ArrayList, LinkedList e Stack.

Como todas as listas herdam da interface List, é possível criar objetos utilizando a interface pai. Mas vamos aprofundar esse assunto mais adiante.

Por enquanto, vamos discutir o primeiro tipo de lista – ArrayList.

Acima, você vê a sintaxe para criar um ArrayList<>. Há uma parte que talvez não seja familiar – o genérico. Abordaremos genéricos e como criá-los posteriormente.

Por enquanto, lembre-se apenas de que, ao criar um ArrayList, você especifica o tipo de dado entre sinais de menor e maior. Além disso, lembre-se de que listas não funcionam com tipos de dados primitivos. Em vez disso, utilizamos classes wrapper.

Agora, vamos criar uma lista no código e adicionar alguns objetos utilizando o método add().

Main.java


              1234567891011121314
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Como pode ser observado, o método add() é bastante simples—ele apenas adiciona o valor especificado à lista.

Além disso, é importante lembrar que é necessário importar List e ArrayList da biblioteca java.util. No entanto, se estiver utilizando o IntelliJ IDEA, essas bibliotecas são importadas automaticamente, portanto não há necessidade de se preocupar com isso.

Agora, veja um exemplo de criação de uma lista com nosso próprio tipo de dado:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Como você pode ver, criamos nossa própria classe Dog e um ArrayList utilizando esse tipo de dado. Ao imprimir a lista, foram exibidos todos os objetos armazenados nela.

E se você tiver um array e precisar convertê-lo em uma lista? Isso pode ser feito utilizando o método asList() da classe Arrays.

Esse método permite criar uma lista que contém os mesmos elementos do array original. É especialmente útil quando se deseja aplicar métodos de lista a um array. A sintaxe é simples:

Arrays.asList(arrayName);

E pode ser utilizada imediatamente ao inicializar uma nova lista, por exemplo:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Assim como é possível converter um array em uma lista, também é possível converter uma lista em um array utilizando o método toArray().

Métodos do ArrayList<>

Apresentação dos principais métodos de lista. Até agora, seria possível substituir listas por arrays, mas aqui está a principal diferença—os métodos.

O método add() é um método sobrecarga, ou seja, possui várias variações. Uma delas permite adicionar um elemento em um índice específico.

Ao inserir um elemento no meio de uma lista, todos os elementos à direita deslocam-se uma posição para abrir espaço para o novo elemento.

Por exemplo, ao adicionar um elemento no início da lista, todos os elementos existentes serão deslocados uma posição para a direita.

Veja um exemplo:

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

A forma como os valores se deslocam ao inserir um elemento pode ser visualizada na ilustração a seguir:

Recuperação de Elementos

Naturalmente, se é possível adicionar objetos a uma lista em um índice específico, também é possível recuperar objetos pelo índice utilizando o método get(int index).

Veja um exemplo:

Main.java


              12345678910111213141516171819
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Remoção de Elementos

É possível adicionar, é possível recuperar, mas é possível remover? Claro! É possível remover elementos utilizando o método remove(int index).

Este método também é sobrecarga, ou seja, existe outra forma de remover um elemento. É possível utilizar o método remove(Object obj), que exclui a primeira ocorrência do elemento especificado.

Agora, imagine que existe uma lista grande com todos os alunos do nosso curso. No entanto, um aluno se comportou mal e foi expulso. Não se sabe o índice exato dele, então é necessário removê-lo pelo nome. Mas há um detalhe — o código está um pouco com defeito, e o nome desse aluno pode aparecer várias vezes na lista.

Vamos escrever um programa para remover todas as ocorrências desse aluno da lista:

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Você deve ter notado que utilizamos outro método de lista—contains(Object obj). Este método verifica se o elemento especificado está presente na lista e retorna true ou false.

Ao usar contains(), definimos a condição para o loop while, permitindo remover todas as ocorrências de um estudante como "Bob" da lista.

Aliás, é possível simplificar bastante esse processo utilizando o método removeAll(Collection<?> c):

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

O método removeAll() recebe uma coleção como parâmetro, contendo valores que serão removidos da lista na qual o método foi chamado.

Nesta abordagem, criamos uma coleção de alunos expulsos e adicionamos "Bob" a ela. Isso torna nosso código facilmente expansível—basta adicionar mais alunos problemáticos à lista de expulsos ao longo do tempo.

Atualização de um Valor por Índice

Retornando aos métodos de lista—agora é o momento do método de atualização.

Como o método add() simplesmente desloca todos os elementos para a direita ao inserir um novo valor, é necessário um método diferente para atualizar um valor existente por índice.

O método set(int index, Object value) faz exatamente isso:

Main.java


              12345678910111213141516
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

É bastante simples—substituímos o elemento no segundo índice pelo número 28.

Outros Métodos

Você já estudou os métodos mais comuns, mas existem muitos outros. Como são raramente utilizados, não vamos abordar cada um deles.

Em vez disso, você pode encontrar todos os métodos necessários — juntamente com documentação completa e explicações detalhadas — abrindo a classe ArrayList no IntelliJ IDEA.

Para isso, basta importar a biblioteca ArrayList, manter pressionada a Command key (Ctrl no Windows) e clicar em ArrayList. Isso exibirá todos os campos e métodos disponíveis na classe, ajudando você a explorar quaisquer métodos que possam ter passado despercebidos.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 2

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Deslize para mostrar o menu

Nesta seção, você explorará um tipo específico de coleção chamado listas. Você examinará mais de perto diferentes tipos de listas, incluindo ArrayList, LinkedList e Stack.

Como todas as listas herdam da interface List, é possível criar objetos utilizando a interface pai. Mas vamos aprofundar esse assunto mais adiante.

Por enquanto, vamos discutir o primeiro tipo de lista – ArrayList.

Acima, você vê a sintaxe para criar um ArrayList<>. Há uma parte que talvez não seja familiar – o genérico. Abordaremos genéricos e como criá-los posteriormente.

Agora, vamos criar uma lista no código e adicionar alguns objetos utilizando o método add().

Main.java


              1234567891011121314
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Como pode ser observado, o método add() é bastante simples—ele apenas adiciona o valor especificado à lista.

Agora, veja um exemplo de criação de uma lista com nosso próprio tipo de dado:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Como você pode ver, criamos nossa própria classe Dog e um ArrayList utilizando esse tipo de dado. Ao imprimir a lista, foram exibidos todos os objetos armazenados nela.

E se você tiver um array e precisar convertê-lo em uma lista? Isso pode ser feito utilizando o método asList() da classe Arrays.

Esse método permite criar uma lista que contém os mesmos elementos do array original. É especialmente útil quando se deseja aplicar métodos de lista a um array. A sintaxe é simples:

Arrays.asList(arrayName);

E pode ser utilizada imediatamente ao inicializar uma nova lista, por exemplo:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Assim como é possível converter um array em uma lista, também é possível converter uma lista em um array utilizando o método toArray().

Métodos do ArrayList<>

Apresentação dos principais métodos de lista. Até agora, seria possível substituir listas por arrays, mas aqui está a principal diferença—os métodos.

O método add() é um método sobrecarga, ou seja, possui várias variações. Uma delas permite adicionar um elemento em um índice específico.

Ao inserir um elemento no meio de uma lista, todos os elementos à direita deslocam-se uma posição para abrir espaço para o novo elemento.

Por exemplo, ao adicionar um elemento no início da lista, todos os elementos existentes serão deslocados uma posição para a direita.

Veja um exemplo:

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

A forma como os valores se deslocam ao inserir um elemento pode ser visualizada na ilustração a seguir:

Recuperação de Elementos

Naturalmente, se é possível adicionar objetos a uma lista em um índice específico, também é possível recuperar objetos pelo índice utilizando o método get(int index).

Veja um exemplo:

Main.java


              12345678910111213141516171819
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Remoção de Elementos

É possível adicionar, é possível recuperar, mas é possível remover? Claro! É possível remover elementos utilizando o método remove(int index).

Vamos escrever um programa para remover todas as ocorrências desse aluno da lista:

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Você deve ter notado que utilizamos outro método de lista—contains(Object obj). Este método verifica se o elemento especificado está presente na lista e retorna true ou false.

Ao usar contains(), definimos a condição para o loop while, permitindo remover todas as ocorrências de um estudante como "Bob" da lista.

Aliás, é possível simplificar bastante esse processo utilizando o método removeAll(Collection<?> c):

Main.java


              123456789101112131415161718
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

O método removeAll() recebe uma coleção como parâmetro, contendo valores que serão removidos da lista na qual o método foi chamado.

Atualização de um Valor por Índice

Retornando aos métodos de lista—agora é o momento do método de atualização.

Como o método add() simplesmente desloca todos os elementos para a direita ao inserir um novo valor, é necessário um método diferente para atualizar um valor existente por índice.

O método set(int index, Object value) faz exatamente isso:

Main.java


              12345678910111213141516
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

É bastante simples—substituímos o elemento no segundo índice pelo número 28.

Outros Métodos

Você já estudou os métodos mais comuns, mas existem muitos outros. Como são raramente utilizados, não vamos abordar cada um deles.

Em vez disso, você pode encontrar todos os métodos necessários — juntamente com documentação completa e explicações detalhadas — abrindo a classe ArrayList no IntelliJ IDEA.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 2

Lista e ArrayList em Java

Métodos do ArrayList<>

Recuperação de Elementos

Remoção de Elementos

Atualização de um Valor por Índice

Outros Métodos

1. Qual método podemos usar para adicionar um elemento por índice?

2. Qual método podemos usar para recuperar um elemento por índice?

3. Qual método pode ser utilizado para remover a primeira ocorrência de um elemento?

4. Qual método pode ser utilizado para substituir um elemento pelo índice?

5. Qual método pode ser utilizado para verificar a presença de um elemento?

6. Podemos criar uma lista a partir de um array?

7. Como podemos criar uma lista a partir de um array?

Lista e ArrayList em Java

Métodos do ArrayList<>

Recuperação de Elementos

Remoção de Elementos

Atualização de um Valor por Índice

Outros Métodos

1. Qual método podemos usar para adicionar um elemento por índice?

2. Qual método podemos usar para recuperar um elemento por índice?

3. Qual método pode ser utilizado para remover a primeira ocorrência de um elemento?

4. Qual método pode ser utilizado para substituir um elemento pelo índice?

5. Qual método pode ser utilizado para verificar a presença de um elemento?

6. Podemos criar uma lista a partir de um array?

7. Como podemos criar uma lista a partir de um array?