Visão geral resumida baseada em uma coleção de revisões de Java

Autor：Eve Cole Data da Última Atualização：2024-11-18 12:48:01

As coleções em Java estão concentradas principalmente em duas partes, uma está no pacote java.util e a outra está em java.util.concurrent. A última é baseada na primeira e define algumas coleções que implementam funções de sincronização.

Este artigo concentra-se principalmente em vários objetos de coleção em java.util. Os objetos de coleção em Java podem ser divididos em três categorias: Lista, Conjunto e Mapa. O diagrama UML correspondente é o seguinte (incluindo a maioria dos objetos de coleção em java.util):

Visão geral da coleção

Tanto List quanto Set em coleções Java vêm de Collection. É um bom ponto de entrada para aprender coleções. Inclui operações que geralmente são necessárias em coleções.

Adicionar elementos: add/addAll
Limpar a coleção: limpar
Remover elementos: remover/remover todos
Determine se a coleção contém um elemento: contains/containsAll
Determine se a coleção está vazia: isEmpty
Calcule o número de elementos em uma coleção: tamanho
Converta uma coleção em um array: toArray
Obter iterador: iterador

Vejamos um exemplo simples. O código a seguir retornará uma coleção cujos elementos são inteiros gerados aleatoriamente:

Copie o código do código da seguinte forma:

coleção estática privada initCollection()
{
Coleção<Integer> coleção = new ArrayList<Integer>();
Aleatório r = novo Aleatório();
para (int i = 0; i < 5; i++)
{
coleção.add(new Integer(r.nextInt(100)));
}

cobrança de devolução;
}

No processo de operação em coleções, o percurso é uma operação usada com frequência. Podemos percorrer coleções de duas maneiras:

1) Use iteradores para percorrer a coleção. Conforme mencionado ao descrever a interface Collection acima, todas as coleções terão um iterador que podemos usar para percorrer a coleção.

Copie o código do código da seguinte forma:

private static void accessCollectionByIterator(Collection<Integer> coleção)
{
Iterador<Integer> iterador = coleção.iterator();
System.out.println("O valor na lista:");
enquanto(iterador.hasNext())
{
System.out.println(iterator.next());
}
}

2) Use foreach para percorrer a coleção.

Copie o código do código da seguinte forma:

private static void accessCollectionByFor(Collection<Integer> coleção)
{
System.out.println("O valor na lista:");
for (valor inteiro: coleção)
{
System.out.println(valor);
}
}

Lista

Lista em Java é uma extensão eficaz de array. É uma estrutura que pode conter elementos de qualquer tipo se genéricos não forem usados. Se genéricos forem usados, ela só poderá conter elementos do tipo especificado pelos genéricos. Comparado com arrays, a capacidade de List pode ser expandida dinamicamente.

Os elementos da Lista podem ser repetidos e os elementos internos são "ordenados". O "ordenado" aqui não significa classificação, mas significa que podemos especificar a posição de um elemento na coleção.

Os objetos de coleção comumente usados em List incluem: ArrayList, Vector e LinkedList, os dois primeiros são armazenados com base em arrays e os últimos são armazenados com base em listas vinculadas. Entre eles, Vector é thread-safe e os outros dois não são thread-safe.

A lista pode conter nulo, mesmo se forem usados genéricos.

ArrayList pode ser o objeto de coleção mais comumente usado. No código de exemplo acima, também o usamos para instanciar um objeto Collection, portanto não entraremos em detalhes aqui.
Vetor

Um exemplo de Vector é o seguinte. Primeiro, veremos como gerar e gerar Vector:

Copie o código do código da seguinte forma:

vetor de vazio estático privadoTest1()
{
Lista<Integer> list = new Vector<Integer>();
para (int i = 0; i < 5; i++)
{
list.add(novo inteiro(100));
}
lista.add(nulo);
System.out.println("o tamanho do vetor é " + list.size());
System.out.println(lista);
}

Seus elementos incluem elementos repetidos e nulos. Os resultados de saída são os seguintes:

Copie o código do código da seguinte forma:

o tamanho do vetor é 6
[100, 100, 100, 100, 100, nulo]

O exemplo a seguir demonstra alguns métodos comuns em Vector:

