"Olá, amigo!"
"Oi, Ellie!"
"Hoje vamos entender a estrutura das coleções de uma vez por todas."
"Eu esperei muito tempo por isso."
"Você já sabe o que são coleções e sabe como trabalhar com elas. É hora de organizar seu conhecimento em um sistema estrito. Então, muitos 'por que' e 'como' perguntas desaparecerão e a maioria das coisas se tornará óbvia."
" Interfaces de coleção . A estrutura de herança das interfaces de coleção é mais ou menos assim:"
Observe duas coisas.
Primeiro, tudo o que você vê aqui é uma interface.
Em segundo lugar, as setas significam «herdados».
"Em outras palavras, List, Set e Queue herdam Collection, mas Map não?"
"Sim. As classes abstratas herdam essas interfaces e, por sua vez, as implementações que você conhece herdam essas classes abstratas: ArrayList, Hashtable, TreeSet,… "
"Você está certo."
"Agora vamos ver para que servem os métodos dessas interfaces:"
Métodos do Iterable<E>: interface:
| Métodos | Descrição |
|---|---|
Iterator<T> iterator(); |
Retorna um objeto iterador. |
"Isso não parece o suficiente."
"Bem, isso é quantos existem. Isso é tudo para iteradores. Não os cobriremos agora, mas os cobriremos em detalhes em breve."
Métodos da Coleção<E>: interface:
| Métodos | Descrição |
|---|---|
boolean add(E e); |
Adiciona um elemento à coleção |
boolean addAll(Collection<? extends E> c); |
Adiciona elementos à coleção |
void clear(); |
Remove todos os elementos da coleção |
boolean contains(Object o); |
Verifica se a coleção contém o elemento. |
boolean containsAll(Collection<?> c); |
Verifica se a coleção contém os elementos. |
boolean equals(Object o); |
Verifica se as coleções são equivalentes |
int hashCode(); |
Retorna o código hash |
boolean isEmpty(); |
Verifica se a coleção está vazia. |
Iterator<E> iterator(); |
Retorna um objeto iterador |
boolean remove(Object o); |
Remove um elemento da coleção |
boolean removeAll(Collection<?> c); |
Remove elementos da coleção |
boolean retainAll(Collection<?> c); |
Remove todos os elementos que não estão em c |
int size(); |
Retorna o tamanho da coleção |
Object[] toArray(); |
Converte a coleção em uma matriz |
<T> T[] toArray(T[] a); |
Converte a coleção em uma matriz |
"Já sou sólido em tudo aqui. Usei metade desses métodos e encontrei a outra metade."
"Ótimo, vamos continuar então."
Métodos da List<E>: interface:
| Métodos | Descrição |
|---|---|
void add(int index, E element); |
Adiciona elementos no meio da coleção |
boolean addAll(int index, Collection<? extends E> c); |
Adiciona elementos à coleção |
E get(int index); |
Retorna um elemento por índice |
int indexOf(Object o); |
Retorna o índice (número) de um elemento |
int lastIndexOf(Object o); |
Retorna o índice do último elemento. |
ListIterator<E> listIterator(); |
Retorna um iterador para a lista |
ListIterator<E> listIterator(int index); |
Retorna um iterador para a lista |
E remove(int index); |
Remove um elemento pelo seu índice |
E set(int index, E element); |
Define um novo valor por índice |
List<E> subList(int fromIndex, int toIndex); |
Retorna uma subcoleção |
"Também aqui nada de radicalmente novo. Já sei quase tudo sobre coleções, o que não posso deixar de me alegrar."
"Bem, acho que posso encontrar algo que irá surpreendê-lo. Mas vamos continuar examinando as interfaces:"
Métodos do Set<E>: interface:
| Métodos | Descrição |
|---|---|
|
|
|
"A interface Set não possui nenhum método novo - apenas aqueles que ela herda."
"Sim, vi que a interface Interable também não tinha nada.
"Por outro lado, menos métodos significa menos para lembrar!"
"Seu otimismo de afirmação da vida me deixa feliz."
"A interface Set é herdada por duas interfaces com métodos: SortedSet e NavigableSet. Mas não vou passar por cima deles, ou nunca terminaremos."
"Em vez disso, deixe-me dar uma visão geral das classes e interfaces que descrevem as coleções em Java."
"Pode vir."
"Então segure firme:"
"Uau, isso é enorme!"
"Bem, não é tão grande. Além disso, lembre-se de que as classes abstratas são totalmente opcionais. Mas é bom lembrar qual classe implementa quais interfaces. Isso pode ser útil com bastante frequência."
"Ah, também gostaria de observar que algumas coleções são consideradas obsoletas."
"Quais são esses?"
"Estou falando sobre as classes Vector, Stack, Dictionary e Hashtable. Essas são versões sincronizadas (thread-safe) de coleções comuns."
"Mas Java adicionou uma biblioteca de simultaneidade especial com muitas coleções que não só podem ser acessadas de outros encadeamentos, mas também têm uma implementação muito mais eficiente. ConcurrentHashMap é muito mais eficiente que Hashtable ."
"Você pode usar as coleções Vector, Stack, Dictionary e Hashtable, mas isso não é recomendado."
"Entendi, vou manter isso em mente."
"Obrigado, Ellie!"
GO TO FULL VERSION