O documento apresenta as principais interfaces, implementações e algoritmos da Collection Framework do Java, incluindo List (ArrayList e LinkedList), Set (HashSet e TreeSet) e Map (HashMap e TreeMap). É explicado quando cada uma deve ser utilizada e quais são seus principais prós e contras.

1. Collection Framework
Lucas Santos
Lilian Tobace
Rafael Dias

2. Introdução
 Collections é um meio de apresentar interface, em que há implementações e
algoritmos da Collections Framework, este framework possui elementos que
ajudam o desenvolvedor aplicar em interfaces que necessitem de estruturas
de dados.
2

3. Collection Framework
 A Collection Framework possui os seguintes elementos:
 Interfaces: são tipos abstratos que representam as coleções
 Implementações: implementações concretas da interface.
 Algoritmos: Métodos que realizam operações sobre os objetos das coleçoe
3

4. Collection Framework
4

5. List
 List se encontra no pacote java.util.List, em que representa uma lista de
objetos que caracteriza-se pelo fato de conter elementos duplicados e são
ordenadas.
5

6. ArrayList: pros e contras
 Pro: Um Array dimensionado dinamicamente.
 Contra: Sempre que necessita o aumento, acontece em 50% do tamanho atual
criado um novo Array e isso tem alto custo computacional.
import java.util.ArrayList;
import java.util.Iterator;
public class Principal {
public static void main(String args[]) {
// a1 objeto do tipo ArrayList()
ArrayList al = new ArrayList();
al.add(3);
al.add(2);
al.add(1);
al.add(4);
al.add(5);
al.add(6);
al.add(6);
Iterator iter1 = al.iterator();
// hasNext() verifica se existe mais elementos.
while(iter1.hasNext()){
System.out.println(iter1.next());
}
// Mostrando o valor em posição especifica
System.out.println(al.get(2));
}
}
6

7. LinkedList: pros e contras
 Pro: Melhor performance nos métodos ADD e REMOVE em comparação ao
ArrayList.
 Contra: Pior performance nos métodos GET e SET em comparação ao
ArrayList.
import java.util.Iterator;
import java.util.LinkedList;
public class Principal {
public static void main(String args[]) {
// l1 objeto do tipo LinkedList()
LinkedList ll = new LinkedList();
ll.add(3);
ll.add(2);
ll.add(1);
ll.add(4);
ll.add(5);
ll.add(6);
ll.add(6);
Iterator iter2 = ll.iterator();
// hasNext() verifica se existe mais elementos.
while(iter2.hasNext()){
System.out.println(iter2.next());
}
}
}
7

8. Set
 Interface que faz parte do pacote java.util e representa grupo de elementos
sem duplicatas.
8

9. HashSet: pros e contras
 Pro: HashSet é o mais rápido dentre seus parecidos, deve se levar em conta
que toda estrutura de dados do tipo set não aceita valores repetidos.
 Contra: Não tem garantia de ordem com que os elementos são ordenados.
import java.util.HashSet;
import java.util.Iterator;
public class Principal {
public static void main(String args[]) {
// dset lista de objetos do tipo Dog
HashSet<Dog> dset = new HashSet<Dog>();
dset.add(new Dog(2));
dset.add(new Dog(1));
dset.add(new Dog(3));
dset.add(new Dog(5));
dset.add(new Dog(4));
Iterator<Dog> iterator = dset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
}
}
class Dog {
int size;
public Dog(int s) {
size = s;
}
public String toString() {
return size + "";
}
}
9

10. TreeSet: pros e contras
 Pro: Ordena automaticamente, e por isso a complexidade no seu ADD,
REMOVE e CONTAINS é maior que no HashSet.
import java.util.TreeSet;
import java.util.Iterator;
public class Principal {
public static void main(String args[]) {
TreeSet<Integer> tree = new TreeSet<Integer>();
tree.add(12);
tree.add(63);
tree.add(34);
tree.add(45);
Iterator<Integer> iterator = tree.iterator();
System.out.print("Tree set data: ");
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
}
}
10

