Java Collections - Tomaz Lavieri
Upcoming SlideShare
Loading in...5
×
 

Java Collections - Tomaz Lavieri

on

  • 8,759 views

 

Statistics

Views

Total Views
8,759
Views on SlideShare
8,723
Embed Views
36

Actions

Likes
6
Downloads
268
Comments
1

4 Embeds 36

http://www.slideshare.net 17
https://blogs.oracle.com 10
http://blogs.sun.com 5
http://blogs.oracle.com 4

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Java Collections - Tomaz Lavieri Java Collections - Tomaz Lavieri Presentation Transcript

  • Java Collections – Conceitos Básicos Collections Tomaz Lavieri Sun Certified Java Programmer 6 tomazlavieri@gmail.com http://java-i9se.blogspot.com.br
  • Collections Objetivos: • Ao final desta apresentação espera-se que você saiba: – Distinguir cada tipo de Coleção. – Escolher a melhor implementação de Coleção para cada tipo de uso. – Saber a diferença entre as Interfaces: Collection, Set, Queue, List, SortedSet, NavigableSet, Map, SortedMap e NavigableMap. – Conhecer as implementações básicas: ArrayList, Vector, LinkedList, PriorityQueue, TreeSet, HashSet, LinkedHashSet, TreeMap, HashMap e LinkedHashMap.
  • Collections Objetivos: • Ao final desta apresentação espera-se que você saiba: – Distinguir cada tipo de Coleção. – Escolher a melhor implementação de Coleção para cada tipo de uso. – Saber a diferença entre as Interfaces: Collection, Set, Queue, List, SortedSet, NavigableSet, Map, SortedMap e NavigableMap. – Conhecer as implementações básicas: ArrayList, Vector, LinkedList, PriorityQueue, TreeSet, HashSet, LinkedHashSet, TreeMap, HashMap e LinkedHashMap.
  • Collections Objetivos: • Ao final desta apresentação espera-se que você saiba: – Distinguir cada tipo de Coleção. – Escolher a melhor implementação de Coleção (entre as básicas) para cada tipo de uso. – Saber a diferença entre as Interfaces: Collection, Set, Queue, List, SortedSet, NavigableSet, Map, SortedMap e NavigableMap. – Conhecer as implementações básicas: ArrayList, Vector, LinkedList, PriorityQueue, TreeSet, HashSet, LinkedHashSet, TreeMap, HashMap e LinkedHashMap.
  • Collections Objetivos: • Ao final desta apresentação espera-se que você saiba: – Distinguir cada tipo de Coleção. – Escolher a melhor implementação de Coleção (entre as básicas) para cada tipo de uso. – Saber a diferença entre as Interfaces: Collection, Set, Queue, List, SortedSet, NavigableSet, Map, SortedMap e NavigableMap. – Conhecer as implementações básicas: ArrayList, Vector, LinkedList, PriorityQueue, TreeSet, HashSet, LinkedHashSet, TreeMap, HashMap e LinkedHashMap.
  • Collections Objetivos: • Ao final desta apresentação espera-se que você saiba: – Distinguir cada tipo de Coleção. – Escolher a melhor implementação de Coleção (entre as básicas) para cada tipo de uso. – Saber a diferença entre as Interfaces: Collection, Set, Queue, List, SortedSet, NavigableSet, Map, SortedMap e NavigableMap. – Conhecer as implementações básicas: ArrayList, Vector, LinkedList, PriorityQueue, TreeSet, HashSet, LinkedHashSet, TreeMap, HashMap e LinkedHashMap.
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Existe a dificuldade da inflexibilidade. – Muito rígido, é preciso definir seu tamanho assim que nós a criamos – Object[] minhaArray = new Object[10]; – E se eu precisar agora de 20 lugares ? Como aumentar o tamanho e manter os 10 originais ? – Object[] novaArray = new Object[20]; – System.arraycopy(minhaArray,0,novaArray,0,10); – Como facilitar isto? – Como usar o conceito de array ? Porém com um pouco mais de flexibilidade?
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Arrays: – Coleções pode ser a saída para este problema – Uma das formas de pensar nas coleções são como Arrays turbinadas, incrementadas com várias funcionalidades e regras. – É comum aprender apenas sobre ArrayList – E usá-la para substituir as arrays (porém existe muitas outras). – É necessário saber que existe algumas regras que regem as Coleções – E é por essas regras que são pré-requisitos para os nossos estudos sobre Collections que iremos começar.
  • Collections • Pré-requisitos:
  • Collections • Pré-requisitos: – Igualdade: Para se trabalhar com coleções é preciso entender a igualdade em Java
  • Collections • Pré-requisitos: – Igualdade: Para se trabalhar com coleções é preciso entender a igualdade em Java • Porque é preciso?
  • Collections • Pré-requisitos: – Igualdade: Para se trabalhar com coleções é preciso entender a igualdade em Java • Porque é preciso? – Quando chegarmos lá tudo ficará mais claro, mas adiantando, varias funcionalidades de coleções como contains(Object o) – que verifica se existe um objeto na coleção – precisa testar a igualdade para funcionar.
  • Collections • Como funciona igualdade em Java ? pessoa1 == pessoa2
  • Collections • Como funciona igualdade em Java ? pessoa1 == pessoa2 • Isso irá testar apenas se as duas variáveis referenciam uma única instancia!
  • Collections • Como então saber, por exemplo, quando dois objetos Pessoa são significantemente iguais?
  • Collections • Como então saber, por exemplo, quando dois objetos Pessoa são significantemente iguais? – Para esse tipo de teste você deve usar um método que todo objeto Java tem equals(Object o)
  • Collections • Como então saber, por exemplo, quando dois objetos Pessoa são significantemente iguais? – Para esse tipo de teste você deve usar um método que todo objeto Java tem equals(Object o) • Então nosso teste de igualdade seria: pessoa1.equals(pessoa2)
  • Collections • Só isso resolve?
  • Collections • Só isso resolve? – Não
  • Collections • Só isso resolve? – Não • Por padrão o método equals de Object faz o mesmo que o operador ==
  • Collections • Só isso resolve? – Não • Por padrão o método equals de Object faz o mesmo que o operador == public class Object { //.. public boolean equals(Object obj) { return (this == obj); } //…
  • Collections • Então se queremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais?
  • Collections • Então se queremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais? – Neste caso nós precisamos ensinar ao nosso programa a igualdade entre nossos objetos
  • Collections • Então se queremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais? – Neste caso nós precisamos ensinar ao nosso programa a igualdade entre nossos objetos • Como fazer isso??
  • Collections • Então se queremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais? – Neste caso nós precisamos ensinar ao nosso programa a igualdade entre nossos objetos • Como fazer isso?? – Sobrescrevendo o equals
  • Collections • Mas não basta simplesmente sobrescrever!
  • Collections • Mas não basta simplesmente sobrescrever! • E existe um contrato de equals que deve ser rigorosamente seguido para o bom funcionamento do programa e da Java Collections Framework
  • Collections • O contrato diz que equals é: – Reflexível: a.equals(a) == true – Simétrico: a.equals(b) == b.equals(a) – Transitivo: se a.equals(b) && b.equals(c) == true .:. a.equals(c) também é true. – Consistente: a.equals(b) deve retornar sempre true ou sempre falso, desde que nenhuma propriedade do do Objeto que faz parte do teste equals seja alterada. – Deve retornar false quando testado contra uma variável null
  • Collections • O contrato diz que equals é: – Reflexível: a.equals(a) == true – Simétrico: a.equals(b) == b.equals(a) – Transitivo: se a.equals(b) && b.equals(c) == true .:. a.equals(c) também é true. – Consistente: a.equals(b) deve retornar sempre true ou sempre falso, desde que nenhuma propriedade do do Objeto que faz parte do teste equals seja alterada. – Deve retornar false quando testado contra uma variável null
  • Collections • O contrato diz que equals é: – Reflexível: a.equals(a) == true – Simétrico: a.equals(b) == b.equals(a) – Transitivo: se a.equals(b) && b.equals(c) == true .:. a.equals(c) também é true. – Consistente: a.equals(b) deve retornar sempre true ou sempre falso, desde que nenhuma propriedade do do Objeto que faz parte do teste equals seja alterada. – Deve retornar false quando testado contra uma variável null
  • Collections • O contrato diz que equals é: – Reflexível: a.equals(a) == true – Simétrico: a.equals(b) == b.equals(a) – Transitivo: se a.equals(b) && b.equals(c) == true .:. a.equals(c) == true. – Consistente: a.equals(b) deve retornar sempre true ou sempre falso, desde que nenhuma propriedade do do Objeto que faz parte do teste equals seja alterada. – Deve retornar false quando testado contra uma variável null
  • Collections • O contrato diz que equals é: – Reflexível: a.equals(a) == true – Simétrico: a.equals(b) == b.equals(a) – Transitivo: se a.equals(b) && b.equals(c) == true .:. a.equals(c) == true – Consistente: a.equals(b) deve retornar sempre true ou sempre falso, desde que nenhuma propriedade do do Objeto que faz parte do teste equals seja alterada. – Deve retornar false quando testado contra uma variável null
  • Collections • Portanto para nossa classe Pessoa podemos definir um equals assim: public class Pessoa { private String cpf; //... @Override public boolean equals(Object p) { if (cpf == null) return false; return (p instanceof Pessoa) && this.cpf.equals(((Pessoa)p).cpf); } //... }
  • Collections • Portanto para nossa classe Pessoa podemos definir um equals assim: public class Pessoa { private String cpf; //... @Override // não é necessário mas é bom public boolean equals(Object p) { if (cpf == null) return false; return (p instanceof Pessoa) && this.cpf.equals(((Pessoa)p).cpf); } //... }
  • Collections • Portanto para nossa classe Pessoa podemos definir um equals assim: Eu não podia colocar public class Pessoa { A classe Pessoa? private String cpf; No lugar de Objeto ? //... @Override public boolean equals(Object p) { Pessoa if (cpf == null) return false; return (p instanceof Pessoa) && this.cpf.equals(((Pessoa)p).cpf); } //... }
  • Collections • Portanto para nossa classe Pessoa podemos definir um equals assim: Eu não podia colocar public class Pessoa { A classe Pessoa? private String cpf; No lugar de Objeto ? //... @Override public boolean equals(Object p) { Pessoa if (cpf == null) NÃO!!!! return false; Pois é preciso return (p instanceof Pessoa) && sobrescrever o this.cpf.equals(((Pessoa)p).cpf); método da classe } Object e portanto //... manter a mesma } assinatura
  • Collections • Então é isso basta sobrescrever o método equals corretamente na minha classe e já posso usar: pessoa1.equals(pessoa2) • Não preciso fazer mais nada?
  • Collections • Então é isso basta sobrescrever o método equals corretamente na minha classe e já posso usar: pessoa1.equals(pessoa2) • Não preciso fazer mais nada? – ERRADO! Precisa sim! E é ai o erro mais comum de quem trabalha com collections
  • Collections • Então é isso basta sobrescrever o método equals corretamente na minha classe e já posso usar: pessoa1.equals(pessoa2) • Não preciso fazer mais nada? – ERRADO! Precisa sim! E é ai o erro mais comum de quem trabalha com collections • O contrato de equals(Object o) esta fortemente ligado ao de hashCode()
  • Collections • E pra que serve esse hashCode() ?
  • Collections • E pra que serve esse hashCode() ? – Calma que assim que chegar em coleções falaremos dele ao estudar HashSet, LinkedHashSet, HashMap, LinkedHashMap e Hashtable
  • Collections • E pra que serve esse hashCode() ? – Calma que assim que chegar em coleções falaremos dele ao estudar HashSet, LinkedHashSet, HashMap, LinkedHashMap e Hashtable • Certo mas então o que ele tem a ver com meu teste de igualdade ??
  • Collections • E pra que serve esse hashCode() ? – Calma que assim que chegar em coleções falaremos dele ao estudar HashSet, LinkedHashSet, HashMap, LinkedHashMap e Hashtable • Certo mas então o que ele tem a ver com meu teste de igualdade ?? – As definições do contrato de hashCode() o ligam diretamente ao teste de igualdade, portanto sempre que sobrescrever equals(Object o) você terá que sobrescrever também o hashCode()
  • Collections • O contrato do hashCode() diz: – É constante: qualquer chamada a hashCode() deve sempre retornar o mesmo interiro, desde que as propriedade usadas no teste equals(Object o) não sejam alteradas. – É igual para objetos iguais: a.equals(b) == true .:. a.hashCode() == b.hashCode() – Não é necessário ser diferente para objetos diferentes: ou seja, se a.equals(b) == false .:. a.hashCode() == b.hashCode() || hashCode() != b.hashCode()
  • Collections • O contrato do hashCode() diz: – É constante: qualquer chamada a hashCode() deve sempre retornar o mesmo inteiro, desde que as propriedade usadas no teste equals(Object o) não sejam alteradas. – É igual para objetos iguais: a.equals(b) == true .:. a.hashCode() == b.hashCode() – Não é necessário ser diferente para objetos diferentes: ou seja, se a.equals(b) == false .:. a.hashCode() == b.hashCode() || hashCode() != b.hashCode()
  • Collections • O contrato do hashCode() diz: – É constante: qualquer chamada a hashCode() deve sempre retornar o mesmo inteiro, desde que as propriedade usadas no teste equals(Object o) não sejam alteradas. – É igual para objetos iguais: a.equals(b) == true .:. a.hashCode() == b.hashCode() – Não é necessário ser diferente para objetos diferentes: ou seja, se a.equals(b) == false .:. a.hashCode() == b.hashCode() || hashCode() != b.hashCode()
  • Collections • O contrato do hashCode() diz: – É constante: qualquer chamada a hashCode() deve sempre retornar o mesmo inteiro, desde que as propriedade usadas no teste equals(Object o) não sejam alteradas. – É igual para objetos iguais: a.equals(b) == true .:. a.hashCode() == b.hashCode() – Não é necessário ser diferente para objetos diferentes: ou seja, se a.equals(b) == false .:. a.hashCode() == b.hashCode() || hashCode() != b.hashCode()
  • Collections • Por padrão o método hashCode() é diferente para cada instancia de Object. • Não é implementado em java e sim com linguagem nativa: public class Object { //.. public native int hashCode(); //… }
  • Collections • Por padrão o método hashCode() é diferente para cada instancia de Object. • Não é implementado em java e sim com linguagem nativa: public class Object { //.. public native int hashCode(); //… }
  • Collections • Portanto no nosso modelo dois objetos Pessoa com o mesmo cpf, vai retornar hashCode diferentes (pois esse é o padrão do hashCode) • Isto fere o contrato de hashCode, pois: pessoa1.equals(pessoa2) == true pessoa1.hashCode() != pessoa2.hashCode()
  • Collections • Portanto no nosso modelo dois objetos Pessoa com o mesmo cpf, vai retornar hashCode diferentes (pois esse é o padrão do hashCode) • Isto fere o contrato de hashCode, pois: pessoa1.equals(pessoa2) == true pessoa1.hashCode() != pessoa2.hashCode()
  • Collections Pessoa p1 = new Pessoa("123.456.789-00"); //igual a p2 String text = "São iguais? %b ... hashCodes? %d , %d n"; for (int i = 0; i < 30; i++) { Pessoa p2 = new Pessoa("123.456.789-00"); //igual a p1 System.out.printf( text, p1.equals(p2), p1.hashCode(), p2.hashCode() ); } • O output disso é algo como: – São iguais? true ... hashCodes? 11394033 , 4384790 – São iguais? true ... hashCodes? 11394033 , 24355087 – São iguais? true ... hashCodes? 11394033 , 5442986 – São iguais? true ... hashCodes? 11394033 , 10891203 – São iguais? true ... hashCodes? 11394033 , 9023134 – ....... etc
  • Collections • Portanto para nossa classe Pessoa um hashCode() valido pode ser: public class Pessoa { private String cpf; //... @Override public int hashCode() { return (cpf == null) ? 0 : cpf.hashCode(); } //... }
  • Collections • Portanto para nossa classe Pessoa um hashCode() valido pode ser: public class Pessoa { private String cpf; //... @Override // não é necessário mas é bom public int hashCode() { return (cpf == null) ? 0 : cpf.hashCode(); } //... }
  • Collections • Portanto para nossa classe Pessoa um hashCode() valido pode ser: public class Pessoa { Eu não poderia retornar private String cpf; sempre o mesmo número? Isso não feriria o contrato! //... @Override public int hashCode() { return (cpf == null) ? 0 : cpf.hashCode(); 12; } //... }
  • Collections • Portanto para nossa classe Pessoa um hashCode() valido pode ser: public class Pessoa { Eu não poderia retornar private String cpf; sempre o mesmo número? Isso não feriria o contrato! //... @Override public int hashCode() { SIM! Poderia... return (cpf == null) ? 0 : cpf.hashCode();nem um 12; Porem não é pouco eficiente, como } veremos mais adiante //... quando estudarmos as coleções que usam hash }
  • Collections • Vamos ao que interesssa...
  • Collections • Java Collections Framework (JCF) – Existem duas interfaces principais são elas: • java.util.Collection: uma coleção de objetos • java.util.Map: uma coleção de chave objeto – Toda a estrutura da JCF é baseada e descendem da estrutura destas duas interfaces
  • Collections • Java Collections Framework (JCF) – Existem duas interfaces principais são elas: • java.util.Collection: uma coleção de objetos • java.util.Map: uma coleção de chave objeto – Toda a estrutura da JCF é baseada e descendem da estrutura destas duas interfaces • Então como seria esta estrutura ??
  • Utilitários
  • Collections • E eu preciso saber de tudo isso ????
  • Collections • E eu preciso saber de tudo isso ???? – SIM!!!!
  • Collections • E eu preciso saber de tudo isso ???? – SIM!!!! Para a certificação e para a vida de programador java!
  • Collections • E eu preciso saber de tudo isso ???? – SIM!!!! Para a certificação e para a vida de programador java! • Mas... devagar com andor que o santo é de barro... • Quais são as interfaces mesmo ??
  • Collections • Interfaces da JFC
  • Collections • Interfaces da JFC • Ta bagunçado né ?? Vamos olhar isso direito, começando pela Collection!
  • Collections • A java.util.Collection: – Collection é um contrato de interface que representa uma coleção de objetos – Pode-se dizer que uma coleção é uma versão turbinada de array, com mais funcionalidades e mais segurança.
  • Collections • Métodos java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) boolean retainAll(Collection<?> c) void clear() boolean contains(Object o) boolean containsAll(Collection<?> c) int size() boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator() //método de Iterable
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) boolean retainAll(Collection<?> c) void clear() Opcional boolean contains(Object o) boolean containsAll(Collection<?> c) int size() boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) COMO ASSIM OPCIONAL? boolean remove(Object o) boolean removeAll(Collection<?> c) boolean retainAll(Collection<?> c) void clear() Opcional boolean contains(Object o) boolean containsAll(Collection<?> c) int size() boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) COMO ASSIM OPCIONAL? boolean remove(Object o) boolean removeAll(Collection<?> c) A interface pede o método, como vocês podem ver, boolean retainAll(Collection<?> c) porém na implementação void clear() Opcional pode-se lançar a exceção UnsupportedOperationException boolean contains(Object o) E isso é utilizado em boolean containsAll(Collection<?> c) Implementações somente leitura Implementações boca de lobo int size() ou outros tipos. boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) boolean retainAll(Collection<?> c) void clear() boolean contains(Object o) boolean containsAll(Collection<?> c) int size() Vamos conhecer os métodos! boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Adiciona um elemento a boolean retainAll(Collection<?> c) coleção, onde este elemento void clear() deve ser do mesmo tipo <E> boolean contains(Object o) da coleção, ou de um sub-tipo. boolean containsAll(Collection<?> c) Retorna verdadeiro se houver int size() modificação na coleção, ou boolean isEmpty() seja se o elemento for adicionado. Object[] toArray() <T> T[] toArray(T[] a) Implementação é opcional Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Adiciona uma coleção de boolean retainAll(Collection<?> c) elementos do mesmo tipo <E> void clear() ou uma coleção de sub-tipos boolean contains(Object o) de <E>. boolean containsAll(Collection<?> c) Retorna verdadeiro se pelo int size() menos um elemento for boolean isEmpty() adicionado a coleção, ou seja, se a coleção foi modificada. Object[] toArray() <T> T[] toArray(T[] a) Implementação é opcional Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Remove da coleção a primeira boolean retainAll(Collection<?> c) ocorrência de um objeto void clear() significantemente igual ao boolean contains(Object o) enviado. boolean containsAll(Collection<?> c) Retorna verdadeiro caso o int size() objeto existia na coleção, ou boolean isEmpty() seja, se a coleção foi modificada. Object[] toArray() <T> T[] toArray(T[] a) Implementação é opcional. Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Remove todas da as boolean retainAll(Collection<?> c) ocorrências desta coleção dos void clear() elementos contidos na coleção boolean contains(Object o) c enviada. boolean containsAll(Collection<?> c) Após esta operação nenhum int size() elemento desta coleção boolean isEmpty() retornará true para c.contains() Retorna verdadeiro se pelo Object[] toArray() menos um elemento foi <T> T[] toArray(T[] a) removido, ou seja, se a Iterator<E> iterator() coleção foi modificada. Implementação é opcional.
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Faz o processo inverso de boolean retainAll(Collection<?> c) removeAll. void clear() Retém nesta coleção apénas boolean contains(Object o) os elementos que também boolean containsAll(Collection<?> c) estejam continos na coleção c. int size() Após esta operação todos os boolean isEmpty() elementos desta coleção retornarão true para Object[] toArray() c.contains(). <T> T[] toArray(T[] a) Retorna verdadeiro se a Iterator<E> iterator() coleção for modificada. Implementação é opcional
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Remove todos os elementos boolean retainAll(Collection<?> c) da coleção void clear() boolean contains(Object o) Implementação é opcional. boolean containsAll(Collection<?> c) int size() boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Verifica se existe nesta coleção boolean retainAll(Collection<?> c) um objeto significantemente void clear() igual ao objeto o enviado. boolean contains(Object o) boolean containsAll(Collection<?> c) int size() boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Verifica se todos os objetos da boolean retainAll(Collection<?> c) coleção c enviada, estão void clear() contidos nesta coleção. boolean contains(Object o) Só retorna verdade se boolean containsAll(Collection<?> c) this.contains(elementoDeC) for int size() verdade para cada elemento boolean isEmpty() de c. Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Informa a quantidade de boolean retainAll(Collection<?> c) objetos contidos na coleção. void clear() Obs.: Se a coleção contiver boolean contains(Object o) objetos nulos eles também boolean containsAll(Collection<?> c) serão contabilizados int size() boolean isEmpty() Sim! Existem coleções que aceitam elementos nulos. Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Método de comodidade, o boolean retainAll(Collection<?> c) mesmo que testar se: void clear() size() == 0 boolean contains(Object o) Retorna verdadeiro se não boolean containsAll(Collection<?> c) houver elementos nesta int size() coleção. boolean isEmpty() Object[] toArray() <T> T[] toArray(T[] a) Iterator<E> iterator()
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Retorna uma array contendo boolean retainAll(Collection<?> c) cada um dos elementos desta void clear() coleção, na mesma ordem em boolean contains(Object o) que os elementos aparecem boolean containsAll(Collection<?> c) no iterator(). int size() Não é a array mantida pela boolean isEmpty() lista (caso assim seja implementada) é uma cópia Object[] toArray() dela. <T> T[] toArray(T[] a) Alterações nesta array não são Iterator<E> iterator() refletidas na coleção.
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Retorna todos os elementos da boolean retainAll(Collection<?> c) coleção em uma array do void clear() mesmo tipo da enviada. boolean contains(Object o) if (a.length >= this.size()) { boolean containsAll(Collection<?> c) Então os elementos serão int size() colocados dentro da própria boolean isEmpty() array enviada e os elementos que sobrarem serão setados Object[] toArray() null. <T> T[] toArray(T[] a) } else { Iterator<E> iterator() cria uma nova array do mesmo tipo da enviada e a retorna.
  • Collections • java.util.Collection<E> extends Iterable<E>: boolean add(E e) boolean addAll(Collection<? extends E> c) boolean remove(Object o) boolean removeAll(Collection<?> c) Cria um Iterator que é usado boolean retainAll(Collection<?> c) para navegar sobre os void clear() elementos desta coleção boolean contains(Object o) public interface Iterator<E> { boolean containsAll(Collection<?> c) boolean hasNext(); int size() E next(); boolean isEmpty() void remove(); //opicional } Object[] toArray() * Este método é parte da <T> T[] toArray(T[] a) interface Iterable<E> e toda Iterator<E> iterator() //* classe que a implementa pode ser usada em um for-each
  • Collections • java.util.Collection<E>: – Não há restrição, ordem ou classificação definida no contrato de Collection
  • Collections • java.util.Collection<E>: – Não há restrição, ordem ou classificação definida no contrato de Collection – A coleção de objetos pode conter qualquer tipo de objeto, em qualquer quantidade, sejam eles repetidos ou não, sem qualquer ordem ou classificação definida.
  • Collections • java.util.Collection<E>: – Não há restrição, ordem ou classificação definida no contrato de Collection – A coleção de objetos pode conter qualquer tipo de objeto, em qualquer quantidade, sejam eles repetidos ou não, sem qualquer ordem ou classificação definida. – Esta é a forma mais genérica de agrupar objetos
  • Collections • Tá! e se eu quiser uma coleção sem deixar que os objetos se repitam ??
  • Collections • Tá! e se eu quiser uma coleção sem deixar que os objetos se repitam ?? – Então você quer um java.util.Set uma sub- interface de Collection
  • Collections • java.util.Set<E> extends Collection<E>: – Um Set tem exatamente a mesma interface de Collection, a única mudança é na descrição de seus métodos. – O Set não aceita elementos repetidos – Ao usar add(obj) onde o Set já contem obj, ele simplesmente não o adiciona e retorna false. – A não implementação de equals(Object o) ou a implementação incorreta pode causar efeitos indesejáveis e bug de difícil detectação.
  • Collections • java.util.Set<E> extends Collection<E>: – Um Set tem exatamente a mesma interface de Collection, a única mudança é na descrição de seus métodos. – O Set não aceita elementos repetidos – Ao usar add(obj) onde o Set já contem obj, ele simplesmente não o adiciona e retorna false. – A não implementação de equals(Object o) ou a implementação incorreta pode causar efeitos indesejáveis e bug de difícil detectação.
  • Collections • java.util.Set<E> extends Collection<E>: – Um Set tem exatamente a mesma interface de Collection, a única mudança é na descrição de seus métodos. – O Set não aceita elementos repetidos – Ao usar add(obj) onde o Set já contem obj, ele simplesmente não o adiciona e retorna false. – A não implementação de equals(Object o) ou a implementação incorreta pode causar efeitos indesejáveis e bug de difícil detectação.
  • Collections • java.util.Set<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato de Set – A coleção de objetos pode conter qualquer tipo de objeto, em qualquer quantidade, sem qualquer ordem ou classificação definida, porem nunca objetos repetidos! – Este é o diferencial de um Set para uma Collection, não há objetos significantemente repetidos, isso quer dizer onde equals(other) retorne true para outro elemento dentro do mesmo Set.
  • Collections • java.util.Set<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato de Set – A coleção de objetos pode conter qualquer tipo de objeto, em qualquer quantidade, sem qualquer ordem ou classificação definida, porem nunca objetos repetidos! – Este é o diferencial de um Set para uma Collection, não há objetos significantemente repetidos, isso quer dizer onde equals(other) retorne true para outro elemento dentro do mesmo Set.
  • Collections • java.util.Set<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato de Set – A coleção de objetos pode conter qualquer tipo de objeto, em qualquer quantidade, sem qualquer ordem ou classificação definida, porem nunca objetos repetidos! – Este é o diferencial de um Set para uma Collection, não há objetos significantemente repetidos, isso quer dizer onde equals(other) retorne true para outro elemento dentro do mesmo Set.
  • Collections • É possível também utilizar os conceitos de fila com a Java Collections Framework – Através da interface java.util.Queue<E>
  • Collections • java.util.Queue<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato da fila Queue – Há apenas disponibilizado uma interface de fila, sem especificar quais condições. – As suas implementações que vão definir se a Queue é uma FIFO, FILO ou o quer que seja.
  • Collections • java.util.Queue<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato da fila Queue – Há apenas disponibilizado uma interface de fila, sem especificar quais condições. – As suas implementações que vão definir se a Queue é uma FIFO, FILO ou o quer que seja.
  • Collections • java.util.Queue<E> extends Collection<E>: – Assim como a Collection, não há restrição, ordem ou classificação definida no contrato da fila Queue – Há apenas disponibilizado uma interface de fila, sem especificar quais condições. – As suas implementações que vão definir se a Queue é uma FIFO, FILO ou o quer que seja.
  • Collections • java.util.Queue<E> extends Collection<E>: boolean add(E e) //adciona um elemento a fila se houver capacidade, //lança uma IllegalStateException se não houver. boolean offer(E e) //adciona um elemento a fila se houver capacidade, //retorna false (sem lança exceção) se não houver. E element() //retorna, mas não remove o elemento do topo da fila //lança uma exceção se não houver mais elementos E peek() //retorna, mas não remove o elemento do topo da fila //retorna null se não houver elementos. E remove() //retorna e remove o elemento do topo da fila //lança uma exceção se não houver mais elementos. E poll() //retorna e remove o elemento do topo da fila //retorna null se não houver elementos.
  • Collections • java.util.Queue<E> extends Collection<E>: boolean add(E e) //adiciona um elemento a fila se houver capacidade, // se não houver lança uma IllegalStateException. boolean offer(E e) //adiciona um elemento a fila se houver capacidade, // se não houver retorna false (sem lança exceção). E element() //retorna, mas não remove o elemento do topo da fila //lança uma exceção se não houver mais elementos. E peek() //retorna, mas não remove o elemento do topo da fila //retorna null se não houver elementos. E remove() //retorna e remove o elemento do topo da fila //lança uma exceção se não houver mais elementos. E poll() //retorna e remove o elemento do topo da fila //retorna null se não houver elementos.
  • Collections • java.util.Queue<E> extends Collection<E>: boolean add(E e) //adiciona um elemento a fila se houver capacidade, // se não houver lança uma IllegalStateException. boolean offer(E e) //adiciona um elemento a fila se houver capacidade, // se não houver retorna false (sem lança exceção). E element() //retorna, mas não remove o elemento do topo da fila //não havendo + elementos lança NoSuchElementException. E peek() //retorna, mas não remove o elemento do topo da fila //retorna null se não houver elementos. E remove() //retorna e remove o elemento do topo da fila //lança uma exceção se não houver mais elementos. E poll() //retorna e remove o elemento do topo da fila //retorna null se não houver elementos.
  • Collections • java.util.Queue<E> extends Collection<E>: boolean add(E e) //adiciona um elemento a fila se houver capacidade, // se não houver lança uma IllegalStateException. boolean offer(E e) //adiciona um elemento a fila se houver capacidade, // se não houver retorna false (sem lança exceção). E element() //retorna, mas não remove o elemento do topo da fila //não havendo + elementos lança NoSuchElementException. E peek() //retorna, mas não remove o elemento do topo da fila //retorna null se não houver elementos. E remove() //retorna e remove o elemento do topo da fila //não havendo + elementos lança NoSuchElementException. E poll() //retorna e remove o elemento do topo da fila //retorna null se não houver elementos.
  • Collections • Mas e como eu consigo verificar o elemento 4 que esta dentro de uma Collection, Queue ou Set? só da usando o iterator() ? – Sim infelizmente sim, a única forma de verificar os elementos destas duas interfaces é percorrendo a coleção toda! • Putz! E aquele papo de que era uma array turbinada?? Não tem índice ? – Para tudo na vida tem uma solução, o que você quer é uma java.util.List
  • Collections • Mas e como eu consigo verificar o elemento 4 que esta dentro de uma Collection, Queue ou Set? só da usando o iterator() ? – Sim infelizmente sim, a única forma de verificar os elementos destas interfaces é percorrendo a coleção toda! • Putz! E aquele papo de que era uma array turbinada?? Não tem índice ? – Para tudo na vida tem uma solução, o que você quer é uma java.util.List
  • Collections • Mas e como eu consigo verificar o elemento 4 que esta dentro de uma Collection, Queue ou Set? só da usando o iterator() ? – Sim infelizmente sim, a única forma de verificar os elementos destas interfaces é percorrendo a coleção toda! • Putz! E aquele papo de que era uma array turbinada?? Não tem índice ? cadê o get(3) ? – Para tudo na vida tem uma solução, o que você quer é uma java.util.List
  • Collections • Mas e como eu consigo verificar o elemento 4 que esta dentro de uma Collection, Queue ou Set? só da usando o iterator() ? – Sim infelizmente sim, a única forma de verificar os elementos destas interfaces é percorrendo a coleção toda! • Putz! E aquele papo de que era uma array turbinada?? Não tem índice ? cadê o get(3) ? – Para tudo na vida tem uma solução, o que você quer é uma java.util.List<E>
  • Collections • java.util.List<E> extends Collection<E>: – Uma List é uma coleção ordenada (não classificada), muito parecida com arrays, porem com bem mais funcionalidades e sem limite de tamanho. – Os métodos add() e addAll() da interface Collection adicionam itens ao final da List. – Assim como as Collection todos os métodos de adição e remoção são opcionais e podem lançar UnsupportedOperationException – As mudanças principais em relação a Collection é que tem seus itens ordenado. Os itens da List são ordenados em índice que vão de 0 a (size() -1), conformes veremos a seguir, e usar índice fora desse range gera IndexOutOfBoundsException.
  • Collections • java.util.List<E> extends Collection<E>: – Uma List é uma coleção ordenada (não classificada), muito parecida com arrays, porem com bem mais funcionalidades e sem limite de tamanho. – Os métodos add() e addAll() da interface Collection adicionam itens ao final da List. – Assim como as Collection todos os métodos de adição e remoção são opcionais e podem lançar UnsupportedOperationException – As mudanças principais em relação a Collection é que tem seus itens ordenado. Os itens da List são ordenados em índice que vão de 0 a (size() -1), conformes veremos a seguir, e usar índice fora desse range gera IndexOutOfBoundsException.
  • Collections • java.util.List<E> extends Collection<E>: – Uma List é uma coleção ordenada (não classificada), muito parecida com arrays, porem com bem mais funcionalidades e sem limite de tamanho. – Os métodos add() e addAll() da interface Collection adicionam itens ao final da List. – Assim como as Collection todos os métodos de adição e remoção são opcionais e podem lançar UnsupportedOperationException – As mudanças principais em relação a Collection é que tem seus itens ordenado. Os itens da List são ordenados em índice que vão de 0 a (size() -1), conformes veremos a seguir, e usar índice fora desse range gera IndexOutOfBoundsException.
  • Collections • java.util.List<E> extends Collection<E>: – Uma List é uma coleção ordenada (não classificada), muito parecida com arrays, porem com bem mais funcionalidades e sem limite de tamanho. – Os métodos add() e addAll() da interface Collection adicionam itens ao final da List. – Assim como as Collection todos os métodos de adição e remoção são opcionais e podem lançar UnsupportedOperationException – As mudanças principais em relação a Collection é que tem seus itens ordenado. Os itens da List são ordenados em índice que vão de 0 a (size() -1), conformes veremos a seguir, e usar índice fora desse range gera IndexOutOfBoundsException.
  • Collections • java.util.List<E> extends Collection<E>: – Uma List é uma coleção ordenada (não classificada), muito parecida com arrays, porem com bem mais funcionalidades e sem limite de tamanho. – Os métodos add() e addAll() da interface Collection adicionam itens ao final da List. – Assim como as Collection todos os métodos de adição e remoção são opcionais e podem lançar UnsupportedOperationException – As mudanças principais em relação a Collection é que tem seus itens ordenado. Os itens da List são ordenados em índice que vão de 0 a (size() -1), conformes veremos a seguir, e usar índice fora desse range gera IndexOutOfBoundsException.
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) int lastIndexOf(Object o) ListIterator<E> listIterator() ListIterator<E> listIterator(int i) E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Adiciona o elemento e na posição de índice i. Se houver, o antigo int lastIndexOf(Object o) elemento do índice e seus ListIterator<E> listIterator() posteriores terão seus índices ListIterator<E> listIterator(int i) incrementados E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Adiciona os elemento de c na posição de índice i. Se houver, o int lastIndexOf(Object o) antigo elemento do índice e seus ListIterator<E> listIterator() posteriores terão seus índices ListIterator<E> listIterator(int i) incrementados em c.size() E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Retorna o elemento do índice i int lastIndexOf(Object o) ListIterator<E> listIterator() ListIterator<E> listIterator(int i) E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Retorna o índice do primeiro objeto da list igual ao enviado ou int lastIndexOf(Object o) -1 caso não exista o objeto na ListIterator<E> listIterator() coleção. ListIterator<E> listIterator(int i) E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Retorna o índice do ultimo objeto da list igual ao enviado ou -1 caso int lastIndexOf(Object o) não exista o objeto na coleção. ListIterator<E> listIterator() ListIterator<E> listIterator(int i) E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Retorna um ListIterator desta List. Este objeto é uma extensão do int lastIndexOf(Object o) Iterator, com a diferença que ListIterator<E> listIterator() você pode caminhar p/ frente ou ListIterator<E> listIterator(int i) p/ traz na lista, alem de adicionar E remove(int i) e alterar elementos no índice corrente. E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Retorna um ListIterator desta List. E next() Este objeto é uma extensão do int nextIndex() Iterator, com a diferença que boolean hasPrevious() você pode caminhar p/ frente ou E previous() p/ traz na lista, alem de adicionar int previousIndex() e alterar elementos no índice void add(E e) corrente. void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Verifica se há um próximo E next() elemento na List. int nextIndex() boolean hasPrevious() E previous() int previousIndex() void add(E e) void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Retorna o próximo elemento da E next() List. int nextIndex() boolean hasPrevious() Se não houver o próximo E previous() elemento uma int previousIndex() NoSuchElementException é void add(E e) lançada. void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Retorna o índice do próximo E next() elemento da List. int nextIndex() boolean hasPrevious() Se não houver um próximo E previous() elemento retorna o tamanha da int previousIndex() lista, ou seja, o mesmo que void add(E e) lista.size(). void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Verifica se há um elemento E next() anterior na List. int nextIndex() boolean hasPrevious() E previous() int previousIndex() void add(E e) void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Retorna o elemento anterior da E next() List. int nextIndex() boolean hasPrevious() Se não houver o elemento E previous() anterior uma int previousIndex() NoSuchElementException é void add(E e) lançada. void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Retorna o índice do elemento E next() anterior da List. int nextIndex() boolean hasPrevious() Se não houver um elemento E previous() anterior retorna -1. int previousIndex() void add(E e) void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Adiciona o elemento e a List no E next() índice atual, entre nextIndex() e int nextIndex() previousIndex(). boolean hasPrevious() E previous() int previousIndex() void add(E e) void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Substitui o último elemento E next() retornado por next ou previous. int nextIndex() boolean hasPrevious() Se anteriormente next / previous E previous() não foi chamado ou add / remove int previousIndex() foi invocado será lançada uma void add(E e) IllegalStateException void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: public interface ListIterator<E> extends Iterator<E> { boolean hasNext() Remove o último elemento E next() retornado por next ou previous. int nextIndex() boolean hasPrevious() Se anteriormente next / previous E previous() não foi chamado ou add / remove int previousIndex() foi invocado será lançada uma void add(E e) IllegalStateException void set(E e) void remove() }
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Igual ao método anterior com a diferença que o índice corrente int lastIndexOf(Object o) do ListIterator será o índice ListIterator<E> listIterator() passado. ListIterator<E> listIterator(int i) Obs.: é possível retornar para E remove(int i) antes do índice passado. E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Remove o elemento de índice i da List e o retorna. Importante!!! int lastIndexOf(Object o) Integer indexA = 1; int indexB = 1; ListIterator<E> listIterator() list.remove(indexA) list.remove(indexB) ListIterator<E> listIterator(int i) são operações totalmente diferentes E remove(int i) O 1° remove um objeto Integer == 1 O 2° remove o objeto no índice 1 E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Substitui o objeto no índice index pelo element enviado e retorna o int lastIndexOf(Object o) objeto substituído. ListIterator<E> listIterator() ListIterator<E> listIterator(int i) E remove(int i) E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • java.util.List<E> extends Collection<E>: boolean add(int i, E e) boolean addAll(int i, Collection<? extends E> c) E get(int i) int indexOf(Object o) Retorna o elemento do índice fromIndex (inclusive) até os int lastIndexOf(Object o) elementos de índice toIndex ListIterator<E> listIterator() (exclusive). Mudança na subList são refletidas na List original, o contrario ListIterator<E> listIterator(int i) impossibilita o uso da subList, que, se E remove(int i) usada, lançará ConcurrentModificationException E set(int index, E element) List<E> subList(int fromIndex, int toIndex)
  • Collections • Ok, mas existe alguma forma de criar Coleções classificadas ? – Sim!! • Mas antes de vermos como manter listas classificadas precisamos conhecer duas interfaces Comparator<T> e Comparable<T> • Estas duas interfaces indicam a ordem de classificação dos objetos
  • Collections • Ok, mas existe alguma forma de criar Coleções classificadas ? – Sim!! • Mas antes de vermos como manter listas classificadas precisamos conhecer duas interfaces Comparator<T> e Comparable<T> • Estas duas interfaces indicam a ordem de classificação dos objetos
  • Collections • Ok, mas existe alguma forma de criar Coleções classificadas ? – Sim!! • Mas antes de vermos como manter listas classificadas precisamos conhecer duas interfaces Comparator<T> e Comparable<T> • Estas duas interfaces indicam a ordem de classificação dos objetos
  • Collections • Ok, mas existe alguma forma de criar Coleções classificadas ? – Sim!! • Mas antes de vermos como manter listas classificadas precisamos conhecer duas interfaces Comparator<T> e Comparable<T> • Estas duas interfaces indicam a ordem de classificação dos objetos
  • Collections • Comparable<T> é uma interface que só tem um método: int compareTo(T o) – Retorna negativo, zero, ou positivo quando este objeto é menor que, igual que ou maior que, respectivamente. • Objetos que tem ordem natural implementam esta interface, por exemplo: String texto1 = “dado”, texto2 = “morta”; if (texto1.compareTo(texto2) < 0) { System.out.println(“texto1 vem 1°”); } else if (texto1.compareTo(texto2) > 0) { System.out.println(“texto1 vem 2°”); }
  • Collections • Comparable<T> é uma interface que só tem um método: int compareTo(T o) – Retorna negativo, zero, ou positivo quando este objeto é menor que, igual que ou maior que, respectivamente. • Objetos que tem ordem natural implementam esta interface... por exemplo: String texto1 = “dado”, texto2 = “morta”; if (texto1.compareTo(texto2) < 0) { System.out.println(“texto1 vem 1°”); } else if (texto1.compareTo(texto2) > 0) { System.out.println(“texto1 vem 2°”); }
  • Collections • Comparable<T> é uma interface que só tem um método: int compareTo(T o) – Retorna negativo, zero, ou positivo quando este objeto é menor que, igual que ou maior que, respectivamente. • Objetos que tem ordem natural implementam esta interface... por exemplo: String texto1 = “dado”, texto2 = “morta”; if (texto1.compareTo(texto2) < 0) { System.out.println(“texto1 vem 1°”); } else if (texto1.compareTo(texto2) > 0) { System.out.println(“texto1 vem 2°”); }
  • Collections • Comparable<T> é uma interface que só tem um método: int compareTo(T o) – Retorna negativo, zero, ou positivo quando este objeto é menor que, igual que ou maior que, respectivamente. • Objetos que tem ordem natural implementam esta interface... por exemplo: String texto1 = “dado”, texto2 = “morta”; if (texto1.compareTo(texto2) < 0) { System.out.println(“texto1 vem 1°”); // imprime este } else if (texto1.compareTo(texto2) > 0) { System.out.println(“texto1 vem 2°”); }
  • Collections • Alguma vezes precisamos comparar objetos que não tem ordem natural, ou então comparar objetos por propriedades diferentes da ordem natural • Neste caso utilizamos Comparator<T> int compare(T o1, T o2) • Um comparator funciona como um objeto ordenador, que recebe dois objetos, e compara o primeiro com o segundo (nesta ordem) de acordo com os critérios definidos no comparator.
  • Collections • Alguma vezes precisamos comparar objetos que não tem ordem natural, ou então comparar objetos por propriedades diferentes da ordem natural • Neste caso utilizamos Comparator<T> int compare(T o1, T o2) • Um comparator funciona como um objeto ordenador, que recebe dois objetos, e compara o primeiro com o segundo (nesta ordem) de acordo com os critérios definidos no comparator.
  • Collections • Alguma vezes precisamos comparar objetos que não tem ordem natural, ou então comparar objetos por propriedades diferentes da ordem natural • Neste caso utilizamos Comparator<T> int compare(T o1, T o2) • Um Comparator funciona como um objeto ordenador, que recebe dois objetos, e compara o primeiro com o segundo (nesta ordem) de acordo com os critérios definidos no Comparator.
  • Collections • Agora vamos lá! Vamos conhecer como funciona as classes classificadas java.util.SortedSet<E> extends Set<E> • Esta interface é de uma coleção classificada, onde a classificação do comparator usado por ela, ou a ordem natural é mantida sempre • Não importa a ordem em que os elementos são adicionados a coleção, os itens dentro da coleção serão sempre mantidas na classificação definida por seu comparator ou pela ordem natural.
  • Collections • Agora vamos lá! Vamos conhecer como funciona as classes classificadas java.util.SortedSet<E> extends Set<E> • Esta interface é de uma coleção classificada, onde a classificação do Comparator usado por ela, ou a ordem natural é mantida sempre • Não importa a ordem em que os elementos são adicionados a coleção, os itens dentro da coleção serão sempre mantidas na classificação definida por seu comparator ou pela ordem natural.
  • Collections • Agora vamos lá! Vamos conhecer como funciona as classes classificadas java.util.SortedSet<E> extends Set<E> • Esta interface é de uma coleção classificada, onde a classificação do Comparator usado por ela, ou a ordem natural é mantida sempre • Não importa a ordem em que os elementos são adicionados a coleção, os itens dentro da coleção serão sempre mantidas na classificação definida por seu Comparator ou pela ordem natural.
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement)
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Se a ordem usada na List classificada for a natural retorna null, caso contrario retorna o Comparator que define a ordem usada na classificação. O Comparator é obrigatoriamente do mesmo tipo de E ou de um super tipo de E. Obs.: sendo o Comparator<? super E> seu método compare(E o1, E o2) vai aceitar objetos do tipo E ou de sub-classe, assim mantemos a integridade.
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Retorna o primeiro elemento, de acordo com a classificação desse SortedSet. Não importando a ordem em que os elementos são colocados na coleção, será retornado o primeiro elemento de acordo com a classificação da SortedSet.
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Define o tail – “rabo” – de uma sub SortedSet que inicia em fromElement (inclusive) incluindo todos os elementos maiores que fromElement - A sub coleção criada é um reflexo da coleção principal, e quaisquer operações em uma coleção será refletida na outra, e as duas coleções podem ser alteradas sem problemas. - A sub coleção não pode receber nenhum elemento menor que fromElement, gerando um IllegalArgumentException: key out of range
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Retorna o ultimo elemento, de acordo com a classificação desse SortedSet.
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Define a head – “cabeça” – de uma sub SortedSet que termina em toElement (exclusive) incluindo todos os elementos menores a toElement - A sub coleção criada é um reflexo da coleção principal, e quaisquer operações em uma coleção será refletida na outra, e as duas coleções podem ser alteradas sem problemas.. - A sub coleção não pode receber nenhum elemento maior ou igual que toElement, gerando um IllegalArgumentException: key out of range
  • Collections • java.util.SortedSet<E> extends Set<E>: Comparator<? super E> comparator() E first() SortedSet<E> tailSet(E fromElement) E last() SortedSet<E> headSet(E toElement) SortedSet<E> subSet(E fromElement, E toElement) Cria uma sub SortedSet com os elementos da coleção original iniciando em fromElement (inculsive) e terminando em toElement (exclusive). - A sub coleção criada é um reflexo da coleção principal, e quaisquer operações em uma coleção será refletida na outra, e as duas coleções podem ser alteradas sem problemas. - A nova coleção não pode receber nenhum elemento < fromElement ou >= toElement, gerando um IllegalArgumentException: key out of range
  • Collections • Bem legal, mas e se eu quiser encontrar o primeiro objeto da coleção maior a element, ou um objeto menor a element? Entre outras informações mais detalhas?
  • Collections • Bem legal, mas e se eu quiser encontrar o primeiro objeto da coleção maior a element, ou um objeto menor a element? Entre outras informações mais detalhas? – Nesse caso você precisa de uma java.util.NavigableSet<E> extends SortedSet<E>
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) E floor(E e) E higher(E e) E ceiling(E e) E pollFirst() E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) E higher(E e) E ceiling(E e) E pollFirst() E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) E ceiling(E e) E pollFirst() E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) E pollFirst() E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() //remove e retorna o primeiro elemento ou null E pollLast() Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() //remove e retorna o primeiro elemento ou null E pollLast() //remove e retorna o ultimo elemento ou null Iterator<E> descendingIterator() NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() //remove e retorna o primeiro elemento ou null E pollLast() //remove e retorna o ultimo elemento ou null Iterator<E> descendingIterator() //Iterator na ordem inversa NavigableSet<E> descendingSet() NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() //remove e retorna o primeiro elemento ou null E pollLast() //remove e retorna o ultimo elemento ou null Iterator<E> descendingIterator() //Iterator na ordem inversa NavigableSet<E> descendingSet() //NavigableSet inverso NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • java.util.NavigableSet<E> extends SortedSet<E>: E lower(E e) //primeiro elemento menor a e E floor(E e) //primeiro elemento menor ou igual a e E higher(E e) //primeiro elemento maior a e E ceiling(E e) //primeiro elemento maior ou igual a e E pollFirst() Igual aos métodos da //remove e retorna o primeiro elemento ou null classe SortedSet porém E pollLast() //remove e retorna o ultimo elemento pode escolher aqui você ou null Iterator<E> descendingIterator() se o elemento enviado é //Iterator na ordem inversa inclusive ou exclusive. NavigableSet<E> descendingSet() //NavigableSet inverso NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> tailSet(E fromElement, boolean inclusive) NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
  • Collections • Existem mais interfaces de Collection ? – Que descendam de Collection? nenhuma que vá cair na prova! Mas é bastante vasta a Java Collection Framework
  • Collections • Existem mais interfaces de Collection ? – Que descendam de Collection? nenhuma que vá cair na prova! Mas é bastante vasta a Java Collection Framework • Sobre interfaces só falta Map<E> e suas sub-interfaces, mas este nós só vamos ver depois das classes Concretas de Collection.
  • Collections • Existem mais interfaces de Collection ? – Que descendam de Collection? nenhuma que vá cair na prova! Mas é bastante vasta a Java Collection Framework • Sobre interfaces só falta Map<E> e suas sub-interfaces, mas este nós só vamos ver depois das classes Concretas de Collection. • Então vamos as classes concretas
  • <<Interface>> Collection<E> Collections <<Interface>> List<E> Vector<E> ArrayList<E> • Para o exame você só precisa saber que as duas classes tem a mesma implementação, exceto pela sincronização: – Vector: tem todos os seus métodos sincronizados – ArrayList: NÃO tem os métodos sincronizados. • Só ter os métodos sincronizados não garante a classe que ela é Thread safe, por isso muito cuidado com as perguntas da prova, e é aconselhável o uso de ArrayList pois Vector é mais lenta devido a sync
  • <<Interface>> Collection<E> Collections <<Interface>> <<Interface>> List<E> Queue<E> • LinkedList<E> PriorityQueue<E> • LinkedList: Implementa List e Queue, portanto tem todas funcionalidades de List além da Fila, onde o modelo de fila implementado é FIFO (firs-in-first-out). • PriorityQueue: Essa é uma das poucas que apenas a implementação não da todas as pistas, PriorityQueue é uma fila classificada, ou seja, respeita a classificação natural dos elementos ou de um Comparator. – priorityQueue.poll() retorna sempre o menor elemento (de acordo com o Comparator da fila ou a ordem natural). – A PriorityQueue aceita valores duplicados – Não usar Comparator com objetos não classificáveis gera exceção ao tentar adicionar elementos.
  • <<Interface>> Collection<E> Collections <<Interface>> Set<E> • TreeSet: uma das classes mais interessante e que mais cai na prova: <<Interface>> – É uma coleção de elementos únicos em SortedSet<E> relação a classificação definida. – Deve-se usar Comparator, quando não se quer usar, ou não existe, uma classificação natural. <<Interface>> NavigableSet<E> – Usar a classe sem Comparator com um objeto sem classificação natural gera exceção ao adicionar o elemento. TreeSet<E> – Se a comparação retornar igual para dois elementos, e eles não forem iguais, o TreeSet não deixará incluir os dois elementos, será considerado para o Set como elementos duplicados, o que não é permitido, e false será retornado. – Estudem os métodos subSet, tailSet, headSet
  • Collections • Bom chegou a hora, vamos para as classes hash, e portanto precisamos explicar pra que serve o código hash e como as classes se comportam. • Antes de verificar o comportamento de uma coleção hash, precisamos ver como as demais se comportam. – Sempre que você da um contains(Object o), a coleção começa a verificar seus objetos testando uma a um se o.equals(next) ate encontrar o objeto, retornando se encontrou ou não. – Quando o método usado é remove(Object o), o processo é o mesmo a coleção testa equals um a um ate encontrar um objeto igual e o remove. – Se a coleção for um Set, a cada add(Object o), antes de adicionar a coleção verifica se contains(Object o), daí você começa a entender o problema e as implicações de ficar percorrendo a coleção tantas vezes testando tantos equals.
  • Collections • Para resolver esse problema de performance que vai se acumulando as coleções hash se usam de outro conceito para fazer busca de seus elementos. • Primeiro vamos revisar duas das propriedades do hashCode:
  • Collections • Para resolver esse problema de performance que vai se acumulando as coleções hash se usam de outro conceito para fazer busca de seus elementos. • Primeiro vamos revisar duas das propriedades do hashCode:
  • Collections • Para resolver esse problema de performance que vai se acumulando as coleções hash se usam de outro conceito para fazer busca de seus elementos. • Primeiro vamos revisar duas das propriedades do hashCode: – Se dois objetos a e b forem iguais e a.equals(b) for true então a.hashCode() == b.hashCode() – O inverso não é verdadeiro, quando a.equals(b) for false os hashCode() podem ser iguais ou diferentes.
  • Collections • Para resolver esse problema de performance que vai se acumulando as coleções hash se usam de outro conceito para fazer busca de seus elementos. • Primeiro vamos revisar duas das propriedades do hashCode: – Se dois objetos a e b forem iguais e a.equals(b) for true então a.hashCode() == b.hashCode() – O inverso não é verdadeiro, quando a.equals(b) for false os hashCode() podem ser iguais ou diferentes. • As coleções hash se utilizam desses dois conceitos para otimizar a pesquisa a seus elementos.
  • Collections • Quando você adiciona um elemento a uma coleção hash ela verifica o hashCode do objeto, e o coloca em um recipiente onde só há objetos com o mesmo hashCode, se o recipiente para aquele hashCode ainda não existia ela cria um novo. – Assim é mantido o processo sempre que se adiciona um objeto. • Quando você, por exemplo, precisa verificar se um objeto existe, as coleções hash tem muito menos trabalho para procurar: – primeiro elas verificam o código hash do objeto, e olha no recipiente daquele código – E então verifica um a um, apenas nesse recipiente, através de equals() para ver se há algum objeto que coiencidente.
  • Collections • Quando você adiciona um elemento a uma coleção hash ela verifica o hashCode do objeto, e o coloca em um recipiente onde só há objetos com o mesmo hashCode, se o recipiente para aquele hashCode ainda não existia ela cria um novo. – Assim é mantido o processo sempre que se adiciona um objeto. • Quando você, por exemplo, precisa verificar se um objeto existe, as coleções hash tem muito menos trabalho para procurar: – primeiro elas verificam o código hash do objeto, e olha no recipiente daquele código – E então verifica um a um, apenas nesse recipiente, através de equals() para ver se há algum objeto que coiencidente.
  • Collections • Quando você adiciona um elemento a uma coleção hash ela verifica o hashCode do objeto, e o coloca em um recipiente onde só há objetos com o mesmo hashCode, se o recipiente para aquele hashCode ainda não existia ela cria um novo. – Assim é mantido o processo sempre que se adiciona um objeto. • Quando você, por exemplo, precisa verificar se um objeto existe, as coleções hash tem muito menos trabalho para procurar: – primeiro elas verificam o código hash do objeto, e olha no recipiente daquele código – E então verifica um a um, apenas nesse recipiente, através de equals() para ver se há algum objeto que coincidente.
  • Collections • Portanto a performance e o funcionamento de uma coleção hash esta intimamente ligada ao quão bem implementado é um código hash. • Para um melhor entendimento vamos criar uma classe Aluno: public class Aluno { private String nome; public Aluno(String nome) { this.nome = nome;} public String getNome() { return this.nome;} @Override public boolean equals(Object o) { if (nome == null) return false; return (o instanceof Aluno) && nome.equals(((Aluno)o).nome); } @Override public int hashCode() { //hashCode vem da 1° letra do nome return (nome == null) ? 0 : nome.charAt(0); } }
  • Collections • Portanto a performance e o funcionamento de uma coleção hash esta intimamente ligada ao quão bem implementado é um código hash. • Para um melhor entendimento vamos criar uma classe Aluno: public class Aluno { private String nome; public Aluno(String nome) { this.nome = nome;} public String getNome() { return this.nome;} @Override public boolean equals(Object o) { if (nome == null) return false; return (o instanceof Aluno) && nome.equals(((Aluno)o).nome); } @Override public int hashCode() { //hashCode vem da 1° letra do nome return (nome == null) ? 0 : nome.charAt(0); } }
  • Collections • Portanto a performance e o funcionamento de uma coleção hash esta intimamente ligada ao quão bem implementado é um código hash. • Para um melhor entendimento vamos criar uma classe Aluno: public class Aluno { private String nome; public Aluno(String nome) { this.nome = nome;} public String getNome() { return this.nome;} @Override public boolean equals(Object o) { if (nome == null) return false; return (o instanceof Aluno) && nome.equals(((Aluno)o).nome); } @Override public int hashCode() { //hashCode vem da 1° letra do nome return (nome == null) ? 0 : nome.charAt(0); } }
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>();
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>(); alunos.add(new Aluno(“Marcos”)); 77 alunos.add(new Aluno(“Matheus”)); alunos.add(new Aluno(“Magno”));
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>(); alunos.add(new Aluno(“Marcos”)); 77 alunos.add(new Aluno(“Matheus”)); alunos.add(new Aluno(“Magno”));
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>(); alunos.add(new Aluno(“Marcos”)); 77 alunos.add(new Aluno(“Matheus”)); alunos.add(new Aluno(“Magno”)); alunos.add(new Aluno(“Antonio”)); 66 alunos.add(new Aluno(“Ana”));
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>(); alunos.add(new Aluno(“Marcos”)); 77 alunos.add(new Aluno(“Matheus”)); alunos.add(new Aluno(“Magno”)); alunos.add(new Aluno(“Antonio”)); 66 alunos.add(new Aluno(“Ana”)); alunos.add(new Aluno(“João”)); 74
  • Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>(); alunos.add(new Aluno(“Marcos”)); 77 alunos.add(new Aluno(“Matheus”)); alunos.add(new Aluno(“Magno”)); alunos.add(new Aluno(“Antonio”)); alunos.add(new Aluno(“Ana”)); 66 alunos.add(new Aluno(“João”)); Como então funciona um: 74 alunos.add(new Aluno(“Abel”)) ? 1. A coleção busca “Abel”.hashCode() == 66 2. A coleção busca o conteiner 66 3. Então verifica todos os elementos testando: “Antonio”.equals(“Abel”); “Ana”.equals(“Abel”); o que retorna false,portanto “Abel” é adicionado
  • Collections • Quanto melhor implementado é o hashCode() mais rápida se torna a busca dentro da coleção hash, por exemplo, se mudarmos nossa implementação de hashCode() para: public class Aluno { //... @Override public int hashCode() { //hashCode vem da 1° letra do nome return (nome == null) ? 0 : nome.charAt(0) + nome.size(); } }
  • Collections HashSet • Como seria a nova divisão ?? 7*77 539 alunos.add(new Aluno(“Matheus”)); 5*77 385 alunos.add(new Aluno(“Magno”)); 6*77 alunos.add(new Aluno(“Marcos”)); alunos.add(new Aluno(“Antonio”)); 7*66 462 alunos.add(new Aluno(“Ana”)); alunos.add(new Aluno(“João”)); 3*66 198 4*74 Como então funciona um: 296 alunos.add(new Aluno(“Abel”)) ? 1. A coleção busca “Abel”.hashCode() == 264 2. A coleção verifica que não há o conteiner 264 3. Adicionando “Abel” a um novo conteiner.
  • Collections • Como coleções não hash realizam a mesma busca? Aluno jo = new Aluno(“Jô”); alunos.contains(jo); //A coleção alunos iria testar equals contra cada objeto: “Matheus”.equals(jo); //false “Magno”.equals(jo); //false “Marcos”.equals(jo); //false “Antonio”.equals(jo); //false “Ana”.equals(jo); //false “João”.equals(jo); //false return false; • E essa é diferença de performance de uma coleção hash para uma normal.
  • Collections • Como coleções não hash realizam a mesma busca? Aluno abel = new Aluno(“Abel”); alunos.contains(abel); //A coleção alunos iria testar equals contra cada objeto: “Matheus”.equals(abel); //false “Magno”.equals(abel); //false “Marcos”.equals(abel); //false “Antonio”.equals(abel); //false “Ana”.equals(abel); //false “João”.equals(abel); //false return false; • E essa é diferença de performance de uma coleção hash para uma normal.
  • <<Interface>> Collection<E> Collections <<Interface>> Set<E> • HashSet: uma das classes mais utilizadas (e que pode gerar grandes problemas quando hashCode HashSet<E> não é bem implementado): – É uma coleção de elementos únicos não ordenada e não classificada. – A cada inserção a ordem dos elementos gerados pelo LinkedHashSet<E> iterator pode alterar totalmente. – As buscas são realizadas usando tabelas hash. • LinkedHashSet: A mudança básica para o HashSet é que a LinkedHashSet mantém armazenada a ordem de inserção. – A cada inserção a ordem dos elementos gerados pelo iterator NÃO é alterada. – É mantida a ordem de inserção. – As buscas são realizadas usando tabelas hash.
  • Collections • Finalmente vamos conhecer o funcionamento dos java.util.Map<K,V> • Um Map é uma coleção de pares key-value (chave-valor), porem esta não descende de Collection<E> tendo uma interface nova. • Por exemplo: – Em um Map<String,Thread> podemos guardar instancias de Thread que são identificadas por Strings, onde é possivel gerenciar facilmente as instancias através de suas chaves. • Vamos conhecer sua interface
  • Collections • Finalmente vamos conhecer o funcionamento dos java.util.Map<K,V> • Um Map é uma coleção de pares key-value (chave-valor), porem esta não descende de Collection<E> tendo uma interface nova. • Por exemplo: – Em um Map<String,Thread> podemos guardar instancias de Thread que são identificadas por Strings, onde é possivel gerenciar facilmente as instancias através de suas chaves. • Vamos conhecer sua interface
  • Collections • Finalmente vamos conhecer o funcionamento dos java.util.Map<K,V> • Um Map é uma coleção de pares key-value (chave-valor), porem esta não descende de Collection<E> tendo uma interface nova. • Por exemplo: – Em um Map<String,Thread> podemos guardar instancias de Thread que são identificadas por Strings, onde é possível gerenciar facilmente as instancias através de suas chaves. • Vamos conhecer sua interface
  • Collections • Finalmente vamos conhecer o funcionamento dos java.util.Map<K,V> • Um Map é uma coleção de pares key-value (chave-valor), porem esta não descende de Collection<E> tendo uma interface nova. • Por exemplo: – Em um Map<String,Thread> podemos guardar instancias de Thread que são identificadas por Strings, onde é possível gerenciar facilmente as instancias através de suas chaves. • Vamos conhecer sua interface
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() V get(Object key) boolean containsKey(Object o) boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Insere o valor passado na V get(Object key) chave indicada, e retorna o boolean containsKey(Object o) antigo valor da chave, ou null boolean containsValue(Object o) caso não exista valor anterior. Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Implementação é opcional. Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Copia todos os valores do V get(Object key) mapa enviando m, para este boolean containsKey(Object o) mapa, nas suas respectivas boolean containsValue(Object o) chaves. Set<Map.Entry<K, V>> entrySet() É o mesmo que iterar o Set<K> keySet() entrySet() e adicionar as Collection<V> values() entradas uma a uma. int size() boolean isEmpty() Implementação é opcional.
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Remove, se estiver presente, V get(Object key) o mapeamento de chave boolean containsKey(Object o) enviada, retornando o valor da boolean containsValue(Object o) chave que estava mapeado. Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Implementação é opcional. Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Remove todos as chaves e V get(Object key) valores mapeados. boolean containsKey(Object o) boolean containsValue(Object o) Implementação é opcional. Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Recupera o valor para a chave V get(Object key) enviada. boolean containsKey(Object o) boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Verifica se este mapa contém V get(Object key) uma chave significantemente boolean containsKey(Object o) igual ao objeto enviado. boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Verifica se este mapa contém V get(Object key) uma valor significantemente boolean containsKey(Object o) igual ao objeto enviado. boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Recupera a coleção Set das V get(Object key) Entry deste mapa. boolean containsKey(Object o) Entry são Entradas do mapa é boolean containsValue(Object o) um objeto que guarda o par Set<Map.Entry<K, V>> entrySet() key-value. Set<K> keySet() Veremos na pagina seguinte Collection<V> values() como funciona essa interface int size() Entry. boolean isEmpty() Alterações nesse Set são refletidas no Map e vice-versa, muito cuidado ao manipular.
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Recupera um Set contendo V get(Object key) todas as chaves do Map. boolean containsKey(Object o) boolean containsValue(Object o) Alterações nesse Set são Set<Map.Entry<K, V>> entrySet() refletidas no Map e vice-versa, Set<K> keySet() muito cuidado ao manipular. Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Recupera uma Collection V get(Object key) contendo todos os valores boolean containsKey(Object o) deste Map. boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Alterações nesse Set são Set<K> keySet() refletidas no Map e vice-versa, Collection<V> values() muito cuidado ao manipular. int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Informa a quantidade de pares V get(Object key) key-value existentes neste boolean containsKey(Object o) mapa. boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map<K,V>: V put(K key, V value) void putAll(Map<? extends K,? extends V> m) V remove(Object key) void clear() Verifica se o Map é vazio V get(Object key) Método de comodidade, o boolean containsKey(Object o) mesmo que (size() == 0) boolean containsValue(Object o) Set<Map.Entry<K, V>> entrySet() Set<K> keySet() Collection<V> values() int size() boolean isEmpty()
  • Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() V getValue() V setValue(V value)
  • Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() //recupera a chave desta entrada V getValue() V setValue(V value)
  • Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() //recupera a chave desta entrada V getValue() //recupera o valor desta entrada V setValue(V value)
  • Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() //recupera a chave desta entrada V getValue() //recupera o valor desta entrada V setValue(V value) //altera o valor para esta chave
  • Collections • A uma interface em maps que também é classificada java.util.SortedMap<K,V>: – Esta interface tem exatamente o mesmo funcionamento da Coleção SortedSet, porém se aplica a parte de Keys do Map
  • Collections • Métodos de java.util.SortedMap<K,V>: Comparator<? super K> comparator() K firstKey() SortedMap<K,V> tailMap(K fromKey) K lastKey() SortedMap<K,V> headMap(K toKey) SortedMap<K,V> subMap(K fromKey, K toKey)
  • Collections • Métodos de java.util.SortedMap<K,V>: Comparator<? super K> comparator() K firstKey() Funciona igual SortedMap<K,V> tailMap(K fromKey) SortedSet para o Set de keys do Map K lastKey() SortedMap<K,V> headMap(K toKey) SortedMap<K,V> subMap(K fromKey, K toKey)
  • Collections • Também existe a interface semelhante a NavigableSet com mais funcionalidades java.util.NavigableMap<K,V>: – Esta interface tem exatamente o mesmo funcionamento da Coleção NavigableSet, porém se aplica a parte de keys do Map
  • Collections • Métodos de java.util.NavigableMap<K,V>: K lowerKey(K key) Entry<K,V> lowerEntry(E key) K floorKey(K e) Entry<K,V> floorEntry(E key) Funciona igual E higherKey(K key) NavigableSet para o Entry<K,V> higherEntry(K key) Set de keys do Map E ceilingKey(K key) Entry<K,V> ceilingEntry(K key) Entry<K,V> pollFirstEntry() Entry<K,V> pollLastEntry() NavigableSet<K> descendingKeySet() NavigableMap<K,V> descendingMap() NavigableMap<K,V> headMap(K toElement, boolean inclusive) NavigableMap<K,V> tailMap(K fromElement, boolean inclusive) NavigableMap<K,V> subMap(K from, boolean inc, K to, boolean inc)
  • Collections • As classes concretas de Map que cai no exame são também muito semelhantes a classes concretas Collection que já estudamos: – Examinamos agora as classes concretas.
  • Collections
  • Collections
  • Collections Hashtable e HashMap Semelhanças: Não ordenadas, não classificadas, baseiam suas buscas em tabelas rash. Diferenças: Hashtable tem todos os seus métodos sincronizados enquanto HashMap não! é aconselhável o uso do HashMap
  • Collections LinkedHashMap Semelhanças: não classificadas, baseiam suas buscas em tabelas rash. Diferenças: A ordem de inserção é levada em conta, e a iteração de seus entrySet(), keySet() ou values() obedecem a ordem de inserção. Obs.: não é sincronizada.
  • Collections TreeMap É um Map classificado onde a ordem dos seus elementos segue a ordem de seu Comparator (se houver) ou a natural de seus elementos. Funciona semelhante a TreeSet.
  • Collections • Vários métodos utilitários podem ser encontrados na classe java.util.Collections, sim Collections com “s” no fim. • Esta classe esta munida das principais operações que você precisará realizar com Coleções, e todos os seus métodos são estáticos. • Sua documentação pode ser encontrada neste link: – http://java.sun.com/javase/6/docs/api/java/util/Collecti ons.html
  • Collections • Vários métodos utilitários podem ser encontrados na classe java.util.Collections, sim Collections com “s” no fim. • Esta classe esta munida das principais operações que você precisará realizar com Coleções, e todos os seus métodos são estáticos. • Sua documentação pode ser encontrada neste link: – http://java.sun.com/javase/6/docs/api/java/util/Collecti ons.html
  • Collections • Vários métodos utilitários podem ser encontrados na classe java.util.Collections, sim Collections com “s” no fim. • Esta classe esta munida das principais operações que você precisará realizar com Coleções, e todos os seus métodos são estáticos. • Sua documentação pode ser encontrada neste link: – http://java.sun.com/javase/6/docs/api/java/util/Collecti ons.html
  • Collections • Existe mais alguma interface ou classe concreta? Da Java Collections Framework ?? – SIM, existe! Mas essas são todas que são usadas no exame. • Onde eu posso encontrar mais informações ? – GUJ: http://www.guj.com.br/ – Sergio Taborda’s Weblog: http://sergiotaborda.wordpress.com/java/colecoes-em-java/ – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/ – Tutorial da sun: http://java.sun.com/docs/books/tutorial/collections/index.html – API Specification: http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc e.html – The Java Collection Framework Documentations Contents: http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht ml
  • Collections • Existe mais alguma interface ou classe concreta? Da Java Collections Framework ?? – SIM, existe! Mas essas são todas que são usadas no exame. • Onde eu posso encontrar mais informações ? – GUJ: http://www.guj.com.br/ – Sergio Taborda’s Weblog: http://sergiotaborda.wordpress.com/java/colecoes-em-java/ – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/ – Tutorial da sun: http://java.sun.com/docs/books/tutorial/collections/index.html – API Specification: http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc e.html – The Java Collection Framework Documentations Contents: http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht ml
  • Collections • Existe mais alguma interface ou classe concreta? Da Java Collections Framework ?? – SIM, existe! Mas essas são todas que são usadas no exame. • Onde eu posso encontrar mais informações ? – GUJ: http://www.guj.com.br/ – Sergio Taborda’s Weblog: http://sergiotaborda.wordpress.com/java/colecoes-em-java/ – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/ – Tutorial da sun: http://java.sun.com/docs/books/tutorial/collections/index.html – API Specification: http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc e.html – The Java Collection Framework Documentations Contents: http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht ml
  • Collections • Existe mais alguma interface ou classe concreta? Da Java Collections Framework ?? – SIM, existe! Mas essas são todas que são usadas no exame. • Onde eu posso encontrar mais informações ? – GUJ: http://www.guj.com.br/ – Sergio Taborda’s Weblog: http://sergiotaborda.wordpress.com/java/colecoes-em-java/ – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/ – Tutorial da sun: http://java.sun.com/docs/books/tutorial/collections/index.html – API Specification: http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc e.html – The Java Collection Framework Documentations Contents: http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht ml
  • Collections • Referencias Bibliográficas: – API Java 6: http://java.sun.com/javase/6/docs/technotes/g uides/collections/reference.html – Livro: Certificação Sun® Para Programador Java 6 – Guia de Estudos – 2° Edição