Desenvolvimento e
Projeto de
Aplicações Web
[email protected]
Conteúdo
• Coleções
1
Introdução
• Desde a versão 1.2 do JDK, a
plataforma J2SE inclui um
framework de coleções
(Collections)
• Uma coleção é um objeto que
representa um grupo de objetos
• Um framework de coleções é
uma arquitetura unificada para
representação e manipulação de
coleções, permitindo que elas
sejam manipuladas
independentemente dos
detalhes de sua implementação
Coleções: Tipos
Estruturados
• Uma coleção é um tipo de dado
estruturado usado para agrupar, em
uma única unidade, vários
elementos homogêneos ou
heterogêneos
• Cada coleção é um objeto usado
para armazenar, recuperar e fazer
operações sobre dados
• Java Collections Framework:
Conjunto de interfaces,
implementações e algoritmos
2
Vantagens
• Redução do esforço de
programação
– Estruturas de dados e algoritmos úteis,
para diminuir reescrita
• Aumento da performance
– implementações de alta performance
– Como as várias implementações de
cada interface são substituíveis, os
programas podem ser facilmente
refinados trocando-se as
implementações
Vantagens
• Interoperabilidade entre
APIs não relacionadas
– Estabelecendo uma linguagem
comum para passagem de
coleções
• Redução do esforço de
aprendizado de APIs
– Eliminando a necessidade de se
aprender várias APIs de
coleções diferentes.
3
Vantagens
• Redução do esforço de
projetar e implementar APIs,
– Eliminando a necessidade de se
criar APIs de coleções próprias
• Promover o reuso de
software,
– Fornecendo uma interface
padrão para coleções e
algoritmos para manipulá-los.
Java Collections
Framework
• A biblioteca de coleções é
composta por:
– Interfaces: tipos abstratos que
representam coleções e unificam
as sua operações.
– Implementações:
implementações das interfaces,
usadas para criar objetos
4
Coleções (Java
Collections Framework)
• A biblioteca de coleções
(collecions) é composta por:
– Algoritmos: atuam sobre objetos
que implementam as interfaces e
oferecem serviços como
pesquisa e ordenação
• Pacote:
– java.util.*;
Collection
• Interface base para todos os
tipos de coleção.
• Define as operações básicas
para coleções de objetos,
– adição (add) e remoção (remove),
esvaziamento (clear), tamanho
(size), conversão para array
(toArray), objeto de iteração
(iterator), e verificações de
existência (contains e isEmpty)
5
Coleções Básicas
• Base: interface
java.util.Collection e Map
• Interfaces de tipos fundamentais
– List: coleção ordenada que pode
conter elementos duplicados.
Implementada pela classe Vector
– Map: mapeamento chave-valor, sendo
cada chave única. Especialização:
SortedMap
– Set: coleção sem elementos
duplicados. Especialização: SortedSet
Coleções Básicas
• Cada interface é
implementada com
diferentes estruturas de
dados. Ex: HashSet, TreeSet
class Vector: implementa um array
dinâmico
6
Coleções Básicas
Hierarquia de
Coleções em Java
• Hierarquias distintas:
Collection e Map
• Collection: todos os métodos
que são comuns às coleções
gerais
• Map: todos os métodos que são
comuns a coleções de pares de
elementos
7
Collection:
Operações Básicas
• A interface Collection contém
os métodos abstratos para as
operações fundamentais
public interface Collection {
// Operações básicas
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element);
// Optional
boolean remove(Object element); // Optional
Iterator iterator();
// ...
Importante: Cada coleção
implementa suas operações
Exemplo de Vector
import java.util.*;
public class TestaVector{
public static void main(String args[]){
Vector vetor = new Vector();
vetor.add(new Integer(100));
Casting: Object x Integer
vetor.add(new Integer(200));
e
vetor.add(new Integer(300));
conversão: Integer x int
int soma=0; int elem;
for(int i=0; i<vetor.size();i++){
elem=((Integer)vetor.elementAt(i)).intValue(
);
soma+=elem;
}
System.out.println("Soma: " + soma);
}}
8
Vector com classe do
usuário
public class Professor {
public String nome;
public Ramal ramal;
public Professor(String n,
int r){
nome = n;
ramal = new Ramal(r);
}
public String toString(){
return "Nome: "+ nome +
", Ramal: " + ramal.numero;
}}
Considerando
a classe
Professor
Vector com classe do
usuário: teste
import java.util.*;
public class VectorProfessor{
Um Vector
public static void main(String args[]){
Vector <Professor> professores = Professor
new
Vector();
professores.add(new Professor("Manuela",
3344));
professores.add(new Professor("Carlos",
1549));
professores.add(new Professor("Roberto",
6678);
System.out.println(professores);
Exibe os
[Nome: Manuela, Ramal: 3344,
}
Nome:
Carlos,
Ramal:
1549,
elementos
}
Nome: Roberto, Ramal: 6678]
9
Array x Vector
• Array
– Limitações de tamanho
– Exemplo:
private Conta[] contas;
private final static int tamCache = 100;
contas = new Conta[tamCache];
Array
10
Problemas com Array
• Precisamos saber o
tamanho do array antes de
utilizar
• Operações de inclusão,
alteração e exclusão são
limitadas
• Tamanho do array é fixo, o
que normalmente não
ocorre em uma coleção
Usando Vector
• O Vector tem tamanho variável
• Possui operações de inclusão,
alteração e exclusão
• A iteração, localização etc.. é
mais simples
• Para usar o método sort da
classe Array, basta transformar
para um array através do
método.toArray()
11
Exemplo com Vector
Interface Map:
Operações Básicas
chave
chave
chave
valor
valor
valor
public interface Map {
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
...
}
12
Exemplo
HashMap:
chave: String disciplina
valor: Professor
Vector<Professor> professores = new Vector();
professores.add(new Professor("Manuela", 3344));
professores.add(new Professor("Carlos", 1549));
professores.add(new Professor("Roberto", 6678));
System.out.println(professores);
String[] disciplinas= {"matemática",
“física","português"};
HashMap vincula=new HashMap();
int p=0;
for(String s:disciplinas){
vincula.put(s, professores.elementAt(p++));
}
System.out.println(vincula);
{português=Roberto, Ramal: 6678, física=Carlos, Ramal: 1549, ...}
Outras Operações
• A interface Collection também contém
os métodos abstratos para operações
sobre o agrupamento
// operações com coleções
boolean containsAll(Collection c);
boolean addAll(Collection c);
//
boolean removeAll(Collection c); //
boolean retainAll(Collection c); //
void clear();
//
Optional
Optional
Optional
Optional
// operações com arrays
Object[] toArray();
Object[] toArray(Object a[]);
13
Interfaces Auxiliares
• Iterator
• Navegação nos elementos da coleção
Conta c;
Collection contas =
controladorContas.getContas();
Iterator it = contas.iterator();
while (it.hasNext()) {
c = (Conta) it.next();
System.out.println(“Numero = “ +
c.getNumero() + “ Saldo = “ +
c.getSaldo());
}
Interfaces Auxiliares
• ListIterator
• Interface que estende
Iterator, adicionando funções
específicas para coleções do
tipo List
• É obtida através do método
listIterator() de uma List
• Operações de navegação em
ambos os sentidos
14
Interfaces Auxiliares
• Uma coleção ordenada deve
possuir alguma forma de
comparação entre os
elementos para se
determinar a sua ordem
• Implementar Comparable
• Comparação do próprio
objeto com outro
Comparable
• Definir a ordem natural dos
elementos de uma coleção
• Método compareTo(Object
obj)
– Compara a ordem do objeto atual
com obj
– Retorna um inteiro negativo, zero
ou um inteiro positivo se o objeto
atual é menor, igual ou maior do
que obj
15
Comparable
• Para alguns tipos de objetos –
Integer, Double ou String –
existe uma ordem “natural”
• Ao adicionar um elemento em
uma coleção ordenada que está
utilizando ordenação natural, o
elemento deve ser uma instância
de uma classe que implementa a
interface Comparable
Interfaces Auxiliares
• Comparator
• Comparação entre dois objetos
por um objeto externo.
• É utilizado quando os objetos a
serem adicionados não podem
ser modificados para aceitarem
a interface Comparable
– Exemplo: biblioteca de terceiros ou é
necessária a troca da estratégia de
ordenação em tempo de execução
como em ordenação das linhas de
uma tabela, por exemplo
16
Comparator
public static class
CaseInsensitiveComparator
implements Comparator {
public int compare(Object e1,
Object e2) {
String l1 =
e1.toString().toLowerCase();
String l2 =
e2.toString().toLowerCase();
return l1.compareTo(l2);
}
}
Interfaces Auxiliares
• Enumeration
• “Ancestral” da interface
Iterator, com as mesmas
funções, exceto a deleção de
elementos
• Métodos hasMoreElements() e
nextElement() contra
hasNext() e next() de
Iterator
– Dificuldades no código
• Utilizada basicamente apenas
nas classes Vector e Hashtable
17
Exercício
1. Implemente as classes do
projeto projetoAeroporto
para gerar e imprimir uma
lista de 10 passageiros em
ordem alfabética. Utilizar
os conceitos do framework
collection
2. Refaça o exercício anterior
para que a lista de
passageiros não permita
repetições
Arrays
• Arrays são ideais para organizar
um número fixo de elementos de
um mesmo tipo:
– String[] diasDaSemana =
{“Seg”,"Ter",“Qua",“Qui",”Sex
",“Sab", “Dom"};
• Normalmente, é difícil prever
quantos elementos uma coleção
pode ter
– “Engessamento”
18
Arrays
• Um Array apesar de ser uma
coleção, possui limitação de
tamanho fixo
• Todas as demais coleções do
framework Java não possuem
limitação de tamanho
previamente determinado
– A coleção vai gerenciando seu
tamanho à medida em que os itens
são adicionados/removidos
ArrayList
19
Genéricos
• Antes da versão 5.0 da linguagem
Java, toda coleção era criada para
objetos do tipo genérico Object
• Complicações na recuperação de
objetos na coleção
• ArrayList<Aluno> alunos = new
ArrayList<Aluno>();
• ArrayList<Professor> fac = new
ArrayList<Professor>();
• ArrayList<String> nomes = new
ArrayList<String>();
ArrayList
Métodos
• boolean add(Tipo
elemento):
– Adiciona o elemento ao fim da lista
– Tipo faz referência ao tipo
especificado no <...> na criação do
ArrayList
• void add(int n, Tipo
elemento):
– Insere o elemento na n-ésima
posição na lista, deslocando os
elementos subsequentes
20
ArrayList
Métodos
• void add(int n, Tipo
elemento):
ArrayList
Métodos
• boolean
addAll(Collection c):
– Insere todos os elementos da
coleção c no final da lista
• void clear():
– Remove todos os elementos da
lista
21
ArrayList
Métodos
• boolean contains(Object
o1):
– Retorna true, caso o objeto o1 esteja
presente na lista, e retorna false, em
caso contrário
• int size():
– Retorna o número de elementos da
lista. Caso a lista esteja vazia, esse
valor é 0
• boolean isEmpty():
– Retorna true se a lista está vazia e
false em caso contrário
ArrayList
Métodos
• boolean remove(Object
o1):
– Localiza e remove da lista uma
instância do objeto o1,
retornando true caso o objeto
tenha sido removido e false em
caso contrário
22
ArrayList
Iteração
• Loop de iteração da versão 5.0:
for (Tipo variavelReferencia:
nomeColecao) {
// manipula a variavelReferencia
// com as ocorrências da coleção
}
ArrayList
Cópia em Array
23
HashMap
• HashMap é uma coleção do
tipo dicionário onde cada
objeto pode ser acessado
por um valor de chave único
• Cada objeto na coleção e
sua chave podem ser de
qualquer tipo
HashMap
24
HashMap
Exemplo
HashMap
Exemplo (Continuação)
25
HashMap
Exemplo (Continuação)
Projeto
• Refazer o projeto para, no
lugar de Arrays de objetos,
usar coleções do tipo
ArrayList ou HashMap
26
Referências
• Deitel, capítulo 19
27