Copie o código do código da seguinte forma:

vetor de vazio estático privadoTest2()
{
Vector<Integer> list = new Vector<Integer>();
Aleatório r = novo Aleatório();
para (int i = 0; i < 10; i++)
{
list.add(novo Inteiro(r.nextInt(100)));
}
System.out.println("o tamanho do vetor é " + list.size());
System.out.println(lista);
System.out.println(list.firstElement());
System.out.println(list.lastElement());
System.out.println(list.subList(3, 8));
List<Integer> temp = new ArrayList<Integer>();
para(int i = 4; i < 7; i++)
{
temp.add(lista.get(i));
}
lista.retainAll(temp);
System.out.println("o tamanho do vetor é " + list.size());
System.out.println(lista);
}

Sua saída é a seguinte:

Copie o código do código da seguinte forma:

o tamanho do vetor é 10
[39, 41, 20, 9, 29, 32, 54, 12, 94, 82]

[9, 29, 32, 54, 12]
tamanho do vetor é 3
[29, 32, 54]

Lista vinculada

LinkedList usa listas vinculadas para armazenar dados. Seu código de exemplo é o seguinte:

Copie o código do código da seguinte forma:

Exemplo de LinkedList
vazio estático privado linkedListTest1()
{
LinkedList<Integer> lista = new LinkedList<Integer>();
Aleatório r = novo Aleatório();
para (int i = 0; i < 10; i++)
{
list.add(novo Inteiro(r.nextInt(100)));
}
lista.add(nulo);
System.out.println("o tamanho da lista vinculada é " + list.size());
System.out.println(lista);
System.out.println(lista.element());
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println(list.peek());
System.out.println(list.peekFirst());
System.out.println(list.peekLast());
System.out.println(lista.poll());
System.out.println(list.pollFirst());
System.out.println(list.pollLast());
System.out.println(list.pop());
list.push(novo inteiro(100));
System.out.println("o tamanho da lista vinculada é " + list.size());
System.out.println(lista);
}

Aqui estão os métodos comumente usados de LinkedList. Como você pode ver pelos nomes dos métodos, LinkedList também pode ser usado para implementar pilhas e filas.

A saída é a seguinte:

Copie o código do código da seguinte forma:

o tamanho da lista vinculada é 11
[17, 21, 5, 84, 19, 57, 68, 26, 27, 47, nulo]

nulo

o tamanho da lista vinculada é 8
[100, 84, 19, 57, 68, 26, 27, 47]

Definir

Set é semelhante a List, ambos são usados para armazenar um único elemento e o número de elementos individuais é incerto. Mas Set não pode conter elementos duplicados. Se dois elementos idênticos forem inseridos em Set, o último elemento não será inserido.

O conjunto pode ser dividido em duas categorias: conjunto não classificado e conjunto classificado. Conjunto não classificado inclui HashSet e LinkedHashSet, e conjunto classificado refere-se principalmente a TreeSet. Entre eles, HashSet e LinkedHashSet podem conter nulo.
HashSet

HashSet é uma coleção apoiada por uma tabela Hash, que não é thread-safe.

Vejamos o exemplo a seguir, que é basicamente igual ao primeiro exemplo com Vector:

Copie o código do código da seguinte forma:

hashSetTest1() vazio estático privado
{
Set<Integer> set = new HashSet<Integer>();

para (int i = 0; i < 3; i++)
{
set.add(novo inteiro(100));
}
set.add(nulo);

System.out.println("o tamanho do conjunto é " + set.size());
System.out.println(conjunto);
}

Aqui, HashSet contém elementos repetidos e nulos. Ao contrário do Vector, a saída aqui é a seguinte:

Copie o código do código da seguinte forma:

o tamanho do conjunto é 2
[nulo, 100]

Podemos dar uma olhada em detalhes em como o HashSet determina se dois elementos são duplicados. O método equals também é definido em Object. Para os elementos do HashSet, é julgado se os elementos são iguais com base no método equals. Para provar isso, podemos definir um tipo "anormal".

Copie o código do código da seguinte forma:

Definir objeto MyInteger

