API Orientada a Objetos de Java - Wiki LES PUC-Rio

API e Coleções Java
Sérgio Luiz Ruivace Cerqueira
[email protected]
Java API
Introdução API
• Endereço
– http://download.oracle.com/javase/6/docs/api/
© LES/PUC-Rio
API - Descrição
© LES/PUC-Rio
API - Resumo
© LES/PUC-Rio
API - Detalhes
© LES/PUC-Rio
Coleções Java
Introdução a Coleções
• Coleção
– Objeto que agrupa múltiplos elementos em uma única unidade
– Armazena, recupera e manipula dados agregados
• Representa itens de dados que formam um grupo “natural”
– Como uma caixa de emails ou uma lista telefônica
• Implementações de coleção em versões Java pré-1.2
– Incluíam Vector, Hashtable e Array
– Não existia ainda um “framework de coleções”
© LES/PUC-Rio
Framework de Coleções
• Arquitetura unificada para representar e manipular coleções
• Interfaces
– Tipos abstratos de dados que representam coleções
– Coleções são manipuladas independentemente da representação
• Implementações
– Implementações concretas das interfaces de coleção
– Estruturas de dados reusáveis
• Algoritmos
– Métodos que realizam computações úteis
– Exemplo: busca e ordenação sobre objetos que implementam as
interfaces de coleção
– Ditos “polimórficos”
• mesmo método pode ser usado em diferentes implementações da interface
de coleção apropriada
– Funções reusáveis
© LES/PUC-Rio
Interfaces
• Hierarquia de diferentes tipos de coleções
• Permitem a manipulação de dados independentemente da
representação
• Set é um tipo especial de Collection
• SortedSet é um tipo de Set
• Hierarquia consiste de duas árvores diferentes
– Map não é um Collection verdadeiro
© LES/PUC-Rio
Interfaces
• Interfaces de coleção são genéricas
– public interface Collection<E>...
– <E> significa que a interface é genérica
• Declaração de instância de Collection
– Especificar o tipo de objeto contido na coleção
List<String> list = new ArrayList<String>();
• Permite verificação em tempo de compilação
– Tipo de objeto a ser armazenado na coleção está correto
© LES/PUC-Rio
Interfaces
• Collection
– Raiz da hierarquia de coleções
– Usada quando uma generalidade máxima é necessária
– Java não provê implementações diretas desta interface
• Set
– Coleção que não pode conter elementos duplicados
– Modela a abstração matemática de conjuntos
– Exemplo: processos executando em uma máquina
• List
– Chamada de seqüência, é uma coleção ordenada
– Pode conter elementos duplicados.
– O usuário de List pode controlar a posição em que um
elemento é inserido e acessa elementos através de um índice
– Noção de “vetores”
© LES/PUC-Rio
Interfaces
• Queue
– Coleção de elementos com prioridades associadas
– Provê operações de inserção, extração e inspeção
– Tipicamente ordena elementos no esquema FIFO
– Entre as exceções, estão as “filas de prioridade”
• Map
– Objeto que mapeia chaves e valores
– Não pode conter chaves duplicadas
– Corresponde ao uso de Hashtables
• SortedSet
– Set com elementos em ordem ascendente
• SortedMap
– Map com chaves em ordem ascendente
© LES/PUC-Rio
Interface Collection: Operações
public interface Collection<E> extends Iterable<E> {
//Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element); //optional
boolean remove(Object element); //optional
Iterator iterator();
//Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c); //optional
boolean retainAll(Collection<?> c); //optional
void clear(); //optional
//Array operations
Object[] toArray();
<T> T[] toArray(T[] a);
}
© LES/PUC-Rio
Interface Collection: Iterador
• Iterador
– Permite percorrer uma coleção e remover elementos
seletivamente.
public interface Iterator<E> {
boolean hasNext();
E next();
void remove(); //optional
}
– hasNext() retorna true se a iteração possui mais elementos
– next() retorna o próximo elemento na iteração.
– remove() remove o último elemento retornado pelo next()
• pode ser chamado somente uma vez por next()
• levanta exceção caso a regra seja violada
© LES/PUC-Rio
Interface Set: Implementações
• Implementa a abstração matemática de conjuntos
– Contém somente métodos herdados de Collection
– Adiciona a restrição de que duplicações não são possíveis
• Três implementações de Set:
– HashSet
• elementos em uma tabela hash
• melhor performance
• nenhuma garantia quanto à ordem de iteração
– TreeSet
• elementos em uma árvore vermelho-preto
• substancialmente mais lento que HashSet
• ordena elementos baseados em seus valores.
– LinkedHashSet
• elementos em uma tabela hash associada a uma lista encadeada
• apenas um pouco mais lento que HashSet
• ordena elementos por ordem de inserção
© LES/PUC-Rio
Interface Set: Operações
public interface Set<E> extends Collection<E> {
//Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element); //optional
boolean remove(Object element); //optional
Iterator iterator();
//Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c); //optional
boolean retainAll(Collection<?> c); //optional
void clear(); //optional
//Array operations
Object[] toArray();
<T> T[] toArray(T[] a);
}
© LES/PUC-Rio
Interface Set: Exemplo
import java.util.*;
public class FindDups {
public static void main(String args[]) {
Set<String> s = new HashSet<String>();
for (String a : args)
if (!s.add(a))
System.out.println("Duplicate: " + a);
System.out.println(s.size()+" distinct words: "+s);
}
}
• Toma palavras em args[] e imprime
– uma mensagem que indica se há duplicação de palavras
– o número de palavras distintas
– lista das plavras duplicadas eliminadas
© LES/PUC-Rio
Interface Set: Exemplo
• Saída do programa
– “java FindDups i came i saw i left”:
Duplicate: i
Duplicate: i
4 distinct words: [i, left, saw, came]
• HashSet não dá garantias quanto à ordem dos elementos no
Set
– Para obter as palavras em ordem alfabética, basta modificar
HashSet para TreeSet
• Nova saída para “java FindDups i came i saw i left”
Duplicate word: i
Duplicate word: i
4 distinct words: [came, i, left, saw]
© LES/PUC-Rio
Interface List: Implementações
• List
– Collection ordenado
– Pode conter duplicações
• List inclui as seguintes operações (além das de Collection)
– acesso posicional
• manipulação de elementos baseada na posição numérica destes na lista
– busca
• procura por um objeto especificado na lista e retorna sua posição numérica
– Iteração
• extende a semântica de Iterator, a fim de tirar vantagem da natureza
seqüencial da lista
– de intervalo
• operações em intervalos arbitrários da lista
• Implementações para List
– ArrayList (possui a melhor performance)
– LinkedList
© LES/PUC-Rio
Interface List: Operações
public interface List<E> extends Collection<E> {
//Positional access
E get(int index);
E set(int index, E element); //optional
boolean add(E element); //optional
void add(int index, E element); //optional
E remove(int index); //optional
abstract boolean addAll(int index, Collection<? extends E> c);
//optional
//Search
int indexOf(Object o);
int lastIndexOf(Object o);
//Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
//Range-view
List<E> subList(int from, int to);
}
© LES/PUC-Rio
Interface List: Operações
• Operações de iteração
– List provê um iterator sofisticado que permite
• percorrer a lista em ambas direções
• modificar a lista durante a iteração
• obter posição do iterador
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();
E next();
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void remove(); //optional
void set(E o); //optional
void add(E o); //optional
}
© LES/PUC-Rio
Exercício: Sintaxe e IDE Eclipse
• Escreva um programa que
– Entrada: ano no formato yyyy (ex: 1998, 2006,...)
– Saída: calendário do ano no formato:
• Dia da Semana, dia/mês/ano.
• Imprimir na Tela
• Exemplo:
– Entrada: 2006
– Saída:
Dom, 01/01/2006
Seg, 02/01/2006
Ter, 03/01/2006
...
Sab, 30/12/2006
Dom, 31/12/2006
© LES/PUC-Rio
Dica: use a documentação da
JAVA API
Fim