11. TreeSet: pros e contras
 Contra: Por ser ordenado automaticamente quanto se utiliza Objetos como
tipo de dados é necessário ter o comparable para indicar qual campo servira
para a ordenação.
import java.util.TreeSet;
import java.util.Iterator;
public class Principal {
public static void main(String args[]) {
TreeSet<Dog> dset = new TreeSet<Dog>();
dset.add(new Dog(2));
dset.add(new Dog(1));
dset.add(new Dog(3));
Iterator<Dog> iterator = dset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
}
}
// Implementa o comparavel para poder usar o TreeSet com objetos
class Dog implements Comparable<Dog>{
int size;
public Dog(int s) {
size = s;
}
public String toString() {
return size + "";
}
@Override
public int compareTo(Dog o) {
return size - o.size;
}
}
11

12. Map
 Esta interface faz parte do pacote java.util e não possui métodos na interface
Collection, confia seus dados em um algoritmo hash, que transforma uma
grande quantidade e dados em uma pequena quantidade de informaçoes
12

13. HashMap: pros e contras
 Pro: É a classe mais utilizada da interface Map, pode se inserir valores e
chaves nulas.
 Contra: Um pouco complicada para a utilização de usuários iniciantes.
import java.util.HashMap;
import java.util.Map;
public class Principal {
public static void main(String[] args) {
// Inicializa a variavel mapaNomes como sendo do tipo HashMap
Map<String, String> mapaNomes = new HashMap<String, String>();
mapaNomes.put("1", "João Delfino");
mapaNomes.put("2", "Maria do Carmo");
mapaNomes.put("3", "Claudinei Silva");
// Exibe todos os elementos do mapaNomes
System.out.println(mapaNomes);
//resgatando o nome da posição 2
System.out.println(mapaNomes.get("2"));
}
}
13

14. TreeMap: pros e contras
 Pro: Esta classe apresenta ordenação pela chave.
 Contra: Apenas os valores podem ser nulos.
import java.util.Map;
import java.util.TreeMap;
public class Principal {
public static void main(String [] args) {
// Inicializa a variavel nomes como sendo do tipo TreeMap
Map<Integer,String> nomes = new TreeMap<Integer,String>();
nomes.put(5, "Eduardo");
nomes.put(3, "Luiz");
nomes.put(2, "Bruna");
nomes.put(4, "Sonia");
nomes.put(1, "Brianda");
nomes.put(7, "Julia");
nomes.put(6, "Carlos");
// Exibe todos os elementos de nomes
System.out.println(nomes);
// Resgata o nome da posição 5
System.out.println(nomes.get(5));
}
}
14

15. Conclusão
 Um ArrayList é utilizado quando se sabe quanto vai se armazenar nele, a
criação dinâmica de novos espaços.
 Um LinkedList possui melhor performance nos métodos add e remove, porém
perde performance em um get e set.
 HashSet usa HashTable em sua implementação, que por sinal é muito rápido
mas não garante a ordenação dos seus elementos.
 Um TreeSet perde um pouco em velocidade, porém ele ordena os elementos
automaticamente, não importa a ordem que forem inseridos.
 Um HashMap tem valor e chave nula porém é um pouco trabalhoso de se
utilizar.
 Um TreeMap é bem mais fácil de se utilizar, porém apenas os valores podem
ser nulos, chaves não.
15

16. Referências
 CARLOS - Java Collections: Como utilizar Collections – 2010 -
https://www.devmedia.com.br/java-collections-como-utilizar-collections/18450
 RONALDO - Diferença entre ArrayList, Vector e LinkedList em Java – 2013 -
https://www.devmedia.com.br/diferenca-entre-arraylist-vector-e-linkedlist-em-java/29162
 RONALDO - Diferenças entre TreeSet, HashSet e LinkedHashSet em Java – 2013 -
https://www.devmedia.com.br/diferencas-entre-treeset-hashset-e-linkedhashset-em-java/29077
 THIAGO - Conhecendo a interface Map do Java – 2016 -
https://www.devmedia.com.br/conhecendo-a-interface-map-do-java/37463
16