classMyInteger
{
Valor inteiro privado;

público MyInteger (valor inteiro)
{
este.valor = valor;
}

String pública paraString()
{
retornar String.valueOf(valor);
}

hashCode int público()
{
retornar 1;
}

booleano público é igual (objeto objeto)
{
retornar verdadeiro;
}
}

Pode-se observar que para MyInteger, para quaisquer duas instâncias, consideramos que é desigual.

A seguir está o método de teste correspondente:

Copie o código do código da seguinte forma:

hashSetTest2() vazio estático privado
{
Set<MeuInteger> set = new HashSet<MeuInteger>();

para (int i = 0; i < 3; i++)
{
set.add(new MeuInteger(100));
}

System.out.println("o tamanho do conjunto é " + set.size());
System.out.println(conjunto);
}

Sua saída é a seguinte:

Copie o código do código da seguinte forma:

o tamanho do conjunto é 3
[100, 100, 100]

Como você pode ver, agora existem elementos "duplicados" no HashSet, mas para MyInteger, eles não são "iguais".
Conjunto de árvores

TreeSet é um conjunto que suporta classificação e sua interface pai é SortedSet.

Vamos primeiro dar uma olhada nas operações básicas do TreeSet:

Copie o código do código da seguinte forma:

vazio estático privado treeSetTest1()
{
TreeSet<Integer> set = new TreeSet<Integer>();

Aleatório r = novo Aleatório();
para (int i = 0; i < 5; i++)
{
set.add(novo Inteiro(r.nextInt(100)));
}

System.out.println(conjunto);
System.out.println(set.first());
System.out.println(set.last());
System.out.println(set.descendenteSet());
System.out.println(set.headSet(new Integer(50)));
System.out.println(set.tailSet(new Integer(50)));
System.out.println(set.subSet(30, 60));
System.out.println(set.floor(50));
System.out.println(set.ceiling(50));
}

Sua saída é a seguinte:

Copie o código do código da seguinte forma:

[8, 42, 48, 49, 53]

[53, 49, 48, 42, 8]
[8, 42, 48, 49]
[53]
[42, 48, 49, 53]

Os elementos em TreeSet geralmente implementam a interface Comparable. Por padrão, para Integer, SortedList é armazenado em ordem crescente. Também podemos personalizar o método Compare, como armazenar em ordem decrescente.

A seguir, primeiro redefinimos Inteiro:

Copie o código do código da seguinte forma:

Definir objeto MyInteger2
classe MyInteger2 implementa Comparable
{
valor interno público;

público MyInteger2 (valor interno)
{
este.valor = valor;
}

público int compareTo(Objeto arg0)
{
MeuInteger2 temp = (MeuInteger2)arg0;
if (temp == null) return -1;
if (temp.valor > este.valor)
{
retornar 1;
}
senão if (temp.valor <este.valor)
{
retornar -1;
}
retornar 0;
}

booleano público é igual (objeto objeto)
{
retornar compararTo(obj) == 0;
}

String pública paraString()
{
retornar String.valueOf(valor);
}
}

Aqui está o código de teste:

Copie o código do código da seguinte forma:

vazio estático privado treeSetTest2()
{
TreeSet<Integer> set1 = new TreeSet<Integer>();
TreeSet<MeuInteger2> set2 = new TreeSet<MeuInteger2>();
Aleatório r = novo Aleatório();
para (int i = 0; i < 5; i++)
{
valor interno = r.nextInt(100);
set1.add(novo inteiro(valor));
set2.add(new MyInteger2(valor));
}
System.out.println("Set1 conforme abaixo:");
System.out.println(set1);
System.out.println("Set2 conforme abaixo:");
System.out.println(set2);
}

O resultado da execução do código é o esperado, conforme mostrado abaixo:

Copie o código do código da seguinte forma:

Conjunto 1 conforme abaixo:
[13, 41, 42, 45, 61]
Set2 conforme abaixo:
[61, 45, 42, 41, 13]

Mapa

O mapa armazena "pares de valores-chave". Semelhante ao Set, existem dois tipos de mapas em Java: classificados e não classificados incluem HashMap, Hashtable e LinkedHashMap, e classificados incluem TreeMap.
Mapa não classificado

