Vamos começar nossa introdução a uma estrutura de dados chamada List. Acima está um fluxograma que nos mostra a Hierarquia de Coleções e Listas. Podemos ver que é um diagrama bastante grande e complexo, mas vamos desmembrá-lo passo a passo. Nesta seção, vamos nos familiarizar com um tipo de coleção chamado listas. Exploraremos tipos de listas como ArrayList, LinkedList e Stack.

Nota

Não discutiremos Vector, pois é uma estrutura de dados ultrapassada que foi completamente substituída por ArrayList.

Como todas as Listas herdam da interface List, podemos, obviamente, criar objetos através da interface pai. Mas falaremos mais sobre isso mais tarde. Vamos falar sobre o primeiro tipo de lista - ArrayList.

Acima, você vê a sintaxe para criar um ArrayList<>. Há algo desconhecido para você nesta sintaxe - são os genéricos. Falaremos sobre genéricos e como criá-los mais tarde. Por agora, lembre-se de que estamos criando um ArrayList e especificando o tipo de dados que será armazenado na lista dentro dos colchetes em forma de diamante. Lembre-se de que as listas não podem trabalhar com tipos de dados primitivos. Para isso, usamos as classes embrulho.

Vamos criar uma lista no código e tentar adicionar alguns objetos à lista usando 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 você pode ver, o método add() é extremamente simples. Ele simplesmente adiciona o valor especificado nos parâmetros à lista. Além disso, observe que devemos importar List e ArrayList da biblioteca java.util. No entanto, o IntelliJ IDEA importa automaticamente essas bibliotecas para você, então não se preocupe com isso.

Vamos dar uma olhada em um exemplo de criação de uma lista com nosso tipo de dado personalizado:

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 criamos um ArrayList com esse tipo de dado. Ao imprimir, obtivemos uma lista completa de todos os objetos na lista.

O que fazemos se temos um array e queremos convertê-lo em uma lista? Podemos fazer isso utilizando o método da classe Arrays - asList(). Com esse método, podemos criar uma lista que conterá os mesmos elementos do array original. Isso é frequentemente útil quando precisamos utilizar métodos de listas em um array. A sintaxe é bastante simples:

Arrays.asList(nomeDoArray);

E podemos usá-lo 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 podemos transformar um array em uma lista, podemos transformar uma lista em um array utilizando o método toArray().

Métodos do ArrayList<>

Vamos explorar os métodos básicos para trabalhar com uma lista. Até agora, poderíamos facilmente substituir listas por arrays, mas vamos observar a principal diferença - os métodos.

O método add() é um método sobrecarregado e tem uma segunda utilidade: Podemos adicionar um elemento em um índice específico.

Nota

Listas, assim como os arrays, têm indexação baseada em zero.

Quando adicionamos um elemento no meio da lista, todos os elementos à direita são deslocados em 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 são deslocados uma posição para a direita. Vamos ver 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);
    }
}

O processo de como os valores mudam pode ser visto na ilustração:

Obviamente, se podemos adicionar objetos à lista por índice, também podemos recuperar objetos da lista pelo índice usando o método get(int index). Vamos ver um exemplo:

main.java


              123456789101112131415
            
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);
        }
        int element = numbers.get(1);
        System.out.println(element);
    }
}

Podemos adicionar, podemos recuperar, mas podemos deletar? Certamente podemos! Utilizando o método remove(int index). Este método também é sobrecarregado, então há outra forma de remover um elemento da lista. Podemos usar o método remove(Object obj) e deletar a primeira ocorrência do elemento especificado.

Imaginemos que temos uma grande lista de todos os estudantes do nosso curso. Mas um deles se comportou mal e foi expulso. Não sabemos sob qual índice ele foi registrado, então devemos removê-lo da lista de estudantes. Mas há um porém: o código está um pouco quebrado, e o nome dele pode ter aparecido na lista várias vezes. Vamos escrever um programa que removerá todas as menções deste estudante 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ê pode ter notado corretamente que usamos outro método da lista - contains(Object obj), que verifica se o elemento especificado está presente na lista e retorna true ou false. Utilizando este método, estabelecemos a condição para a execução do loop while, removendo assim todas as menções de um estudante como "Bob" da lista. Maravilhoso.

Aliás, poderíamos simplificar significativamente a resolução deste problema 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 ele irá remover da coleção na qual este método foi chamado. Dessa forma, criamos uma coleção de alunos expulsos e adicionamos "Bob" a ela. Isso nos permite expandir facilmente nosso código adicionando novos causadores de problemas à coleção de alunos expulsos ao longo do tempo.

