Programação Orientada a Objetos com Java

Programação Orientada a Objetos
SANTOS, Rafael (PLT)
Poupam trabalho ao programador e
melhoram a legibilidade do código
 Servem para armazenar agrupamentos de
objetos
 Classes e interfaces de java.util, como:
Collection, Set, List, Map, TreeSet,
HashSet, LinkedHashSet, ArrayList,
LinkedList, TreeMap, HashMap,
LinkedHashMap
 São genéricos e devem ter o tipo entre <...>

Não admitem elementos duplicados
 Podem ser vazios e aumentar de tamanho
 Algumas implementações de Set: TreeSet,
HashSet e LinkedHashSet
 Exemplos:

 Turma é um conjunto de alunos
 Aplicação é um conjunto de classes
 Sorteio de loteria é um conjunto de números
Implementação de Set que usa uma árvore
para manter a ordenação natural de seus
elementos
 Performance inferior a HashSet para
modificação do conjunto
 Ver classe:

 Loteria
 ListaDePalavras
 DemoListaDePalavras
Implementação de Set que não garante
qualquer ordenação, nem mesmo a ordem
de entrada
 Performance para modificação melhor que
TreeSet
 Implementa apenas os métodos de Set
 Ver classe:

 OperacoesEmConjuntos
Implementação de Set que garante a ordem
de entrada
 Performance inferior a HashSet para todas as
operações

Mecanismo de iteração que cria uma visão
dos objetos contidos em uma coleção
 Cada classe tem uma implementação
diferente para a visão de iteração, mas todas
implementam Iterator o que permite um
tratamento padrão (polimórfico).
 Principais métodos:

 boolean hasNext()
 E next()
 void remove()
Integer a[] = { 12, 45, 65, 29, 10, 33, 78, 37, 65 };
Set<Integer> ts = new TreeSet<Integer>(Arrays.asList(a));
Set<Integer> hs = new HashSet<Integer>(Arrays.asList(a));
Set<Integer> lhs = new
LinkedHashSet<Integer>(Arrays.asList(a));
Iterator<Integer> its = ts.iterator();
Iterator<Integer> ihs = hs.iterator();
Iterator<Integer> ilhs = lhs.iterator();
while(its.hasNext()) {
System.out.println(its.next() + "-" + ihs.next() +
"-" + ilhs.next());
}

Estrutura for aprimorado
ihs = hs.iterator();
for(Integer e: ts) {
System.out.println(e + "-" + ihs.next());
}

Arrays gerados a partir da coleção
Integer b[] = ts.toArray(new Integer[0]);
for(int j = 0; j < b.length; j++) {
System.out.println(b[j]);
}


E first()
E last()
Primeiro
Último


E ceiling(E e)
E floor(E e)
Maior ou igual
Menor ou igual


E higher(E e)
E lower(E e)
Maior
Menor


E pollFirst()
E pollLast()
Retorna e retira primeiro
Retorna e retira último

Iterator<E> descendingIterator()



SortedSet<E> headSet(
E ateElementoExclusive)
Início até
SortedSet<E> subSet(
E doElementoInclusive,
E ateElementoExclusive)
Meio do e até
SortedSet<E> tailSet(
E doElementoInclusive)
Fim do













boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object/E o)
boolean containsAll(Collection<?> c)
boolean isEmpty()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
E[] toArray(new E[0])
Iterator<E> iterator()
Admitem objetos duplicados
 Algumas implementações de List: ArrayList
e LinkedList
 Ver classes:

 MovimentoDeRobo
 RoboComMemoria
 DemoRoboComMemoria
 Votacao
 DemoVotacao
Implementação de List que encapsula um
array,redimensionando-o sempre que
necessário
 Mais rápido que LinkedList para iteração
(acesso contínuo ininterrupto)
 Mais lento que LinkedList para modificação
(inserção e exclusão)
 Possui métodos para gerenciamento da
capacidade






Implementação da interface List, que
encapsula uma lista encadeada
Mais lento que ArrayList para iteração
Mais rápido que ArrayList para modificação
Possui métodos que facilitam a criação de
estruturas de dados comuns como pilhas e
filas
Ver classes:
 Votacao e DemoVotacao
Integer a[] = { 12, 45, 65, 29, 10, 33, 78, 37, 65 };
List<Integer> al = new
ArrayList<Integer>(Arrays.asList(a));
List<Integer> ll = new
LinkedList<Integer>(Arrays.asList(a));
Iterator<Integer> ial = al.iterator();
Iterator<Integer> ill = ll.iterator();
while(ial.hasNext()) {
System.out.println(ial.next() + "-" + ill.next());
}








void add(int index, E element)
boolean addAll(int index,
Collection<? extends E> c)
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
E remove(int index)
E set(int index, E element)
List<E> subList(int fromIndex,
int toIndex)
void addFirst(E e)
void addLast(E e)
E getFirst()
E getLast()
E removeFirst()
E removeLast()
void Collections.sort(List)
 int Collections.binnarySearch(List, key)



Interface Comparable<Tipo>
Método int compareTo(objeto)
Conjuntos associativos em que um valor está
associado a uma chave exclusiva
 Não estende Collection
 Algumas das classes que implementam a
interface Map: HashMap, LinkedHashMap e
TreeMap
 Ver classe:

 DicionarioDeIPs
Map<String, String> tm = new TreeMap<String, String>();
Map<String, String> hm = new HashMap<String, String>();
Map<String, String> lhm = new LinkedHashMap<String,
String>();
tm.put("JE", "Jose Eduardo"); tm.put("AM", "Amanda");
tm.put("EL", "Elias");
hm.put("JE", "Jose Eduardo"); hm.put("AM", "Amanda");
hm.put("EL", "Elias");
lhm.put("JE", "Jose Eduardo"); lhm.put("AM", "Amanda");
lhm.put("EL", "Elias");
System.out.println("tm: " + tm + "\nhm: " + hm +
"\nlhm: " + lhm);
V put(K key, V value)
void putAll(
Map<? extends K,? extends V> m)
boolean containsKey(Object key)
boolean containsValue(Object value)
V get(Object key)
V remove(Object key)
Set<K> keySet()
Collection<V> values()