Tanto HashMap quanto Hashtable são armazenados na forma de tabelas Hash. HashMap não é seguro para threads, mas Hashtable é seguro para threads. Podemos considerar o HashMap como uma versão "simplificada" do Hashtable.

HashMap pode armazenar nulo, seja para chave ou valor. Hashtable não pode armazenar nulo.

Independentemente de HashMap ou Hashtable, se observarmos seu construtor, descobriremos que ele pode ter dois parâmetros: inicialCapacity e loadFactor. Por padrão, inicialCapacity é igual a 16 e loadFactor é igual a 0,75. Isso está relacionado ao número de elementos que podem ser armazenados na tabela Hash. Quando o número de elementos exceder inicialCapacity*loadFactor, o método rehash será acionado para expandir a tabela hash. Se precisarmos inserir muitos elementos nele, precisaremos ajustar esses dois parâmetros de forma adequada.

Vejamos primeiro um exemplo de HashMap:

Copie o código do código da seguinte forma:

hashMapTest1() vazio estático privado
{
Map<Integer,String> map = new HashMap<Integer, String>();

map.put(novo Inteiro(1), "a");
map.put(novo Inteiro(2), "b");
map.put(novo Inteiro(3), "c");

System.out.println(mapa);
System.out.println(map.entrySet());
System.out.println(map.keySet());
System.out.println(map.valores());
}

Isso gerará as informações do elemento no HashMap, conforme mostrado abaixo.

Copie o código do código da seguinte forma:

{1=a, 2=b, 3=c}
[1=a, 2=b, 3=c]
[1, 2, 3]
[a, b, c]

O exemplo a seguir demonstra nulo:

Copie o código do código da seguinte forma:

hashMapTest2() vazio estático privado
{
Map<Integer,String> map = new HashMap<Integer, String>();

map.put(nulo,nulo);
map.put(nulo,nulo);
map.put(novo Inteiro(4), null);
map.put(novo Inteiro(5), null);

System.out.println(mapa);
System.out.println(map.entrySet());
System.out.println(map.keySet());
System.out.println(map.valores());
}

Os resultados da execução são os seguintes:

Copie o código do código da seguinte forma:

{nulo=nulo, 4=nulo, 5=nulo}
[nulo=nulo, 4=nulo, 5=nulo]
[nulo, 4, 5]
[nulo, nulo, nulo]

A seguir demonstramos Hashtable, que é basicamente igual aos dois exemplos acima (o código não será expandido):

Copie o código do código da seguinte forma:

Exemplo de tabela hash
hashTableTest1() vazio estático privado
{
Map<Integer,String> tabela = new Hashtable<Integer, String>();

tabela.put(novo Inteiro(1), "a");
tabela.put(novo Inteiro(2), "b");
tabela.put(novo Inteiro(3), "c");

System.out.println(tabela);
System.out.println(tabela.entrySet());
System.out.println(table.keySet());
System.out.println(tabela.valores());
}

hashTableTest2() vazio estático privado
{
Map<Integer,String> tabela = new Hashtable<Integer, String>();

tabela.put(nulo,nulo);
tabela.put(nulo,nulo);
tabela.put (novo inteiro (4), nulo);
tabela.put (novo inteiro (5), nulo);

System.out.println(tabela);
System.out.println(tabela.entrySet());
System.out.println(table.keySet());
System.out.println(tabela.valores());
}

Os resultados da execução são os seguintes:

Copie o código do código da seguinte forma:

{3=c, 2=b, 1=a}
[3=c, 2=b, 1=a]
[3, 2, 1]
[c, b, a]
Exceção no thread "principal" java.lang.NullPointerException
em java.util.Hashtable.put (fonte desconhecida)
em sample.collections.MapSample.hashTableTest2(MapSample.java:61)
em sample.collections.MapSample.main(MapSample.java:11)

Pode-se ver claramente que quando tentamos inserir nulo na tabela hash, uma exceção de ponteiro nulo é relatada.
SortMap

Sorting Map refere-se principalmente ao TreeMap, que tem uma complexidade de tempo de O(log(n)) ao adicionar, excluir e pesquisar elementos. Não é thread-safe.

Suas características são muito semelhantes às do TreeSet, por isso não entrarei em detalhes aqui.