Vamos voltar aos métodos de lista; agora temos o método de atualização em sequência. Considerando que o método add() simplesmente desloca todos os valores para a direita após si mesmo, precisamos descobrir como atualizar um valor pelo índice. O método set(int index, Object value) realiza esta ação:

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

Aqui é bem direto; substituímos o elemento no segundo índice pelo número 28.

Outros Métodos

Poderíamos falar sobre vários métodos de trabalho com esta lista por um longo tempo, mas isso levaria bastante tempo. Portanto, você pode encontrar todos os métodos de que precisa com documentação completa e explicações sobre o funcionamento deles ao abrir a classe ArrayList no IntelliJ IDEA. Para fazer isso, basta importar a biblioteca ArrayList, manter pressionada a tecla command (ctrl para Windows) e clicar em ArrayList. Aqui, você verá todos os campos e métodos desta classe, permitindo que você se familiarize com os métodos que talvez tenha perdido.

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

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

3. Qual método podemos usar para remover a primeira ocorrência de um elemento?

4. Qual método podemos usar para substituir um elemento pelo índice?

5. Qual método podemos usar 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?

Como podemos criar uma lista a partir de um array?

Select the correct answer

List<> list = new ArrayList<>()

Please note that the given Java code snippet seems to contain a syntax error. The correct Java syntax to initialize a list with values from an array should look like this:

List<Type> list = new ArrayList<>(Arrays.asList(array));

In this corrected version, "Type" should be replaced with the actual data type contained in the array, for instance, Integer, String, etc.

However, since the task is only to translate the text and not correct the code, here is the translation maintaining the original structure:

List<> lista = new ArrayList<Arrays.asList(array)>();

Please note that "Arrays.asList(array)" should not be translated, as it is part of the code.

List<> lista = new ArrayList<>(Arrays.asList(array));

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

Nota

Não discutiremos Vector, pois é uma estrutura de dados ultrapassada que foi completamente substituída por ArrayList.

Vamos criar uma lista no código e tentar adicionar alguns objetos à lista usando 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);
    }
}

Vamos dar uma olhada em um exemplo de criação de uma lista com nosso tipo de dado personalizado:

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 criamos um ArrayList com esse tipo de dado. Ao imprimir, obtivemos uma lista completa de todos os objetos na lista.

Arrays.asList(nomeDoArray);

E podemos usá-lo 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 podemos transformar um array em uma lista, podemos transformar uma lista em um array utilizando o método toArray().

Métodos do ArrayList<>

Vamos explorar os métodos básicos para trabalhar com uma lista. Até agora, poderíamos facilmente substituir listas por arrays, mas vamos observar a principal diferença - os métodos.

O método add() é um método sobrecarregado e tem uma segunda utilidade: Podemos adicionar um elemento em um índice específico.

Nota

Listas, assim como os arrays, têm indexação baseada em zero.

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

O processo de como os valores mudam pode ser visto na ilustração:

Obviamente, se podemos adicionar objetos à lista por índice, também podemos recuperar objetos da lista pelo índice usando o método get(int index). Vamos ver um exemplo:

main.java


              123456789101112131415
            
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);
        }
        int element = numbers.get(1);
        System.out.println(element);
    }
}

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

Aliás, poderíamos simplificar significativamente a resolução deste problema 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"));
    }
}

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

Aqui é bem direto; substituímos o elemento no segundo índice pelo número 28.

Outros Métodos

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

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

3. Qual método podemos usar para remover a primeira ocorrência de um elemento?

4. Qual método podemos usar para substituir um elemento pelo índice?

5. Qual método podemos usar 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?

Como podemos criar uma lista a partir de um array?

Select the correct answer

List<> list = new ArrayList<>()

Please note that the given Java code snippet seems to contain a syntax error. The correct Java syntax to initialize a list with values from an array should look like this:

List<Type> list = new ArrayList<>(Arrays.asList(array));

In this corrected version, "Type" should be replaced with the actual data type contained in the array, for instance, Integer, String, etc.

However, since the task is only to translate the text and not correct the code, here is the translation maintaining the original structure:

List<> lista = new ArrayList<Arrays.asList(array)>();

Please note that "Arrays.asList(array)" should not be translated, as it is part of the code.

List<> lista = new ArrayList<>(Arrays.asList(array));

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 2

Lista e ArrayList

Métodos do ArrayList<>

Outros Métodos

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

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

3. Qual método podemos usar para remover a primeira ocorrência de um elemento?

4. Qual método podemos usar para substituir um elemento pelo índice?

5. Qual método podemos usar 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?

Awesome!

Lista e ArrayList

Métodos do ArrayList<>

Outros Métodos

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

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

3. Qual método podemos usar para remover a primeira ocorrência de um elemento?

4. Qual método podemos usar para substituir um elemento pelo índice?

5. Qual método podemos usar 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?