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

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
8,897
On Slideshare
8,861
From Embeds
36
Number of Embeds
4

Actions

Shares
Downloads
275
Comments
1
Likes
6

Embeds 36

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

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Java Collections – Conceitos Básicos Collections Tomaz Lavieri Sun Certified Java Programmer 6 tomazlavieri@gmail.com http://java-i9se.blogspot.com.br
  • 2. 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.
  • 3. 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.
  • 4. 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.
  • 5. 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.
  • 6. 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.
  • 7. 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?
  • 8. 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?
  • 9. 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?
  • 10. 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?
  • 11. 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?
  • 12. 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?
  • 13. 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.
  • 14. 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.
  • 15. 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.
  • 16. 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.
  • 17. 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.
  • 18. 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.
  • 19. Collections • Pré-requisitos:
  • 20. Collections • Pré-requisitos: – Igualdade: Para se trabalhar com coleções é preciso entender a igualdade em Java
  • 21. Collections • Pré-requisitos: – Igualdade: Para se trabalhar com coleções é preciso entender a igualdade em Java • Porque é preciso?
  • 22. 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.
  • 23. Collections • Como funciona igualdade em Java ? pessoa1 == pessoa2
  • 24. Collections • Como funciona igualdade em Java ? pessoa1 == pessoa2 • Isso irá testar apenas se as duas variáveis referenciam uma única instancia!
  • 25. Collections • Como então saber, por exemplo, quando dois objetos Pessoa são significantemente iguais?
  • 26. 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)
  • 27. 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)
  • 28. Collections • Só isso resolve?
  • 29. Collections • Só isso resolve? – Não
  • 30. Collections • Só isso resolve? – Não • Por padrão o método equals de Object faz o mesmo que o operador ==
  • 31. 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); } //…
  • 32. Collections • Então se queremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais?
  • 33. 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
  • 34. 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??
  • 35. 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
  • 36. Collections • Mas não basta simplesmente sobrescrever!
  • 37. 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
  • 38. 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
  • 39. 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
  • 40. 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
  • 41. 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
  • 42. 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
  • 43. 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); } //... }
  • 44. 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); } //... }
  • 45. 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); } //... }
  • 46. 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
  • 47. 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?
  • 48. 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
  • 49. 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()
  • 50. Collections • E pra que serve esse hashCode() ?
  • 51. 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
  • 52. 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 ??
  • 53. 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()
  • 54. 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()
  • 55. 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()
  • 56. 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()
  • 57. 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()
  • 58. 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(); //… }
  • 59. 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(); //… }
  • 60. 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()
  • 61. 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()
  • 62. 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
  • 63. 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(); } //... }
  • 64. 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(); } //... }
  • 65. 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; } //... }
  • 66. 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 }
  • 67. Collections • Vamos ao que interesssa...
  • 68. 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
  • 69. 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 ??
  • 70. Utilitários
  • 71. Collections • E eu preciso saber de tudo isso ????
  • 72. Collections • E eu preciso saber de tudo isso ???? – SIM!!!!
  • 73. Collections • E eu preciso saber de tudo isso ???? – SIM!!!! Para a certificação e para a vida de programador java!
  • 74. 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 ??
  • 75. Collections • Interfaces da JFC
  • 76. Collections • Interfaces da JFC • Ta bagunçado né ?? Vamos olhar isso direito, começando pela Collection!
  • 77. 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.
  • 78. 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
  • 79. 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()
  • 80. 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()
  • 81. 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()
  • 82. 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()
  • 83. 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()
  • 84. 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()
  • 85. 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()
  • 86. 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.
  • 87. 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
  • 88. 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()
  • 89. 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()
  • 90. 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()
  • 91. 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()
  • 92. 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()
  • 93. 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.
  • 94. 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.
  • 95. 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
  • 96. Collections • java.util.Collection<E>: – Não há restrição, ordem ou classificação definida no contrato de Collection
  • 97. 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.
  • 98. 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
  • 99. Collections • Tá! e se eu quiser uma coleção sem deixar que os objetos se repitam ??
  • 100. 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
  • 101. 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.
  • 102. 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.
  • 103. 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.
  • 104. 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.
  • 105. 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.
  • 106. 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.
  • 107. Collections • É possível também utilizar os conceitos de fila com a Java Collections Framework – Através da interface java.util.Queue<E>
  • 108. 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.
  • 109. 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.
  • 110. 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.
  • 111. 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.
  • 112. 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.
  • 113. 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.
  • 114. 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.
  • 115. 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
  • 116. 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
  • 117. 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
  • 118. 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>
  • 119. 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.
  • 120. 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.
  • 121. 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.
  • 122. 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.
  • 123. 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.
  • 124. 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)
  • 125. 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)
  • 126. 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)
  • 127. 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)
  • 128. 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)
  • 129. 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)
  • 130. 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)
  • 131. 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() }
  • 132. 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() }
  • 133. 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() }
  • 134. 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() }
  • 135. 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() }
  • 136. 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() }
  • 137. 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() }
  • 138. 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() }
  • 139. 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() }
  • 140. 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() }
  • 141. 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)
  • 142. 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)
  • 143. 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)
  • 144. 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)
  • 145. 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
  • 146. 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
  • 147. 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
  • 148. 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
  • 149. 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°”); }
  • 150. 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°”); }
  • 151. 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°”); }
  • 152. 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°”); }
  • 153. 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.
  • 154. 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.
  • 155. 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.
  • 156. 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.
  • 157. 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.
  • 158. 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.
  • 159. 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)
  • 160. 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.
  • 161. 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.
  • 162. 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
  • 163. 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.
  • 164. 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
  • 165. 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
  • 166. 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?
  • 167. 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>
  • 168. 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)
  • 169. 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)
  • 170. 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)
  • 171. 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)
  • 172. 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)
  • 173. 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)
  • 174. 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)
  • 175. 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)
  • 176. 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)
  • 177. 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)
  • 178. Collections • Existem mais interfaces de Collection ? – Que descendam de Collection? nenhuma que vá cair na prova! Mas é bastante vasta a Java Collection Framework
  • 179. 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.
  • 180. 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
  • 181. <<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
  • 182. <<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.
  • 183. <<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
  • 184. 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.
  • 185. 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:
  • 186. 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:
  • 187. 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.
  • 188. 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.
  • 189. 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.
  • 190. 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.
  • 191. 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.
  • 192. 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); } }
  • 193. 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); } }
  • 194. 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); } }
  • 195. Collections • Como é a divisão em uma coleção Hash? HashSet Set<Aluno> alunos = new HashSet<Aluno>();
  • 196. 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”));
  • 197. 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”));
  • 198. 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”));
  • 199. 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
  • 200. 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
  • 201. 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(); } }
  • 202. 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.
  • 203. 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.
  • 204. 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.
  • 205. <<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.
  • 206. 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
  • 207. 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
  • 208. 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
  • 209. 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
  • 210. 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()
  • 211. 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()
  • 212. 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.
  • 213. 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()
  • 214. 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()
  • 215. 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()
  • 216. 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()
  • 217. 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()
  • 218. 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.
  • 219. 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()
  • 220. 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()
  • 221. 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()
  • 222. 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()
  • 223. Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() V getValue() V setValue(V value)
  • 224. Collections • Métodos de java.util.Map.Entry<K,V>: K getKey() //recupera a chave desta entrada V getValue() V setValue(V value)
  • 225. 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)
  • 226. 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
  • 227. 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
  • 228. 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)
  • 229. 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)
  • 230. 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
  • 231. 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)
  • 232. 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.
  • 233. Collections
  • 234. Collections
  • 235. 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
  • 236. 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.
  • 237. 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.
  • 238. 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
  • 239. 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
  • 240. 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
  • 241. 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
  • 242. 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
  • 243. 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
  • 244. 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
  • 245. 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