Java ArrayList vs Vector

Overview

In this tutorial, we’re going to focus on the differences between the ArrayList and Vector classes. Ambos pertencem ao Java Collections Framework e implementam o java.util.List interface.

no entanto, estas classes têm diferenças significativas em suas implementações.O que é diferente?

como um começo rápido, vamos apresentar as principais diferenças de matrizes e vetores. Então, discutiremos alguns dos pontos em mais detalhes.:

• sincronização-a primeira grande diferença entre estes dois. O vetor é sincronizado e o ArrayList não é.
• crescimento de tamanho – outra diferença entre os dois é a forma como eles redimensionam enquanto atingem sua capacidade. O Vector duplica o seu tamanho. Em contraste, ArrayList aumenta apenas em metade de seu comprimento
• iteração – e vetor pode usar Iterator e enumeração para atravessar sobre os elementos. Por outro lado, o ArrayList só pode usar iterador.
• performance-em grande parte devido à sincronização, as operações vetoriais são mais lentas quando comparadas com o ArrayList
• framework – além disso, o ArrayList é uma parte do framework Collections e foi introduzido no JDK 1.2. Enquanto isso, o vetor está presente nas versões anteriores do Java como uma classe de legado.

Vector

como já temos um guia alargado sobre o ArrayList, não vamos discutir a sua API e capacidades aqui. Por outro lado, vamos apresentar alguns detalhes sobre o Vector.

simply put, a Vector is a resizable array. Pode crescer e encolher à medida que adicionamos ou removemos os elementos.

podemos criar um vector de forma típica:

Vector<String> vector = new Vector<>();

o construtor padrão cria um vetor vazio com uma capacidade inicial de 10.

Vamos adicionar alguns valores:

vector.add("baeldung");vector.add("Vector");vector.add("example");

E finalmente, vamos iterar através de valores usando a interface Iterator:

Iterator<String> iterator = vector.iterator();while (iterator.hasNext()) { String element = iterator.next(); // ...}

Ou, podemos percorrer o Vetor usando a Enumeração:

Enumeration e = vector.elements();while(e.hasMoreElements()) { String element = e.nextElement(); // ... }

Agora, vamos explorar algumas das suas características únicas em mais profundidade.

concurrencia

já mencionamos que ArrayList e Vector são diferentes em sua estratégia de concorrência, mas vamos dar uma olhada mais de perto. Se investigássemos as assinaturas do método do Vector, veríamos que cada um tem a palavra-chave sincronizada.:

public synchronized E get(int index)

simplificando, isso significa que apenas um fio pode acessar um dado Vetor de cada vez.

realmente, no entanto, esta sincronização de nível operacional precisa ser sobreposta de qualquer forma com a nossa própria sincronização para operações compostas.

assim, em contraste, ArrayList tem uma abordagem diferente. Seus métodos não são sincronizados e essa preocupação é separada em classes que são dedicadas à concorrência.Por exemplo, podemos usar CopyOnWriteArrayList ou coleções.synchronizedList para obter um efeito semelhante ao Vector:

vector.get(1); // synchronizedCollections.synchronizedList(arrayList).get(1); // also synchronized

desempenho

como já discutimos acima, o vetor é sincronizado o que causa um impacto direto no desempenho.

para ver a diferença de desempenho entre operações vectoriais versus ArrayList, vamos escrever um teste de benchmark JMH simples.

no passado, nós olhamos para a complexidade de tempo das operações de ArrayList, então vamos adicionar os casos de teste para vetor.

Primeiro, vamos testar o método get() :

@Benchmarkpublic Employee testGet(ArrayListBenchmark.MyState state) { return state.employeeList.get(state.employeeIndex);}@Benchmarkpublic Employee testVectorGet(ArrayListBenchmark.MyState state) { return state.employeeVector.get(state.employeeIndex);}

vamos configurar o JMH para usar três tópicos e 10 iterações de aquecimento.

e, vamos relatar o tempo médio por operação no nível nanossegundo:

Benchmark Mode Cnt Score Error UnitsArrayListBenchmark.testGet avgt 20 9.786 ± 1.358 ns/opArrayListBenchmark.testVectorGet avgt 20 37.074 ± 3.469 ns/op

podemos ver que o ArrayList#get funciona três vezes mais rápido que o Vector#get.

agora, vamos comparar os resultados da operação contain() :

@Benchmarkpublic boolean testContains(ArrayListBenchmark.MyState state) { return state.employeeList.contains(state.employee);}@Benchmarkpublic boolean testContainsVector(ArrayListBenchmark.MyState state) { return state.employeeVector.contains(state.employee);}

e imprime os resultados:

Benchmark Mode Cnt Score Error UnitsArrayListBenchmark.testContains avgt 20 8.665 ± 1.159 ns/opArrayListBenchmark.testContainsVector avgt 20 36.513 ± 1.266 ns/op

como podemos ver, para a operação contém (), o tempo de desempenho para vetor é muito mais longo do que ArrayList.

Summary

In this article, we had a look at the differences between the Vector and ArrayList classes in Java. Além disso, também apresentamos recursos vetoriais em mais detalhes.

como de costume, o código completo para este artigo está disponível em GitHub.