TOC

Guia para o Java ArrayList

Guia para o Java ArrayList

1. Visão geral

Neste artigo, vamos dar uma olhada na classeArrayList do Java Collections Framework. Discutiremos suas propriedades, casos de uso comuns, bem como suas vantagens e desvantagens.

ArrayList reside nas Bibliotecas Java Core, então você não precisa de nenhuma biblioteca adicional. Para usá-lo, basta adicionar a seguinte declaração de importação: 

import java.util.ArrayList;

List representa uma sequência ordenada de valores onde algum valor pode ocorrer mais de uma vez.

ArrayList é uma das implementações deList construídas sobre uma matriz, que é capaz de aumentar e diminuir dinamicamente conforme você adiciona / remove elementos. Os elementos podem ser facilmente acessados ​​por seus índices a partir do zero. Esta implementação possui as seguintes propriedades:

  • O acesso aleatório levaO(1) tempo

  • Adicionar elemento leva tempo constante amortizadoO(1)

  • Inserting/Deleting takes O(n) time

  • A pesquisa levaO(n) tempo para uma matriz não classificada eO(log n) para uma classificada

2. Crie umArrayList

ArrayList tem vários construtores e apresentaremos todos eles nesta seção.

Primeiro, observe queArrayList é uma classe genérica, então você pode parametrizá-la com qualquer tipo que você quiser e o compilador irá garantir que, por exemplo, você não será capaz de colocar valoresInteger dentro de uma coleção deStrings. Além disso, você não precisa lançar elementos ao recuperá-los de uma coleção.

Em segundo lugar, é uma boa prática usar a interface genéricaList como um tipo de variável, porque ela a separa de uma implementação particular.

2.1. Construtor Sem Arg padrão 

List list = new ArrayList<>();
assertTrue(list.isEmpty());

Estamos simplesmente criando uma instância vazia deArrayList.

2.2. Construtor que aceita capacidade inicial 

List list = new ArrayList<>(20);

Aqui você especifica o comprimento inicial de uma matriz subjacente. Isso pode ajudar a evitar o redimensionamento desnecessário ao adicionar novos itens.

2.3. Construtor aceitandoCollection 

Collection number
  = IntStream.range(0, 10).boxed().collect(toSet());

List list = new ArrayList<>(numbers);
assertEquals(10, list.size());
assertTrue(numbers.containsAll(list));

Observe que esse elemento da instânciaCollection é usado para preencher a matriz subjacente.

3. Adicione elementos aoArrayList

Você pode inserir um elemento no final ou na posição específica: 

List list = new ArrayList<>();

list.add(1L);
list.add(2L);
list.add(1, 3L);

assertThat(Arrays.asList(1L, 3L, 2L), equalTo(list));

Você também pode inserir uma coleção ou vários elementos de uma vez: 

List list = new ArrayList<>(Arrays.asList(1L, 2L, 3L));
LongStream.range(4, 10).boxed()
  .collect(collectingAndThen(toCollection(ArrayList::new), ys -> list.addAll(0, ys)));
assertThat(Arrays.asList(4L, 5L, 6L, 7L, 8L, 9L, 1L, 2L, 3L), equalTo(list));

4. Iterar sobreArrayList

Existem dois tipos de iteradores disponíveis:IteratoreListIterator.

Enquanto o primeiro oferece a oportunidade de percorrer a lista em uma direção, o último permite percorrê-la nas duas direções.

Aqui, mostraremos apenas oListIterator: 

List list = new ArrayList<>(
  IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new))
);
ListIterator it = list.listIterator(list.size());
List result = new ArrayList<>(list.size());
while (it.hasPrevious()) {
    result.add(it.previous());
}

Collections.reverse(list);
assertThat(result, equalTo(list));

Você também pode pesquisar, adicionar ou remover elementos usando iteradores.

5. Pesquise oArrayList

Demonstraremos como a pesquisa funciona usando uma coleção: 

List list = LongStream.range(0, 16)
  .boxed()
  .map(Long::toHexString)
  .collect(toCollection(ArrayList::new));
List stringsToSearch = new ArrayList<>(list);
stringsToSearch.addAll(list);

5.1. Pesquisando uma lista não classificada

Para encontrar um elemento, você pode usar os métodosindexOf() oulastIndexOf(). Ambos aceitam um objeto e retornam o valorint: 

assertEquals(10, stringsToSearch.indexOf("a"));
assertEquals(26, stringsToSearch.lastIndexOf("a"));

Se quiser encontrar todos os elementos que satisfaçam um predicado, você pode filtrar a coleção usando Java 8Stream API (leia mais sobre issohere) usandoPredicate assim: 

Set matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));

List result = stringsToSearch
  .stream()
  .filter(matchingStrings::contains)
  .collect(toCollection(ArrayList::new));

assertEquals(6, result.size());

Também é possível usar um loopfor ou um iterador: 

Iterator it = stringsToSearch.iterator();
Set matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));

List result = new ArrayList<>();
while (it.hasNext()) {
    String s = it.next();
    if (matchingStrings.contains(s)) {
        result.add(s);
    }
}

5.2. Pesquisando uma lista classificada

Se você tiver uma matriz classificada, poderá usar um algoritmo de pesquisa binária que funciona mais rápido que a pesquisa linear: 

List copy = new ArrayList<>(stringsToSearch);
Collections.sort(copy);
int index = Collections.binarySearch(copy, "f");
assertThat(index, not(equalTo(-1)));

Observe que se um elemento não for encontrado, -1 será retornado.

6. Remova os elementos deArrayList

Para remover um elemento, você deve encontrar seu índice e só então realizar a remoção através do métodoremove(). Uma versão sobrecarregada desse método, que aceita um objeto, procura e executa a remoção da primeira ocorrência de um elemento igual: 

List list = new ArrayList<>(
  IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new))
);
Collections.reverse(list);

list.remove(0);
assertThat(list.get(0), equalTo(8));

list.remove(Integer.valueOf(0));
assertFalse(list.contains(0));

Mas tome cuidado ao trabalhar com tipos em caixas, comoInteger. Para remover um elemento em particular, você deve primeiro marcar o valorint ou, caso contrário, um elemento será removido por seu índice.

Você também pode usar oStream API mencionado acima para remover vários itens, mas não o mostraremos aqui. Para esse fim, usaremos um iterador: 

Set matchingStrings
 = HashSet<>(Arrays.asList("a", "b", "c", "d", "e", "f"));

Iterator it = stringsToSearch.iterator();
while (it.hasNext()) {
    if (matchingStrings.contains(it.next())) {
        it.remove();
    }
}

7. Sumário

Neste artigo rápido, vimos o ArrayList em Java.

Mostramos como criar uma instânciaArrayList, como adicionar, encontrar ou remover elementos usando diferentes abordagens.

Como de costume, você pode encontrar todas as amostras de códigoover on GitHub.

Related