# Como usar Java ArrayList

**ArrayList** é uma das estruturas de dados mais utilizadas em Java. Ela permite modificar e armazenar dinamicamente uma coleção de objetos. Neste tutorial, vamos apresentar a sintaxe de Java ArrayList e explicar quando e como utilizá-la.

## Qual é a diferença entre ArrayList e array em Java?

Uma Java ArrayList é dinâmica, o que significa que ela aumenta e diminui de tamanho a depender dos elementos adicionados ou removidos. Vale notar que a classe ArrayList faz parte do **Java Collections Framework**. Ao contrário de arrays, ArrayLists precisam ser importadas da biblioteca *java.util*.

ArrayLists são a escolha adequada quando o comprimento de uma [lista em Java](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-list-lista-em-java/) pode variar potencialmente. Exemplos incluem armazenar objetos, **buscar ou ordenar dados** e criar listas ou filas.

Em contrapartida, não é possível alterar o tamanho de um array. Assim, de preferência, você deverá saber, antecipadamente, quantos objetos o array irá conter. Arrays são adequados para gerenciar conjuntos pré-definido de **tipos de dados primitivos**, como *int*, *float*, *char* e *boolean*.

Uma desvantagem da ArrayList é que ela pode **demorar mais para ser acessada**. Enquanto arrays têm blocos contínuos e fixos de memória, objetos em ArrayLists não ficam armazenados de maneira contígua. É importante levar em consideração as vantagens e desvantagens das estruturas de dados para escolher aquela que melhor se adapta ao uso que você fará.

## Qual é a sintaxe de Java ArrayList?

Antes de criar uma ArrayList, você deve importar a classe correspondente da biblioteca *java.util*:

```Java
import java.util.ArrayList;
```

A sintaxe geral é:

```Java
ArrayList<Tipo> arrayList= new ArrayList<>();
```

`Tipo` se refere ao respectivo tipo de dado na Java ArrayList.

O próximo passo é criar listas de `strings` e `integers`:

```Java
ArrayList<String> arrayList= new ArrayList<>();
```

```Java
ArrayList<Integer> arrayList= new ArrayList<>();
```

ArrayLists usam a **classe wrapper** dos tipos de dados primitivos correspondentes para tratá-los como objetos. Isso significa que você precisará especificar `Integer` em vez de `int`.

## Exemplos de métodos Java ArrayList

Operações como adicionar ou remover elementos não são realizadas, na ArrayList, com [operadores Java](https://www.ionos.com/digitalguide/websites/web-development/java-operators/ "Operadores em Java"), mas por **métodos predefinidos**. Apesentaremos, agora, os métodos mais comuns de ArrayList.

### Adicionar elementos

Após criar o ArrayList “cores” (tipo `String`), vamos adicionar vários elementos a ele usando o método `.add()`:

```Java
import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
    }
}
```

O código resultará em:

```Java
ArrayList: [azul vermelho verde]
```

### Remover elementos

Para remover objetos de uma Java ArrayList, podemos usar o método `.remove()` e especificar o índice do elemento:

```Java
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
        String cor = cores.remove(1);
        System.out.println("ArrayList: " + cores);
        System.out.println("Elemento Removido: " + cor);
    }
}
```

A saída mostra a ArrayList modificada e o elemento que foi removido:

```Java
ArrayList: [azul verde]
Elemento Removido: vermelho
```

Como na maioria das linguagens de programação, a contagem em Java começa em 0. Isso significa que o elemento removido no índice 1 é `vermelho`.

### Acessar elementos

Usando o método `.get()`, podemos acessar um elemento em uma posição específica.

```Java
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> roupas = new ArrayList<>();
        roupas.add("jaqueta");
        roupas.add("camisa");
        roupas.add("pulôver");
        System.out.println("ArrayList: " + roupas);
        String str = roupas.get(2);
        System.out.print("Elemento no índice 2: " + str);
    }
}
```

Como resultado, recebemos:

```Java
ArrayList: [jaqueta camisa pulôver]
Elemento no índice 2: pulôver
```

### Alterar elementos

Com `.set()`, podemos alterar um elemento, atribuindo um novo elemento em um índice específico.

```Java
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println("ArrayList: " + cores);
        cores.set(2, "amarelo");
        System.out.println("ArrayList Modificado: " + cores);
    }
}
```

Agora vemos `amarelo` em vez de `verde` no índice 2:

```Java
ArrayList: [azul vermelho verde]
ArrayList Modificado: [azul vermelho amarelo]
```

### Determinar tamanho da Java ArrayList

O número de elementos no ArrayList pode ser facilmente calculado usando o método `.size()`:

```Java
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> cores = new ArrayList<>();
        cores.add("azul");
        cores.add("vermelho");
        cores.add("verde");
        System.out.println(cores.size());
    }
}
```

Este é o resultado:

```Java
3
```

### Classificar e iterar sobre ArrayList

Para classificar a Java ArrayList, a classe Collections deve ser importada. Para a iteração, usamos um [loop for-each em Java](https://www.ionos.com/digitalguide/websites/web-development/java-for-each-loop/). A cada iteração do loop, o respectivo elemento é exibido no console.

```Java
import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> idades = new ArrayList<Integer>();
        idades.add(20);
        idades.add(54);
        idades.add(17);
        idades.add(9);
        Collections.sort(idades);
        for (int i : idades) {
            System.out.println(i);
        }
    }
}
```

Os elementos da ArrayList são exibidos do menor para o maior:

```Java
9
17
20
54
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-arraylist/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-arraylist/) for AI/LLM consumption.