Java Collections – Conceitos Básicos




                                   Collections



Tomaz Lavieri
Sun Certified Java Programmer 6
tomazlavieri@gmail.com
http://java-i9se.blogspot.com.br
Collections
Objetivos:
• Ao final desta apresentação espera-se que você
  saiba:
  – Distinguir cada tipo de Coleção.
  – Escolher a melhor implementação de Coleção para
    cada tipo de uso.
  – Saber a diferença entre as Interfaces: Collection, Set,
    Queue, List, SortedSet, NavigableSet, Map,
    SortedMap e NavigableMap.
  – Conhecer as implementações básicas: ArrayList,
    Vector, LinkedList, PriorityQueue, TreeSet, HashSet,
    LinkedHashSet, TreeMap, HashMap e
    LinkedHashMap.
Collections
Objetivos:
• Ao final desta apresentação espera-se que você
  saiba:
  – Distinguir cada tipo de Coleção.
  – Escolher a melhor implementação de Coleção para
    cada tipo de uso.
  – Saber a diferença entre as Interfaces: Collection, Set,
    Queue, List, SortedSet, NavigableSet, Map,
    SortedMap e NavigableMap.
  – Conhecer as implementações básicas: ArrayList,
    Vector, LinkedList, PriorityQueue, TreeSet, HashSet,
    LinkedHashSet, TreeMap, HashMap e
    LinkedHashMap.
Collections
Objetivos:
• Ao final desta apresentação espera-se que você
  saiba:
  – Distinguir cada tipo de Coleção.
  – Escolher a melhor implementação de Coleção (entre
    as básicas) para cada tipo de uso.
  – Saber a diferença entre as Interfaces: Collection, Set,
    Queue, List, SortedSet, NavigableSet, Map,
    SortedMap e NavigableMap.
  – Conhecer as implementações básicas: ArrayList,
    Vector, LinkedList, PriorityQueue, TreeSet, HashSet,
    LinkedHashSet, TreeMap, HashMap e
    LinkedHashMap.
Collections
Objetivos:
• Ao final desta apresentação espera-se que você
  saiba:
  – Distinguir cada tipo de Coleção.
  – Escolher a melhor implementação de Coleção (entre
    as básicas) para cada tipo de uso.
  – Saber a diferença entre as Interfaces: Collection, Set,
    Queue, List, SortedSet, NavigableSet, Map,
    SortedMap e NavigableMap.
  – Conhecer as implementações básicas: ArrayList,
    Vector, LinkedList, PriorityQueue, TreeSet, HashSet,
    LinkedHashSet, TreeMap, HashMap e
    LinkedHashMap.
Collections
Objetivos:
• Ao final desta apresentação espera-se que você
  saiba:
  – Distinguir cada tipo de Coleção.
  – Escolher a melhor implementação de Coleção (entre
    as básicas) para cada tipo de uso.
  – Saber a diferença entre as Interfaces: Collection, Set,
    Queue, List, SortedSet, NavigableSet, Map,
    SortedMap e NavigableMap.
  – Conhecer as implementações básicas: ArrayList,
    Vector, LinkedList, PriorityQueue, TreeSet, HashSet,
    LinkedHashSet, TreeMap, HashMap e
    LinkedHashMap.
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Existe a dificuldade da inflexibilidade.
  – Muito rígido, é preciso definir seu tamanho assim que
    nós a criamos
  – Object[] minhaArray = new Object[10];
  – E se eu precisar agora de 20 lugares ? Como
    aumentar o tamanho e manter os 10 originais ?
  – Object[] novaArray = new Object[20];
  – System.arraycopy(minhaArray,0,novaArray,0,10);
  – Como facilitar isto?
  – Como usar o conceito de array ? Porém com um
    pouco mais de flexibilidade?
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Arrays:
  – Coleções pode ser a saída para este problema
  – Uma das formas de pensar nas coleções são como
    Arrays turbinadas, incrementadas com várias
    funcionalidades e regras.
  – É comum aprender apenas sobre ArrayList
  – E usá-la para substituir as arrays (porém existe
    muitas outras).
  – É necessário saber que existe algumas regras que
    regem as Coleções
  – E é por essas regras que são pré-requisitos para os
    nossos estudos sobre Collections que iremos
    começar.
Collections
• Pré-requisitos:
Collections
• Pré-requisitos:
  – Igualdade: Para se trabalhar com coleções é
    preciso entender a igualdade em Java
Collections
• Pré-requisitos:
  – Igualdade: Para se trabalhar com coleções é
    preciso entender a igualdade em Java
• Porque é preciso?
Collections
• Pré-requisitos:
  – Igualdade: Para se trabalhar com coleções é
    preciso entender a igualdade em Java
• Porque é preciso?
  – Quando chegarmos lá tudo ficará mais claro,
    mas adiantando, varias funcionalidades de
    coleções como contains(Object o) – que
    verifica se existe um objeto na coleção –
    precisa testar a igualdade para funcionar.
Collections
• Como funciona igualdade em Java ?
  pessoa1 == pessoa2
Collections
• Como funciona igualdade em Java ?
  pessoa1 == pessoa2
• Isso irá testar apenas se as duas variáveis
  referenciam uma única instancia!
Collections
• Como então saber, por exemplo, quando
  dois objetos Pessoa são significantemente
  iguais?
Collections
• Como então saber, por exemplo, quando
  dois objetos Pessoa são significantemente
  iguais?
  – Para esse tipo de teste você deve usar um
    método que todo objeto Java tem
    equals(Object o)
Collections
• Como então saber, por exemplo, quando
  dois objetos Pessoa são significantemente
  iguais?
  – Para esse tipo de teste você deve usar um
    método que todo objeto Java tem
    equals(Object o)
• Então nosso teste de igualdade seria:
  pessoa1.equals(pessoa2)
Collections
• Só isso resolve?
Collections
• Só isso resolve?
  – Não
Collections
• Só isso resolve?
  – Não
• Por padrão o método equals de Object faz
  o mesmo que o operador ==
Collections
• Só isso resolve?
  – Não
• Por padrão o método equals de Object faz
  o mesmo que o operador ==
  public class Object {
    //..
    public boolean equals(Object obj) {
       return (this == obj);
   }
   //…
Collections
• Então se queremos definir em nosso
  modelo que dois objetos Pessoa são
  iguais quando, por exemplo, seus cpf são
  iguais?
Collections
• Então se queremos definir em nosso
  modelo que dois objetos Pessoa são
  iguais quando, por exemplo, seus cpf são
  iguais?
  – Neste caso nós precisamos ensinar ao nosso
    programa a igualdade entre nossos objetos
Collections
• Então se queremos definir em nosso
  modelo que dois objetos Pessoa são
  iguais quando, por exemplo, seus cpf são
  iguais?
  – Neste caso nós precisamos ensinar ao nosso
    programa a igualdade entre nossos objetos
• Como fazer isso??
Collections
• Então se queremos definir em nosso
  modelo que dois objetos Pessoa são
  iguais quando, por exemplo, seus cpf são
  iguais?
  – Neste caso nós precisamos ensinar ao nosso
    programa a igualdade entre nossos objetos
• Como fazer isso??
  – Sobrescrevendo o equals
Collections
• Mas não basta simplesmente
  sobrescrever!
Collections
• Mas não basta simplesmente
  sobrescrever!
• E existe um contrato de equals que
  deve ser rigorosamente seguido para o
  bom funcionamento do programa e da
  Java Collections Framework
Collections
• O contrato diz que equals é:
  – Reflexível: a.equals(a) == true
  – Simétrico: a.equals(b) == b.equals(a)
  – Transitivo: se a.equals(b) && b.equals(c) == true .:.
                 a.equals(c) também é true.
  – Consistente: a.equals(b) deve retornar sempre true
    ou sempre falso, desde que nenhuma propriedade do
    do Objeto que faz parte do teste equals seja alterada.
  – Deve retornar false quando testado contra
    uma variável null
Collections
• O contrato diz que equals é:
  – Reflexível: a.equals(a) == true
  – Simétrico: a.equals(b) == b.equals(a)
  – Transitivo: se a.equals(b) && b.equals(c) == true .:.
                 a.equals(c) também é true.
  – Consistente: a.equals(b) deve retornar sempre true
    ou sempre falso, desde que nenhuma propriedade do
    do Objeto que faz parte do teste equals seja alterada.
  – Deve retornar false quando testado contra
    uma variável null
Collections
• O contrato diz que equals é:
  – Reflexível: a.equals(a) == true
  – Simétrico: a.equals(b) == b.equals(a)
  – Transitivo: se a.equals(b) && b.equals(c) == true .:.
                 a.equals(c) também é true.
  – Consistente: a.equals(b) deve retornar sempre true
    ou sempre falso, desde que nenhuma propriedade do
    do Objeto que faz parte do teste equals seja alterada.
  – Deve retornar false quando testado contra
    uma variável null
Collections
• O contrato diz que equals é:
  – Reflexível: a.equals(a) == true
  – Simétrico: a.equals(b) == b.equals(a)
  – Transitivo: se a.equals(b) && b.equals(c) == true .:.
                 a.equals(c) == true.
  – Consistente: a.equals(b) deve retornar sempre true
    ou sempre falso, desde que nenhuma propriedade do
    do Objeto que faz parte do teste equals seja alterada.
  – Deve retornar false quando testado contra
    uma variável null
Collections
• O contrato diz que equals é:
  – Reflexível: a.equals(a) == true
  – Simétrico: a.equals(b) == b.equals(a)
  – Transitivo: se a.equals(b) && b.equals(c) == true .:.
                 a.equals(c) == true
  – Consistente: a.equals(b) deve retornar sempre true
    ou sempre falso, desde que nenhuma propriedade do
    do Objeto que faz parte do teste equals seja alterada.
  – Deve retornar false quando testado contra
    uma variável null
Collections
• Portanto para nossa classe Pessoa podemos
  definir um equals assim:
  public class Pessoa {
    private String cpf;
    //...
    @Override
    public boolean equals(Object p) {
       if (cpf == null)
          return false;
       return (p instanceof Pessoa) &&
          this.cpf.equals(((Pessoa)p).cpf);
    }
    //...
  }
Collections
• Portanto para nossa classe Pessoa podemos
  definir um equals assim:
  public class Pessoa {
    private String cpf;
    //...
    @Override // não é necessário mas é bom
    public boolean equals(Object p) {
       if (cpf == null)
          return false;
       return (p instanceof Pessoa) &&
          this.cpf.equals(((Pessoa)p).cpf);
    }
    //...
  }
Collections
• Portanto para nossa classe Pessoa podemos
  definir um equals assim:    Eu não podia colocar
   public class Pessoa {              A classe Pessoa?
     private String cpf;              No lugar de Objeto ?
     //...
     @Override
     public boolean equals(Object p) {
                               Pessoa
        if (cpf == null)
           return false;
        return (p instanceof Pessoa) &&
           this.cpf.equals(((Pessoa)p).cpf);
     }
     //...
   }
Collections
• Portanto para nossa classe Pessoa podemos
  definir um equals assim:    Eu não podia colocar
   public class Pessoa {              A classe Pessoa?
     private String cpf;              No lugar de Objeto ?
     //...
     @Override
     public boolean equals(Object p) {
                               Pessoa
        if (cpf == null)                         NÃO!!!!
           return false;                         Pois é preciso
        return (p instanceof Pessoa) &&          sobrescrever o
           this.cpf.equals(((Pessoa)p).cpf);     método da classe
     }                                           Object e portanto
     //...                                       manter a mesma
   }                                             assinatura
Collections
• Então é isso basta sobrescrever o método
  equals corretamente na minha classe e já
  posso usar:
  pessoa1.equals(pessoa2)
• Não preciso fazer mais nada?
Collections
• Então é isso basta sobrescrever o método
  equals corretamente na minha classe e já
  posso usar:
  pessoa1.equals(pessoa2)
• Não preciso fazer mais nada?
  – ERRADO! Precisa sim! E é ai o erro mais comum de
    quem trabalha com collections
Collections
• Então é isso basta sobrescrever o método
  equals corretamente na minha classe e já
  posso usar:
  pessoa1.equals(pessoa2)
• Não preciso fazer mais nada?
  – ERRADO! Precisa sim! E é ai o erro mais comum de
    quem trabalha com collections
• O contrato de equals(Object o) esta
  fortemente ligado ao de hashCode()
Collections
• E pra que serve esse hashCode() ?
Collections
• E pra que serve esse hashCode() ?
  – Calma que assim que chegar em coleções falaremos
    dele ao estudar HashSet, LinkedHashSet, HashMap,
    LinkedHashMap e Hashtable
Collections
• E pra que serve esse hashCode() ?
  – Calma que assim que chegar em coleções falaremos
    dele ao estudar HashSet, LinkedHashSet, HashMap,
    LinkedHashMap e Hashtable
• Certo mas então o que ele tem a ver com meu
  teste de igualdade ??
Collections
• E pra que serve esse hashCode() ?
  – Calma que assim que chegar em coleções falaremos
    dele ao estudar HashSet, LinkedHashSet, HashMap,
    LinkedHashMap e Hashtable
• Certo mas então o que ele tem a ver com meu
  teste de igualdade ??
  – As definições do contrato de hashCode() o ligam
    diretamente ao teste de igualdade, portanto sempre
    que sobrescrever equals(Object o) você terá que
    sobrescrever também o hashCode()
Collections
• O contrato do hashCode() diz:
  – É constante: qualquer chamada a hashCode() deve sempre
    retornar o mesmo interiro, desde que as propriedade usadas no
    teste equals(Object o) não sejam alteradas.
  – É igual para objetos iguais: a.equals(b) == true .:.
    a.hashCode() == b.hashCode()
  – Não é necessário ser diferente para objetos
    diferentes: ou seja, se a.equals(b) == false .:. a.hashCode()
    == b.hashCode() || hashCode() != b.hashCode()
Collections
• O contrato do hashCode() diz:
  – É constante: qualquer chamada a hashCode() deve sempre
    retornar o mesmo inteiro, desde que as propriedade usadas no
    teste equals(Object o) não sejam alteradas.
  – É igual para objetos iguais: a.equals(b) == true .:.
    a.hashCode() == b.hashCode()
  – Não é necessário ser diferente para objetos
    diferentes: ou seja, se a.equals(b) == false .:. a.hashCode()
    == b.hashCode() || hashCode() != b.hashCode()
Collections
• O contrato do hashCode() diz:
  – É constante: qualquer chamada a hashCode() deve sempre
    retornar o mesmo inteiro, desde que as propriedade usadas no
    teste equals(Object o) não sejam alteradas.
  – É igual para objetos iguais: a.equals(b) == true .:.
    a.hashCode() == b.hashCode()
  – Não é necessário ser diferente para objetos
    diferentes: ou seja, se a.equals(b) == false .:. a.hashCode()
    == b.hashCode() || hashCode() != b.hashCode()
Collections
• O contrato do hashCode() diz:
  – É constante: qualquer chamada a hashCode() deve sempre
    retornar o mesmo inteiro, desde que as propriedade usadas no
    teste equals(Object o) não sejam alteradas.
  – É igual para objetos iguais: a.equals(b) == true .:.
    a.hashCode() == b.hashCode()
  – Não é necessário ser diferente para objetos
    diferentes: ou seja, se a.equals(b) == false .:.
    a.hashCode() == b.hashCode() || hashCode() != b.hashCode()
Collections
• Por padrão o método hashCode() é
  diferente para cada instancia de Object.
• Não é implementado em java e sim com
  linguagem nativa:
  public class Object {
    //..
    public native int hashCode();
    //…
  }
Collections
• Por padrão o método hashCode() é
  diferente para cada instancia de Object.
• Não é implementado em java e sim com
  linguagem nativa:
  public class Object {
    //..
    public native int hashCode();
    //…
  }
Collections
• Portanto no nosso modelo dois objetos
  Pessoa com o mesmo cpf, vai retornar
  hashCode diferentes (pois esse é o
  padrão do hashCode)
• Isto fere o contrato de hashCode, pois:
  pessoa1.equals(pessoa2) == true
  pessoa1.hashCode() != pessoa2.hashCode()
Collections
• Portanto no nosso modelo dois objetos
  Pessoa com o mesmo cpf, vai retornar
  hashCode diferentes (pois esse é o
  padrão do hashCode)
• Isto fere o contrato de hashCode, pois:
  pessoa1.equals(pessoa2) == true
  pessoa1.hashCode() != pessoa2.hashCode()
Collections
   Pessoa p1 = new Pessoa("123.456.789-00"); //igual a p2
   String text = "São iguais? %b ... hashCodes? %d , %d n";
   for (int i = 0; i < 30; i++) {
      Pessoa p2 = new Pessoa("123.456.789-00"); //igual a p1
      System.out.printf( text, p1.equals(p2), p1.hashCode(),
                            p2.hashCode() );
   }
• O output disso é algo como:
   –   São iguais? true ... hashCodes? 11394033 , 4384790
   –   São iguais? true ... hashCodes? 11394033 , 24355087
   –   São iguais? true ... hashCodes? 11394033 , 5442986
   –   São iguais? true ... hashCodes? 11394033 , 10891203
   –   São iguais? true ... hashCodes? 11394033 , 9023134
   –   ....... etc
Collections
• Portanto para nossa classe Pessoa um
  hashCode() valido pode ser:
  public class Pessoa {
    private String cpf;
    //...
    @Override
    public int hashCode() {
       return (cpf == null) ? 0 : cpf.hashCode();
    }
    //...
  }
Collections
• Portanto para nossa classe Pessoa um
  hashCode() valido pode ser:
  public class Pessoa {
    private String cpf;
    //...
    @Override // não é necessário mas é bom
    public int hashCode() {
       return (cpf == null) ? 0 : cpf.hashCode();
    }
    //...
  }
Collections
• Portanto para nossa classe Pessoa um
  hashCode() valido pode ser:
  public class Pessoa {                Eu não poderia retornar
    private String cpf;                sempre o mesmo número?
                                       Isso não feriria o contrato!
    //...
    @Override
    public int hashCode() {
       return (cpf == null) ? 0 : cpf.hashCode();
               12;
    }
    //...
  }
Collections
• Portanto para nossa classe Pessoa um
  hashCode() valido pode ser:
  public class Pessoa {                Eu não poderia retornar
    private String cpf;                sempre o mesmo número?
                                       Isso não feriria o contrato!
    //...
    @Override
    public int hashCode() {
                                        SIM! Poderia...
       return (cpf == null) ? 0 : cpf.hashCode();nem um
               12;                      Porem não é
                                        pouco eficiente, como
    }                                   veremos mais adiante
    //...                               quando estudarmos as
                                        coleções que usam hash
  }
Collections
• Vamos ao que interesssa...
Collections
• Java Collections Framework (JCF)
  – Existem duas interfaces principais são elas:
    • java.util.Collection: uma coleção de objetos
    • java.util.Map: uma coleção de chave        objeto
  – Toda a estrutura da JCF é baseada e
    descendem da estrutura destas duas
    interfaces
Collections
• Java Collections Framework (JCF)
  – Existem duas interfaces principais são elas:
    • java.util.Collection: uma coleção de objetos
    • java.util.Map: uma coleção de chave        objeto
  – Toda a estrutura da JCF é baseada e
    descendem da estrutura destas duas
    interfaces
• Então como seria esta estrutura ??
Utilitários
Collections
• E eu preciso saber de tudo isso ????
Collections
• E eu preciso saber de tudo isso ????
  – SIM!!!!
Collections
• E eu preciso saber de tudo isso ????
  – SIM!!!! Para a certificação e para a vida de
    programador java!
Collections
• E eu preciso saber de tudo isso ????
  – SIM!!!! Para a certificação e para a vida de
    programador java!
• Mas... devagar com andor que o santo é
  de barro...
• Quais são as interfaces mesmo ??
Collections
• Interfaces da JFC
Collections
• Interfaces da JFC




• Ta bagunçado né ?? Vamos olhar isso
  direito, começando pela Collection!
Collections
• A java.util.Collection:
  – Collection é um contrato de interface que
    representa uma coleção de objetos
  – Pode-se dizer que uma coleção é uma versão
    turbinada de array, com mais funcionalidades
    e mais segurança.
Collections
• Métodos java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)
   boolean retainAll(Collection<?> c)
   void clear()
   boolean contains(Object o)
   boolean containsAll(Collection<?> c)
   int size()
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator() //método de Iterable
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)
   boolean retainAll(Collection<?> c)
   void clear()                         Opcional

   boolean contains(Object o)
   boolean containsAll(Collection<?> c)
   int size()
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)       COMO ASSIM OPCIONAL?
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)
   boolean retainAll(Collection<?> c)
   void clear()                         Opcional

   boolean contains(Object o)
   boolean containsAll(Collection<?> c)
   int size()
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)       COMO ASSIM OPCIONAL?
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)              A interface pede o método,
                                                   como vocês podem ver,
   boolean retainAll(Collection<?> c)              porém na implementação
   void clear()                         Opcional   pode-se lançar a exceção
                                                   UnsupportedOperationException
   boolean contains(Object o)                      E isso é utilizado em
   boolean containsAll(Collection<?> c)            Implementações somente leitura
                                                   Implementações boca de lobo
   int size()                                      ou outros tipos.
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)
   boolean retainAll(Collection<?> c)
   void clear()
   boolean contains(Object o)
   boolean containsAll(Collection<?> c)
   int size()                           Vamos conhecer os métodos!
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)      Adiciona um elemento a
   boolean retainAll(Collection<?> c)    coleção, onde este elemento
   void clear()                          deve ser do mesmo tipo <E>
   boolean contains(Object o)           da coleção, ou de um sub-tipo.
   boolean containsAll(Collection<?> c) Retorna verdadeiro se houver
   int size()                             modificação na coleção, ou
   boolean isEmpty()                         seja se o elemento for
                                                  adicionado.
   Object[] toArray()
   <T> T[] toArray(T[] a)
                                          Implementação é opcional
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)      Adiciona uma coleção de
   boolean retainAll(Collection<?> c)   elementos do mesmo tipo <E>
   void clear()                          ou uma coleção de sub-tipos
   boolean contains(Object o)                      de <E>.
   boolean containsAll(Collection<?> c)   Retorna verdadeiro se pelo
   int size()                               menos um elemento for
   boolean isEmpty()                    adicionado a coleção, ou seja,
                                         se a coleção foi modificada.
   Object[] toArray()
   <T> T[] toArray(T[] a)
                                          Implementação é opcional
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c) Remove da coleção a primeira
   boolean retainAll(Collection<?> c)       ocorrência de um objeto
   void clear()                            significantemente igual ao
   boolean contains(Object o)                        enviado.
   boolean containsAll(Collection<?> c)   Retorna verdadeiro caso o
   int size()                            objeto existia na coleção, ou
   boolean isEmpty()                          seja, se a coleção foi
                                                   modificada.
   Object[] toArray()
   <T> T[] toArray(T[] a)
                                          Implementação é opcional.
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)         Remove todas da as
   boolean retainAll(Collection<?> c)   ocorrências desta coleção dos
   void clear()                         elementos contidos na coleção
   boolean contains(Object o)                      c enviada.
   boolean containsAll(Collection<?> c) Após esta operação nenhum
   int size()                               elemento desta coleção
   boolean isEmpty()                    retornará true para c.contains()
                                          Retorna verdadeiro se pelo
   Object[] toArray()
                                            menos um elemento foi
   <T> T[] toArray(T[] a)
                                            removido, ou seja, se a
   Iterator<E> iterator()
                                            coleção foi modificada.
                                          Implementação é opcional.
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)     Faz o processo inverso de
   boolean retainAll(Collection<?> c)              removeAll.
   void clear()                          Retém nesta coleção apénas
   boolean contains(Object o)             os elementos que também
   boolean containsAll(Collection<?> c) estejam continos na coleção c.
   int size()                            Após esta operação todos os
   boolean isEmpty()                       elementos desta coleção
                                              retornarão true para
   Object[] toArray()
                                                  c.contains().
   <T> T[] toArray(T[] a)
                                           Retorna verdadeiro se a
   Iterator<E> iterator()
                                            coleção for modificada.
                                          Implementação é opcional
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)    Remove todos os elementos
   boolean retainAll(Collection<?> c)            da coleção
   void clear()
   boolean contains(Object o)             Implementação é opcional.
   boolean containsAll(Collection<?> c)
   int size()
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c) Verifica se existe nesta coleção
   boolean retainAll(Collection<?> c)    um objeto significantemente
   void clear()                           igual ao objeto o enviado.
   boolean contains(Object o)
   boolean containsAll(Collection<?> c)
   int size()
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c) Verifica se todos os objetos da
   boolean retainAll(Collection<?> c)       coleção c enviada, estão
   void clear()                              contidos nesta coleção.
   boolean contains(Object o)                 Só retorna verdade se
   boolean containsAll(Collection<?> c) this.contains(elementoDeC) for
   int size()                            verdade para cada elemento
   boolean isEmpty()                                   de c.
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)      Informa a quantidade de
   boolean retainAll(Collection<?> c)    objetos contidos na coleção.
   void clear()                          Obs.: Se a coleção contiver
   boolean contains(Object o)             objetos nulos eles também
   boolean containsAll(Collection<?> c)      serão contabilizados
   int size()
   boolean isEmpty()                      Sim! Existem coleções que
                                          aceitam elementos nulos.
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)     Método de comodidade, o
   boolean retainAll(Collection<?> c)        mesmo que testar se:
   void clear()                                  size() == 0
   boolean contains(Object o)             Retorna verdadeiro se não
   boolean containsAll(Collection<?> c)    houver elementos nesta
   int size()                                     coleção.
   boolean isEmpty()
   Object[] toArray()
   <T> T[] toArray(T[] a)
   Iterator<E> iterator()
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)    Retorna uma array contendo
   boolean retainAll(Collection<?> c)   cada um dos elementos desta
   void clear()                         coleção, na mesma ordem em
   boolean contains(Object o)            que os elementos aparecem
   boolean containsAll(Collection<?> c)           no iterator().
   int size()                             Não é a array mantida pela
   boolean isEmpty()                         lista (caso assim seja
                                         implementada) é uma cópia
   Object[] toArray()
                                                      dela.
   <T> T[] toArray(T[] a)
                                        Alterações nesta array não são
   Iterator<E> iterator()
                                             refletidas na coleção.
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c) Retorna todos os elementos da
   boolean retainAll(Collection<?> c)       coleção em uma array do
   void clear()                              mesmo tipo da enviada.
   boolean contains(Object o)           if (a.length >= this.size()) {
   boolean containsAll(Collection<?> c) Então os elementos serão
   int size()                           colocados dentro da própria
   boolean isEmpty()                    array enviada e os elementos
                                        que sobrarem serão setados
   Object[] toArray()
                                        null.
   <T> T[] toArray(T[] a)
                                        } else {
   Iterator<E> iterator()
                                        cria uma nova array do mesmo
                                        tipo da enviada e a retorna.
Collections
• java.util.Collection<E> extends Iterable<E>:
   boolean add(E e)
   boolean addAll(Collection<? extends E> c)
   boolean remove(Object o)
   boolean removeAll(Collection<?> c)     Cria um Iterator que é usado
   boolean retainAll(Collection<?> c)        para navegar sobre os
   void clear()                             elementos desta coleção
   boolean contains(Object o)           public interface Iterator<E> {
   boolean containsAll(Collection<?> c)   boolean hasNext();
   int size()                             E next();
   boolean isEmpty()                      void remove(); //opicional
                                        }
   Object[] toArray()
                                        * Este método é parte da
   <T> T[] toArray(T[] a)
                                        interface Iterable<E> e toda
   Iterator<E> iterator() //*
                                        classe que a implementa pode
                                        ser usada em um for-each
Collections
• java.util.Collection<E>:
  – Não há restrição, ordem ou classificação
    definida no contrato de Collection
Collections
• java.util.Collection<E>:
  – Não há restrição, ordem ou classificação
    definida no contrato de Collection
  – A coleção de objetos pode conter qualquer
    tipo de objeto, em qualquer quantidade,
    sejam eles repetidos ou não, sem qualquer
    ordem ou classificação definida.
Collections
• java.util.Collection<E>:
  – Não há restrição, ordem ou classificação
    definida no contrato de Collection
  – A coleção de objetos pode conter qualquer
    tipo de objeto, em qualquer quantidade,
    sejam eles repetidos ou não, sem qualquer
    ordem ou classificação definida.
  – Esta é a forma mais genérica de agrupar
    objetos
Collections
• Tá! e se eu quiser uma coleção sem
  deixar que os objetos se repitam ??
Collections
• Tá! e se eu quiser uma coleção sem
  deixar que os objetos se repitam ??
  – Então você quer um java.util.Set uma sub-
    interface de Collection
Collections
• java.util.Set<E> extends Collection<E>:
  – Um Set tem exatamente a mesma interface de
    Collection, a única mudança é na descrição de seus
    métodos.
  – O Set não aceita elementos repetidos
  – Ao usar add(obj) onde o Set já contem obj, ele
    simplesmente não o adiciona e retorna false.
  – A não implementação de equals(Object o) ou a
    implementação incorreta pode causar efeitos
    indesejáveis e bug de difícil detectação.
Collections
• java.util.Set<E> extends Collection<E>:
  – Um Set tem exatamente a mesma interface de
    Collection, a única mudança é na descrição de seus
    métodos.
  – O Set não aceita elementos repetidos
  – Ao usar add(obj) onde o Set já contem obj, ele
    simplesmente não o adiciona e retorna false.
  – A não implementação de equals(Object o) ou a
    implementação incorreta pode causar efeitos
    indesejáveis e bug de difícil detectação.
Collections
• java.util.Set<E> extends Collection<E>:
  – Um Set tem exatamente a mesma interface de
    Collection, a única mudança é na descrição de seus
    métodos.
  – O Set não aceita elementos repetidos
  – Ao usar add(obj) onde o Set já contem obj, ele
    simplesmente não o adiciona e retorna false.
  – A não implementação de equals(Object o) ou a
    implementação incorreta pode causar efeitos
    indesejáveis e bug de difícil detectação.
Collections
• java.util.Set<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato de Set
  – A coleção de objetos pode conter qualquer tipo de
    objeto, em qualquer quantidade, sem qualquer ordem
    ou classificação definida, porem nunca objetos
    repetidos!
  – Este é o diferencial de um Set para uma Collection,
    não há objetos significantemente repetidos, isso
    quer dizer onde equals(other) retorne true para outro
    elemento dentro do mesmo Set.
Collections
• java.util.Set<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato de Set
  – A coleção de objetos pode conter qualquer tipo de
    objeto, em qualquer quantidade, sem qualquer ordem
    ou classificação definida, porem nunca objetos
    repetidos!
  – Este é o diferencial de um Set para uma Collection,
    não há objetos significantemente repetidos, isso
    quer dizer onde equals(other) retorne true para outro
    elemento dentro do mesmo Set.
Collections
• java.util.Set<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato de Set
  – A coleção de objetos pode conter qualquer tipo de
    objeto, em qualquer quantidade, sem qualquer ordem
    ou classificação definida, porem nunca objetos
    repetidos!
  – Este é o diferencial de um Set para uma Collection,
    não há objetos significantemente repetidos, isso
    quer dizer onde equals(other) retorne true para outro
    elemento dentro do mesmo Set.
Collections
• É possível também utilizar os conceitos de
  fila com a Java Collections Framework
  – Através da interface java.util.Queue<E>
Collections
• java.util.Queue<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato da fila Queue
  – Há apenas disponibilizado uma interface de fila,
    sem especificar quais condições.
  – As suas implementações que vão definir se a Queue
    é uma FIFO, FILO ou o quer que seja.
Collections
• java.util.Queue<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato da fila Queue
  – Há apenas disponibilizado uma interface de fila,
    sem especificar quais condições.
  – As suas implementações que vão definir se a Queue
    é uma FIFO, FILO ou o quer que seja.
Collections
• java.util.Queue<E> extends Collection<E>:
  – Assim como a Collection, não há restrição, ordem ou
    classificação definida no contrato da fila Queue
  – Há apenas disponibilizado uma interface de fila,
    sem especificar quais condições.
  – As suas implementações que vão definir se a Queue
    é uma FIFO, FILO ou o quer que seja.
Collections
• java.util.Queue<E> extends Collection<E>:
  boolean add(E e) //adciona um elemento a fila se houver capacidade,
                     //lança uma IllegalStateException se não houver.
  boolean offer(E e) //adciona um elemento a fila se houver capacidade,
                     //retorna false (sem lança exceção) se não houver.

  E element() //retorna, mas não remove o elemento do topo da fila
              //lança uma exceção se não houver mais elementos
  E peek()    //retorna, mas não remove o elemento do topo da fila
              //retorna null se não houver elementos.

  E remove() //retorna e remove o elemento do topo da fila
              //lança uma exceção se não houver mais elementos.
  E poll()   //retorna e remove o elemento do topo da fila
              //retorna null se não houver elementos.
Collections
• java.util.Queue<E> extends Collection<E>:
  boolean add(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver lança uma IllegalStateException.
  boolean offer(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver retorna false (sem lança exceção).

  E element() //retorna, mas não remove o elemento do topo da fila
              //lança uma exceção se não houver mais elementos.
  E peek()    //retorna, mas não remove o elemento do topo da fila
              //retorna null se não houver elementos.

  E remove() //retorna e remove o elemento do topo da fila
              //lança uma exceção se não houver mais elementos.
  E poll()   //retorna e remove o elemento do topo da fila
              //retorna null se não houver elementos.
Collections
• java.util.Queue<E> extends Collection<E>:
  boolean add(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver lança uma IllegalStateException.
  boolean offer(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver retorna false (sem lança exceção).

  E element() //retorna, mas não remove o elemento do topo da fila
              //não havendo + elementos lança NoSuchElementException.
  E peek()    //retorna, mas não remove o elemento do topo da fila
              //retorna null se não houver elementos.

  E remove() //retorna e remove o elemento do topo da fila
              //lança uma exceção se não houver mais elementos.
  E poll()   //retorna e remove o elemento do topo da fila
              //retorna null se não houver elementos.
Collections
• java.util.Queue<E> extends Collection<E>:
  boolean add(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver lança uma IllegalStateException.
  boolean offer(E e) //adiciona um elemento a fila se houver capacidade,
                     // se não houver retorna false (sem lança exceção).

  E element() //retorna, mas não remove o elemento do topo da fila
              //não havendo + elementos lança NoSuchElementException.
  E peek()    //retorna, mas não remove o elemento do topo da fila
              //retorna null se não houver elementos.

  E remove() //retorna e remove o elemento do topo da fila
             //não havendo + elementos lança NoSuchElementException.
  E poll()   //retorna e remove o elemento do topo da fila
             //retorna null se não houver elementos.
Collections
• Mas e como eu consigo verificar o elemento 4
  que esta dentro de uma Collection, Queue ou
  Set? só da usando o iterator() ?
  – Sim infelizmente sim, a única forma de verificar os
    elementos destas duas interfaces é percorrendo a
    coleção toda!
• Putz! E aquele papo de que era uma array
  turbinada?? Não tem índice ?
  – Para tudo na vida tem uma solução, o que você quer
    é uma java.util.List
Collections
• Mas e como eu consigo verificar o elemento 4
  que esta dentro de uma Collection, Queue ou
  Set? só da usando o iterator() ?
  – Sim infelizmente sim, a única forma de verificar os
    elementos destas interfaces é percorrendo a coleção
    toda!
• Putz! E aquele papo de que era uma array
  turbinada?? Não tem índice ?
  – Para tudo na vida tem uma solução, o que você quer
    é uma java.util.List
Collections
• Mas e como eu consigo verificar o elemento 4
  que esta dentro de uma Collection, Queue ou
  Set? só da usando o iterator() ?
  – Sim infelizmente sim, a única forma de verificar os
    elementos destas interfaces é percorrendo a coleção
    toda!
• Putz! E aquele papo de que era uma array
  turbinada?? Não tem índice ? cadê o get(3) ?
  – Para tudo na vida tem uma solução, o que você quer
    é uma java.util.List
Collections
• Mas e como eu consigo verificar o elemento 4
  que esta dentro de uma Collection, Queue ou
  Set? só da usando o iterator() ?
  – Sim infelizmente sim, a única forma de verificar os
    elementos destas interfaces é percorrendo a coleção
    toda!
• Putz! E aquele papo de que era uma array
  turbinada?? Não tem índice ? cadê o get(3) ?
  – Para tudo na vida tem uma solução, o que você quer
    é uma java.util.List<E>
Collections
• java.util.List<E> extends Collection<E>:
  – Uma List é uma coleção ordenada (não classificada), muito
    parecida com arrays, porem com bem mais funcionalidades e
    sem limite de tamanho.
  – Os métodos add() e addAll() da interface Collection adicionam
    itens ao final da List.
  – Assim como as Collection todos os métodos de adição e
    remoção são opcionais e podem lançar
    UnsupportedOperationException
  – As mudanças principais em relação a Collection é que tem seus
    itens ordenado. Os itens da List são ordenados em índice
      que vão de 0 a (size() -1), conformes veremos a seguir, e usar
    índice fora desse range gera IndexOutOfBoundsException.
Collections
• java.util.List<E> extends Collection<E>:
  – Uma List é uma coleção ordenada (não classificada), muito
    parecida com arrays, porem com bem mais funcionalidades e
    sem limite de tamanho.
  – Os métodos add() e addAll() da interface Collection adicionam
    itens ao final da List.
  – Assim como as Collection todos os métodos de adição e
    remoção são opcionais e podem lançar
    UnsupportedOperationException
  – As mudanças principais em relação a Collection é que tem seus
    itens ordenado. Os itens da List são ordenados em índice
      que vão de 0 a (size() -1), conformes veremos a seguir, e usar
    índice fora desse range gera IndexOutOfBoundsException.
Collections
• java.util.List<E> extends Collection<E>:
  – Uma List é uma coleção ordenada (não classificada), muito
    parecida com arrays, porem com bem mais funcionalidades e
    sem limite de tamanho.
  – Os métodos add() e addAll() da interface Collection adicionam
    itens ao final da List.
  – Assim como as Collection todos os métodos de adição e
    remoção são opcionais e podem lançar
    UnsupportedOperationException
  – As mudanças principais em relação a Collection é que tem seus
    itens ordenado. Os itens da List são ordenados em índice
      que vão de 0 a (size() -1), conformes veremos a seguir, e usar
    índice fora desse range gera IndexOutOfBoundsException.
Collections
• java.util.List<E> extends Collection<E>:
  – Uma List é uma coleção ordenada (não classificada), muito
    parecida com arrays, porem com bem mais funcionalidades e
    sem limite de tamanho.
  – Os métodos add() e addAll() da interface Collection adicionam
    itens ao final da List.
  – Assim como as Collection todos os métodos de adição e
    remoção são opcionais e podem lançar
    UnsupportedOperationException
  – As mudanças principais em relação a Collection é que tem seus
    itens ordenado. Os itens da List são ordenados em índice
      que vão de 0 a (size() -1), conformes veremos a seguir, e usar
    índice fora desse range gera IndexOutOfBoundsException.
Collections
• java.util.List<E> extends Collection<E>:
  – Uma List é uma coleção ordenada (não classificada), muito
    parecida com arrays, porem com bem mais funcionalidades e
    sem limite de tamanho.
  – Os métodos add() e addAll() da interface Collection adicionam
    itens ao final da List.
  – Assim como as Collection todos os métodos de adição e
    remoção são opcionais e podem lançar
    UnsupportedOperationException
  – As mudanças principais em relação a Collection é que tem seus
    itens ordenado. Os itens da List são ordenados em índice que
    vão de 0 a (size() -1), conformes veremos a seguir, e usar índice
    fora desse range gera IndexOutOfBoundsException.
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)
  int lastIndexOf(Object o)
  ListIterator<E> listIterator()
  ListIterator<E> listIterator(int i)
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Adiciona o elemento e na posição
                                      de índice i. Se houver, o antigo
  int lastIndexOf(Object o)
                                      elemento do índice e seus
  ListIterator<E> listIterator()      posteriores terão seus índices
  ListIterator<E> listIterator(int i) incrementados
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Adiciona os elemento de c na
                                      posição de índice i. Se houver, o
  int lastIndexOf(Object o)
                                      antigo elemento do índice e seus
  ListIterator<E> listIterator()      posteriores terão seus índices
  ListIterator<E> listIterator(int i) incrementados em c.size()
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Retorna o elemento do índice i
  int lastIndexOf(Object o)
  ListIterator<E> listIterator()
  ListIterator<E> listIterator(int i)
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Retorna o índice do primeiro
                                      objeto da list igual ao enviado ou
  int lastIndexOf(Object o)
                                      -1 caso não exista o objeto na
  ListIterator<E> listIterator()      coleção.
  ListIterator<E> listIterator(int i)
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Retorna o índice do ultimo objeto
                                      da list igual ao enviado ou -1 caso
  int lastIndexOf(Object o)
                                      não exista o objeto na coleção.
  ListIterator<E> listIterator()
  ListIterator<E> listIterator(int i)
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Retorna um ListIterator desta List.
                                      Este objeto é uma extensão do
  int lastIndexOf(Object o)
                                      Iterator, com a diferença que
  ListIterator<E> listIterator()      você pode caminhar p/ frente ou
  ListIterator<E> listIterator(int i) p/ traz na lista, alem de adicionar
  E remove(int i)                     e alterar elementos no índice
                                      corrente.
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Retorna um ListIterator desta List.
      E next()                       Este objeto é uma extensão do
      int nextIndex()                Iterator, com a diferença que
      boolean hasPrevious()          você pode caminhar p/ frente ou
      E previous()                   p/ traz na lista, alem de adicionar
      int previousIndex()            e alterar elementos no índice
      void add(E e)                  corrente.
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Verifica se há um próximo
      E next()                       elemento na List.
      int nextIndex()
      boolean hasPrevious()
      E previous()
      int previousIndex()
      void add(E e)
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Retorna o próximo elemento da
      E next()                       List.
      int nextIndex()
      boolean hasPrevious()          Se não houver o próximo
      E previous()                   elemento uma
      int previousIndex()            NoSuchElementException é
      void add(E e)                  lançada.
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Retorna o índice do próximo
      E next()                       elemento da List.
      int nextIndex()
      boolean hasPrevious()          Se não houver um próximo
      E previous()                   elemento retorna o tamanha da
      int previousIndex()            lista, ou seja, o mesmo que
      void add(E e)                  lista.size().
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Verifica se há um elemento
      E next()                       anterior na List.
      int nextIndex()
      boolean hasPrevious()
      E previous()
      int previousIndex()
      void add(E e)
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Retorna o elemento anterior da
      E next()                       List.
      int nextIndex()
      boolean hasPrevious()          Se não houver o elemento
      E previous()                   anterior uma
      int previousIndex()            NoSuchElementException é
      void add(E e)                  lançada.
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Retorna o índice do elemento
      E next()                       anterior da List.
      int nextIndex()
      boolean hasPrevious()          Se não houver um elemento
      E previous()                   anterior retorna -1.
      int previousIndex()
      void add(E e)
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Adiciona o elemento e a List no
      E next()                       índice atual, entre nextIndex() e
      int nextIndex()                previousIndex().
      boolean hasPrevious()
      E previous()
      int previousIndex()
      void add(E e)
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Substitui o último elemento
      E next()                       retornado por next ou previous.
      int nextIndex()
      boolean hasPrevious()          Se anteriormente next / previous
      E previous()                   não foi chamado ou add / remove
      int previousIndex()            foi invocado será lançada uma
      void add(E e)                  IllegalStateException
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  public interface ListIterator<E>
     extends Iterator<E> {

      boolean hasNext()              Remove o último elemento
      E next()                       retornado por next ou previous.
      int nextIndex()
      boolean hasPrevious()          Se anteriormente next / previous
      E previous()                   não foi chamado ou add / remove
      int previousIndex()            foi invocado será lançada uma
      void add(E e)                  IllegalStateException
      void set(E e)
      void remove()

  }
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Igual ao método anterior com a
                                      diferença que o índice corrente
  int lastIndexOf(Object o)
                                      do ListIterator será o índice
  ListIterator<E> listIterator()      passado.
  ListIterator<E> listIterator(int i) Obs.: é possível retornar para
  E remove(int i)                     antes do índice passado.
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Remove o elemento de índice i da
                                      List e o retorna. Importante!!!
  int lastIndexOf(Object o)           Integer indexA = 1; int indexB = 1;
  ListIterator<E> listIterator()      list.remove(indexA)
                                      list.remove(indexB)
  ListIterator<E> listIterator(int i) são operações totalmente diferentes
  E remove(int i)                     O 1° remove um objeto Integer == 1
                                      O 2° remove o objeto no índice 1
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Substitui o objeto no índice index
                                      pelo element enviado e retorna o
  int lastIndexOf(Object o)
                                      objeto substituído.
  ListIterator<E> listIterator()
  ListIterator<E> listIterator(int i)
  E remove(int i)
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• java.util.List<E> extends Collection<E>:
  boolean add(int i, E e)
  boolean addAll(int i, Collection<? extends E> c)
  E get(int i)
  int indexOf(Object o)               Retorna o elemento do índice
                                      fromIndex (inclusive) até os
  int lastIndexOf(Object o)           elementos de índice toIndex
  ListIterator<E> listIterator()      (exclusive). Mudança na subList são
                                      refletidas na List original, o contrario
  ListIterator<E> listIterator(int i) impossibilita o uso da subList, que, se
  E remove(int i)                     usada, lançará
                                      ConcurrentModificationException
  E set(int index, E element)
  List<E> subList(int fromIndex, int toIndex)
Collections
• Ok, mas existe alguma forma de criar
  Coleções classificadas ?
  – Sim!!
• Mas antes de vermos como manter listas
  classificadas precisamos conhecer duas
  interfaces Comparator<T> e
  Comparable<T>
• Estas duas interfaces indicam a ordem de
  classificação dos objetos
Collections
• Ok, mas existe alguma forma de criar
  Coleções classificadas ?
  – Sim!!
• Mas antes de vermos como manter listas
  classificadas precisamos conhecer duas
  interfaces Comparator<T> e
  Comparable<T>
• Estas duas interfaces indicam a ordem de
  classificação dos objetos
Collections
• Ok, mas existe alguma forma de criar
  Coleções classificadas ?
  – Sim!!
• Mas antes de vermos como manter listas
  classificadas precisamos conhecer duas
  interfaces Comparator<T> e
  Comparable<T>
• Estas duas interfaces indicam a ordem de
  classificação dos objetos
Collections
• Ok, mas existe alguma forma de criar
  Coleções classificadas ?
  – Sim!!
• Mas antes de vermos como manter listas
  classificadas precisamos conhecer duas
  interfaces Comparator<T> e
  Comparable<T>
• Estas duas interfaces indicam a ordem de
  classificação dos objetos
Collections
• Comparable<T> é uma interface que só tem um método:
   int compareTo(T o)
   – Retorna negativo, zero, ou positivo quando este objeto é menor
      que, igual que ou maior que, respectivamente.
• Objetos que tem ordem natural implementam esta
  interface, por exemplo:
   String texto1 = “dado”, texto2 = “morta”;
   if (texto1.compareTo(texto2) < 0) {
       System.out.println(“texto1 vem 1°”);
   } else if (texto1.compareTo(texto2) > 0) {
        System.out.println(“texto1 vem 2°”);
   }
Collections
• Comparable<T> é uma interface que só tem um método:
   int compareTo(T o)
   – Retorna negativo, zero, ou positivo quando este objeto é menor
      que, igual que ou maior que, respectivamente.
• Objetos que tem ordem natural implementam esta
  interface... por exemplo:
   String texto1 = “dado”, texto2 = “morta”;
   if (texto1.compareTo(texto2) < 0) {
       System.out.println(“texto1 vem 1°”);
   } else if (texto1.compareTo(texto2) > 0) {
        System.out.println(“texto1 vem 2°”);
   }
Collections
• Comparable<T> é uma interface que só tem um método:
   int compareTo(T o)
   – Retorna negativo, zero, ou positivo quando este objeto é menor
      que, igual que ou maior que, respectivamente.
• Objetos que tem ordem natural implementam esta
  interface... por exemplo:
   String texto1 = “dado”, texto2 = “morta”;
   if (texto1.compareTo(texto2) < 0) {
       System.out.println(“texto1 vem 1°”);
   } else if (texto1.compareTo(texto2) > 0) {
        System.out.println(“texto1 vem 2°”);
   }
Collections
• Comparable<T> é uma interface que só tem um método:
   int compareTo(T o)
   – Retorna negativo, zero, ou positivo quando este objeto é menor
      que, igual que ou maior que, respectivamente.
• Objetos que tem ordem natural implementam esta
  interface... por exemplo:
   String texto1 = “dado”, texto2 = “morta”;
   if (texto1.compareTo(texto2) < 0) {
       System.out.println(“texto1 vem 1°”); //   imprime este
   } else if (texto1.compareTo(texto2) > 0) {
        System.out.println(“texto1 vem 2°”);
   }
Collections
• Alguma vezes precisamos comparar objetos
  que não tem ordem natural, ou então comparar
  objetos por propriedades diferentes da ordem
  natural
• Neste caso utilizamos Comparator<T>
  int compare(T o1, T o2)
• Um comparator funciona como um objeto
  ordenador, que recebe dois objetos, e compara
  o primeiro com o segundo (nesta ordem) de
  acordo com os critérios definidos no
  comparator.
Collections
• Alguma vezes precisamos comparar objetos
  que não tem ordem natural, ou então comparar
  objetos por propriedades diferentes da ordem
  natural
• Neste caso utilizamos Comparator<T>
  int compare(T o1, T o2)
• Um comparator funciona como um objeto
  ordenador, que recebe dois objetos, e compara
  o primeiro com o segundo (nesta ordem) de
  acordo com os critérios definidos no
  comparator.
Collections
• Alguma vezes precisamos comparar objetos
  que não tem ordem natural, ou então comparar
  objetos por propriedades diferentes da ordem
  natural
• Neste caso utilizamos Comparator<T>
  int compare(T o1, T o2)
• Um Comparator funciona como um objeto
  ordenador, que recebe dois objetos, e compara
  o primeiro com o segundo (nesta ordem) de
  acordo com os critérios definidos no
  Comparator.
Collections
• Agora vamos lá! Vamos conhecer como
  funciona as classes classificadas
  java.util.SortedSet<E> extends Set<E>
• Esta interface é de uma coleção classificada,
  onde a classificação do comparator usado por
  ela, ou a ordem natural é mantida sempre
• Não importa a ordem em que os elementos são
  adicionados a coleção, os itens dentro da
  coleção serão sempre mantidas na classificação
  definida por seu comparator ou pela ordem
  natural.
Collections
• Agora vamos lá! Vamos conhecer como
  funciona as classes classificadas
  java.util.SortedSet<E> extends Set<E>
• Esta interface é de uma coleção classificada,
  onde a classificação do Comparator usado por
  ela, ou a ordem natural é mantida sempre
• Não importa a ordem em que os elementos são
  adicionados a coleção, os itens dentro da
  coleção serão sempre mantidas na classificação
  definida por seu comparator ou pela ordem
  natural.
Collections
• Agora vamos lá! Vamos conhecer como
  funciona as classes classificadas
  java.util.SortedSet<E> extends Set<E>
• Esta interface é de uma coleção classificada,
  onde a classificação do Comparator usado por
  ela, ou a ordem natural é mantida sempre
• Não importa a ordem em que os elementos são
  adicionados a coleção, os itens dentro da
  coleção serão sempre mantidas na classificação
  definida por seu Comparator ou pela ordem
  natural.
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Se a ordem usada na List classificada for a natural retorna null, caso
   contrario retorna o Comparator que define a ordem usada na classificação.
   O Comparator é obrigatoriamente do mesmo tipo de E ou de um super tipo
   de E.

   Obs.: sendo o Comparator<? super E> seu método compare(E o1, E o2) vai
   aceitar objetos do tipo E ou de sub-classe, assim mantemos a integridade.
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Retorna o primeiro elemento, de acordo com a classificação desse
   SortedSet.
   Não importando a ordem em que os elementos são colocados na coleção,
   será retornado o primeiro elemento de acordo com a classificação da
   SortedSet.
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Define o tail – “rabo” – de uma sub SortedSet que inicia em fromElement
   (inclusive) incluindo todos os elementos maiores que fromElement
    - A sub coleção criada é um reflexo da coleção principal, e quaisquer
   operações em uma coleção será refletida na outra, e as duas coleções
   podem ser alteradas sem problemas.
    - A sub coleção não pode receber nenhum elemento menor que
   fromElement, gerando um IllegalArgumentException: key out of range
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Retorna o ultimo elemento, de acordo com a classificação desse SortedSet.
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Define a head – “cabeça” – de uma sub SortedSet que termina em
   toElement (exclusive) incluindo todos os elementos menores a toElement
    - A sub coleção criada é um reflexo da coleção principal, e quaisquer
   operações em uma coleção será refletida na outra, e as duas coleções
   podem ser alteradas sem problemas..
    - A sub coleção não pode receber nenhum elemento maior ou igual que
   toElement, gerando um IllegalArgumentException: key out of range
Collections
• java.util.SortedSet<E> extends Set<E>:
  Comparator<? super E> comparator()
  E first()
  SortedSet<E> tailSet(E fromElement)
  E last()
  SortedSet<E> headSet(E toElement)
  SortedSet<E> subSet(E fromElement, E toElement)
   Cria uma sub SortedSet com os elementos da coleção original iniciando em
   fromElement (inculsive) e terminando em toElement (exclusive).
    - A sub coleção criada é um reflexo da coleção principal, e quaisquer
   operações em uma coleção será refletida na outra, e as duas coleções
   podem ser alteradas sem problemas.
    - A nova coleção não pode receber nenhum elemento < fromElement
   ou >= toElement, gerando um IllegalArgumentException: key out of range
Collections
• Bem legal, mas e se eu quiser encontrar o primeiro
  objeto da coleção maior a element, ou um objeto menor
  a element? Entre outras informações mais detalhas?
Collections
• Bem legal, mas e se eu quiser encontrar o primeiro
  objeto da coleção maior a element, ou um objeto menor
  a element? Entre outras informações mais detalhas?
   – Nesse caso você precisa de uma
     java.util.NavigableSet<E> extends SortedSet<E>
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)
   E floor(E e)
   E higher(E e)
   E ceiling(E e)
   E pollFirst()
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)
   E higher(E e)
   E ceiling(E e)
   E pollFirst()
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)
   E ceiling(E e)
   E pollFirst()
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)
   E pollFirst()
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()      //remove e retorna o primeiro elemento ou null
   E pollLast()
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()      //remove e retorna o primeiro elemento ou null
   E pollLast()       //remove e retorna o ultimo elemento ou null
   Iterator<E> descendingIterator()
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()      //remove e retorna o primeiro elemento ou null
   E pollLast()       //remove e retorna o ultimo elemento ou null
   Iterator<E> descendingIterator()   //Iterator na ordem inversa
   NavigableSet<E> descendingSet()
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()      //remove e retorna o primeiro elemento ou null
   E pollLast()       //remove e retorna o ultimo elemento ou null
   Iterator<E> descendingIterator()   //Iterator na ordem inversa
   NavigableSet<E> descendingSet() //NavigableSet inverso
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• java.util.NavigableSet<E> extends SortedSet<E>:
   E lower(E e)       //primeiro elemento menor a e
   E floor(E e)       //primeiro elemento menor ou igual a e
   E higher(E e)      //primeiro elemento maior a e
   E ceiling(E e)     //primeiro elemento maior ou igual a e
   E pollFirst()                                      Igual aos métodos da
                      //remove e retorna o primeiro elemento ou null
                                                    classe SortedSet porém
   E pollLast()       //remove e retorna o ultimo elemento pode escolher
                                                    aqui você ou null
   Iterator<E> descendingIterator()                 se o elemento enviado é
                                      //Iterator na ordem inversa
                                                     inclusive ou exclusive.
   NavigableSet<E> descendingSet() //NavigableSet inverso
   NavigableSet<E> headSet(E toElement, boolean inclusive)
   NavigableSet<E> tailSet(E fromElement, boolean inclusive)
   NavigableSet<E> subSet(E from, boolean inc, E to, boolean inc)
Collections
• Existem mais interfaces de Collection ?
   – Que descendam de Collection? nenhuma que vá cair na prova!
     Mas é bastante vasta a Java Collection Framework
Collections
• Existem mais interfaces de Collection ?
   – Que descendam de Collection? nenhuma que vá cair na prova!
     Mas é bastante vasta a Java Collection Framework
• Sobre interfaces só falta Map<E> e suas sub-interfaces,
  mas este nós só vamos ver depois das classes
  Concretas de Collection.
Collections
• Existem mais interfaces de Collection ?
   – Que descendam de Collection? nenhuma que vá cair na prova!
     Mas é bastante vasta a Java Collection Framework
• Sobre interfaces só falta Map<E> e suas sub-interfaces,
  mas este nós só vamos ver depois das classes
  Concretas de Collection.
• Então vamos as classes concretas
<<Interface>>
        Collection<E>
                        Collections
        <<Interface>>
           List<E>


Vector<E>         ArrayList<E>

• Para o exame você só precisa saber que as duas
  classes tem a mesma implementação, exceto pela
  sincronização:
   – Vector: tem todos os seus métodos sincronizados
   – ArrayList: NÃO tem os métodos sincronizados.
• Só ter os métodos sincronizados não garante a classe
  que ela é Thread safe, por isso muito cuidado com as
  perguntas da prova, e é aconselhável o uso de ArrayList
  pois Vector é mais lenta devido a sync
<<Interface>>
           Collection<E>
                             Collections
<<Interface>>        <<Interface>>
   List<E>            Queue<E>


 •
LinkedList<E>      PriorityQueue<E>

 •   LinkedList: Implementa List e Queue, portanto tem todas
     funcionalidades de List além da Fila, onde o modelo de fila
     implementado é FIFO (firs-in-first-out).
 •   PriorityQueue: Essa é uma das poucas que apenas a
     implementação não da todas as pistas, PriorityQueue é uma fila
     classificada, ou seja, respeita a classificação natural dos elementos
     ou de um Comparator.
      – priorityQueue.poll() retorna sempre o menor elemento (de acordo com o
        Comparator da fila ou a ordem natural).
      – A PriorityQueue aceita valores duplicados
      – Não usar Comparator com objetos não classificáveis gera exceção ao
        tentar adicionar elementos.
<<Interface>>
 Collection<E>
                         Collections
 <<Interface>>
    Set<E>        • TreeSet: uma das classes mais
                    interessante e que mais cai na prova:
 <<Interface>>       – É uma coleção de elementos únicos em
 SortedSet<E>          relação a classificação definida.
                     – Deve-se usar Comparator, quando não se quer
                       usar, ou não existe, uma classificação natural.
 <<Interface>>
NavigableSet<E>      – Usar a classe sem Comparator com um objeto
                       sem classificação natural gera exceção ao
                       adicionar o elemento.
  TreeSet<E>         – Se a comparação retornar igual para dois
                       elementos, e eles não forem iguais, o TreeSet
                       não deixará incluir os dois elementos, será
                       considerado para o Set como elementos
                       duplicados, o que não é permitido, e false será
                       retornado.
                     – Estudem os métodos subSet, tailSet, headSet
Collections
•   Bom chegou a hora, vamos para as classes hash, e portanto
    precisamos explicar pra que serve o código hash e como as classes
    se comportam.
•   Antes de verificar o comportamento de uma coleção hash,
    precisamos ver como as demais se comportam.
    – Sempre que você da um contains(Object o), a coleção começa a
      verificar seus objetos testando uma a um se o.equals(next) ate
      encontrar o objeto, retornando se encontrou ou não.
    – Quando o método usado é remove(Object o), o processo é o mesmo a
      coleção testa equals um a um ate encontrar um objeto igual e o
      remove.
    – Se a coleção for um Set, a cada add(Object o), antes de adicionar a
      coleção verifica se contains(Object o), daí você começa a entender o
      problema e as implicações de ficar percorrendo a coleção tantas vezes
      testando tantos equals.
Collections
• Para resolver esse problema de performance que vai se
  acumulando as coleções hash se usam de outro
  conceito para fazer busca de seus elementos.
• Primeiro vamos revisar duas das propriedades do
  hashCode:
Collections
• Para resolver esse problema de performance que vai se
  acumulando as coleções hash se usam de outro
  conceito para fazer busca de seus elementos.
• Primeiro vamos revisar duas das propriedades do
  hashCode:
Collections
• Para resolver esse problema de performance que vai se
  acumulando as coleções hash se usam de outro
  conceito para fazer busca de seus elementos.
• Primeiro vamos revisar duas das propriedades do
  hashCode:
   – Se dois objetos a e b forem iguais e a.equals(b) for true então
     a.hashCode() == b.hashCode()
   – O inverso não é verdadeiro, quando a.equals(b) for false os
     hashCode() podem ser iguais ou diferentes.
Collections
• Para resolver esse problema de performance que vai se
  acumulando as coleções hash se usam de outro
  conceito para fazer busca de seus elementos.
• Primeiro vamos revisar duas das propriedades do
  hashCode:
   – Se dois objetos a e b forem iguais e a.equals(b) for true então
     a.hashCode() == b.hashCode()
   – O inverso não é verdadeiro, quando a.equals(b) for false os
     hashCode() podem ser iguais ou diferentes.
• As coleções hash se utilizam desses dois conceitos para
  otimizar a pesquisa a seus elementos.
Collections
• Quando você adiciona um elemento a uma coleção hash
  ela verifica o hashCode do objeto, e o coloca em um
  recipiente onde só há objetos com o mesmo hashCode,
  se o recipiente para aquele hashCode ainda não existia
  ela cria um novo.
   – Assim é mantido o processo sempre que se adiciona um objeto.
• Quando você, por exemplo, precisa verificar se um
  objeto existe, as coleções hash tem muito menos
  trabalho para procurar:
   – primeiro elas verificam o código hash do objeto, e olha no
     recipiente daquele código
   – E então verifica um a um, apenas nesse recipiente, através de
     equals() para ver se há algum objeto que coiencidente.
Collections
• Quando você adiciona um elemento a uma coleção hash
  ela verifica o hashCode do objeto, e o coloca em um
  recipiente onde só há objetos com o mesmo hashCode,
  se o recipiente para aquele hashCode ainda não existia
  ela cria um novo.
   – Assim é mantido o processo sempre que se adiciona um objeto.
• Quando você, por exemplo, precisa verificar se um
  objeto existe, as coleções hash tem muito menos
  trabalho para procurar:
   – primeiro elas verificam o código hash do objeto, e olha no
     recipiente daquele código
   – E então verifica um a um, apenas nesse recipiente, através de
     equals() para ver se há algum objeto que coiencidente.
Collections
• Quando você adiciona um elemento a uma coleção hash
  ela verifica o hashCode do objeto, e o coloca em um
  recipiente onde só há objetos com o mesmo hashCode,
  se o recipiente para aquele hashCode ainda não existia
  ela cria um novo.
   – Assim é mantido o processo sempre que se adiciona um objeto.
• Quando você, por exemplo, precisa verificar se um
  objeto existe, as coleções hash tem muito menos
  trabalho para procurar:
   – primeiro elas verificam o código hash do objeto, e olha no
     recipiente daquele código
   – E então verifica um a um, apenas nesse recipiente, através de
     equals() para ver se há algum objeto que coincidente.
Collections
•   Portanto a performance e o funcionamento de uma coleção hash
    esta intimamente ligada ao quão bem implementado é um código
    hash.
•   Para um melhor entendimento vamos criar uma classe Aluno:
    public class Aluno {
      private String nome;
      public Aluno(String nome) { this.nome = nome;}
      public String getNome() { return this.nome;}
      @Override public boolean equals(Object o) {
         if (nome == null) return false;
         return (o instanceof Aluno) && nome.equals(((Aluno)o).nome);
      }
      @Override public int hashCode() { //hashCode vem da 1° letra do nome
         return (nome == null) ? 0 : nome.charAt(0);
      }
    }
Collections
•   Portanto a performance e o funcionamento de uma coleção hash
    esta intimamente ligada ao quão bem implementado é um código
    hash.
•   Para um melhor entendimento vamos criar uma classe Aluno:
    public class Aluno {
      private String nome;
      public Aluno(String nome) { this.nome = nome;}
      public String getNome() { return this.nome;}
      @Override public boolean equals(Object o) {
         if (nome == null) return false;
         return (o instanceof Aluno) && nome.equals(((Aluno)o).nome);
      }
      @Override public int hashCode() { //hashCode vem da 1° letra do nome
         return (nome == null) ? 0 : nome.charAt(0);
      }
    }
Collections
•   Portanto a performance e o funcionamento de uma coleção hash
    esta intimamente ligada ao quão bem implementado é um código
    hash.
•   Para um melhor entendimento vamos criar uma classe Aluno:
    public class Aluno {
      private String nome;
      public Aluno(String nome) { this.nome = nome;}
      public String getNome() { return this.nome;}
      @Override public boolean equals(Object o) {
         if (nome == null) return false;
         return (o instanceof Aluno) && nome.equals(((Aluno)o).nome);
      }
      @Override public int hashCode() { //hashCode vem da 1° letra do nome
         return (nome == null) ? 0 : nome.charAt(0);
      }
    }
Collections
• Como é a divisão em uma coleção Hash?       HashSet
  Set<Aluno> alunos = new HashSet<Aluno>();
Collections
• Como é a divisão em uma coleção Hash?       HashSet
  Set<Aluno> alunos = new HashSet<Aluno>();
  alunos.add(new Aluno(“Marcos”));
                                                77
  alunos.add(new Aluno(“Matheus”));
  alunos.add(new Aluno(“Magno”));
Collections
• Como é a divisão em uma coleção Hash?       HashSet
  Set<Aluno> alunos = new HashSet<Aluno>();
  alunos.add(new Aluno(“Marcos”));
                                                77
  alunos.add(new Aluno(“Matheus”));
  alunos.add(new Aluno(“Magno”));
Collections
• Como é a divisão em uma coleção Hash?       HashSet
  Set<Aluno> alunos = new HashSet<Aluno>();
  alunos.add(new Aluno(“Marcos”));
                                                77
  alunos.add(new Aluno(“Matheus”));
  alunos.add(new Aluno(“Magno”));
  alunos.add(new Aluno(“Antonio”));             66
  alunos.add(new Aluno(“Ana”));
Collections
• Como é a divisão em uma coleção Hash?       HashSet
  Set<Aluno> alunos = new HashSet<Aluno>();
  alunos.add(new Aluno(“Marcos”));
                                                77
  alunos.add(new Aluno(“Matheus”));
  alunos.add(new Aluno(“Magno”));
  alunos.add(new Aluno(“Antonio”));             66
  alunos.add(new Aluno(“Ana”));
  alunos.add(new Aluno(“João”));
                                                74
Collections
•    Como é a divisão em uma coleção Hash?                    HashSet
    Set<Aluno> alunos = new HashSet<Aluno>();
    alunos.add(new Aluno(“Marcos”));
                                                                  77
    alunos.add(new Aluno(“Matheus”));
    alunos.add(new Aluno(“Magno”));
    alunos.add(new Aluno(“Antonio”));
    alunos.add(new Aluno(“Ana”));
                                                                  66
    alunos.add(new Aluno(“João”));

    Como então funciona um:                                       74
       alunos.add(new Aluno(“Abel”)) ?
    1. A coleção busca “Abel”.hashCode() == 66
    2. A coleção busca o conteiner 66
    3. Então verifica todos os elementos testando: “Antonio”.equals(“Abel”);
       “Ana”.equals(“Abel”); o que retorna false,portanto “Abel” é adicionado
Collections
• Quanto melhor implementado é o hashCode() mais
  rápida se torna a busca dentro da coleção hash, por
  exemplo, se mudarmos nossa implementação de
  hashCode() para:
   public class Aluno {
     //...
     @Override
     public int hashCode() { //hashCode vem da 1° letra do nome
        return (nome == null) ? 0 : nome.charAt(0) + nome.size();
     }
   }
Collections                     HashSet

•    Como seria a nova divisão ??          7*77
                                                          539

    alunos.add(new Aluno(“Matheus”));             5*77
                                                          385
    alunos.add(new Aluno(“Magno”));
                                              6*77
    alunos.add(new Aluno(“Marcos”));
    alunos.add(new Aluno(“Antonio”));             7*66
                                                          462
    alunos.add(new Aluno(“Ana”));
    alunos.add(new Aluno(“João”));            3*66        198
                                              4*74
    Como então funciona um:                               296
       alunos.add(new Aluno(“Abel”)) ?
    1. A coleção busca “Abel”.hashCode() == 264
    2. A coleção verifica que não há o conteiner 264
    3. Adicionando “Abel” a um novo conteiner.
Collections
• Como coleções não hash realizam a mesma busca?
   Aluno jo = new Aluno(“Jô”);
   alunos.contains(jo);
   //A coleção alunos iria testar equals contra cada objeto:
      “Matheus”.equals(jo); //false
      “Magno”.equals(jo); //false
      “Marcos”.equals(jo); //false
      “Antonio”.equals(jo); //false
      “Ana”.equals(jo); //false
      “João”.equals(jo); //false
      return false;
• E essa é diferença de performance de uma coleção
  hash para uma normal.
Collections
• Como coleções não hash realizam a mesma busca?
   Aluno abel = new Aluno(“Abel”);
   alunos.contains(abel);
   //A coleção alunos iria testar equals contra cada objeto:
      “Matheus”.equals(abel); //false
      “Magno”.equals(abel); //false
      “Marcos”.equals(abel); //false
      “Antonio”.equals(abel); //false
      “Ana”.equals(abel); //false
      “João”.equals(abel); //false
      return false;
• E essa é diferença de performance de uma coleção
  hash para uma normal.
<<Interface>>
  Collection<E>
                            Collections
  <<Interface>>
     Set<E>        •   HashSet: uma das classes mais utilizadas (e que
                       pode gerar grandes problemas quando hashCode
  HashSet<E>
                       não é bem implementado):
                       – É uma coleção de elementos únicos não ordenada e
                         não classificada.
                       – A cada inserção a ordem dos elementos gerados pelo
LinkedHashSet<E>         iterator pode alterar totalmente.
                       – As buscas são realizadas usando tabelas hash.
                   •   LinkedHashSet: A mudança básica para o
                       HashSet é que a LinkedHashSet mantém
                       armazenada a ordem de inserção.
                       – A cada inserção a ordem dos elementos gerados pelo
                         iterator NÃO é alterada.
                       – É mantida a ordem de inserção.
                       – As buscas são realizadas usando tabelas hash.
Collections
• Finalmente vamos conhecer o funcionamento
  dos java.util.Map<K,V>
• Um Map é uma coleção de pares key-value
  (chave-valor), porem esta não descende de
  Collection<E> tendo uma interface nova.
• Por exemplo:
  – Em um Map<String,Thread> podemos guardar
    instancias de Thread que são identificadas por
    Strings, onde é possivel gerenciar facilmente as
    instancias através de suas chaves.
• Vamos conhecer sua interface
Collections
• Finalmente vamos conhecer o funcionamento
  dos java.util.Map<K,V>
• Um Map é uma coleção de pares key-value
  (chave-valor), porem esta não descende de
  Collection<E> tendo uma interface nova.
• Por exemplo:
  – Em um Map<String,Thread> podemos guardar
    instancias de Thread que são identificadas por
    Strings, onde é possivel gerenciar facilmente as
    instancias através de suas chaves.
• Vamos conhecer sua interface
Collections
• Finalmente vamos conhecer o funcionamento
  dos java.util.Map<K,V>
• Um Map é uma coleção de pares key-value
  (chave-valor), porem esta não descende de
  Collection<E> tendo uma interface nova.
• Por exemplo:
  – Em um Map<String,Thread> podemos guardar
    instancias de Thread que são identificadas por
    Strings, onde é possível gerenciar facilmente as
    instancias através de suas chaves.
• Vamos conhecer sua interface
Collections
• Finalmente vamos conhecer o funcionamento
  dos java.util.Map<K,V>
• Um Map é uma coleção de pares key-value
  (chave-valor), porem esta não descende de
  Collection<E> tendo uma interface nova.
• Por exemplo:
  – Em um Map<String,Thread> podemos guardar
    instancias de Thread que são identificadas por
    Strings, onde é possível gerenciar facilmente as
    instancias através de suas chaves.
• Vamos conhecer sua interface
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()
   V get(Object key)
   boolean containsKey(Object o)
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Insere o valor passado na
   V get(Object key)                 chave indicada, e retorna o
   boolean containsKey(Object o)     antigo valor da chave, ou null
   boolean containsValue(Object o) caso não exista valor anterior.
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()                   Implementação é opcional.
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Copia todos os valores do
   V get(Object key)                 mapa enviando m, para este
   boolean containsKey(Object o)     mapa, nas suas respectivas
   boolean containsValue(Object o) chaves.
   Set<Map.Entry<K, V>> entrySet() É o mesmo que iterar o
   Set<K> keySet()                   entrySet() e adicionar as
   Collection<V> values()            entradas uma a uma.
   int size()
   boolean isEmpty()                 Implementação é opcional.
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Remove, se estiver presente,
   V get(Object key)                 o mapeamento de chave
   boolean containsKey(Object o)     enviada, retornando o valor da
   boolean containsValue(Object o) chave que estava mapeado.
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()                   Implementação é opcional.
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Remove todos as chaves e
   V get(Object key)                 valores mapeados.
   boolean containsKey(Object o)
   boolean containsValue(Object o) Implementação é opcional.
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Recupera o valor para a chave
   V get(Object key)                 enviada.
   boolean containsKey(Object o)
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Verifica se este mapa contém
   V get(Object key)                 uma chave significantemente
   boolean containsKey(Object o)     igual ao objeto enviado.
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Verifica se este mapa contém
   V get(Object key)                 uma valor significantemente
   boolean containsKey(Object o)     igual ao objeto enviado.
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Recupera a coleção Set das
   V get(Object key)                 Entry deste mapa.
   boolean containsKey(Object o)     Entry são Entradas do mapa é
   boolean containsValue(Object o) um objeto que guarda o par
   Set<Map.Entry<K, V>> entrySet() key-value.
   Set<K> keySet()                   Veremos na pagina seguinte
   Collection<V> values()            como funciona essa interface
   int size()                        Entry.
   boolean isEmpty()                 Alterações nesse Set são
                                   refletidas no Map e vice-versa,
                                   muito cuidado ao manipular.
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Recupera um Set contendo
   V get(Object key)                 todas as chaves do Map.
   boolean containsKey(Object o)
   boolean containsValue(Object o) Alterações nesse Set são
   Set<Map.Entry<K, V>> entrySet() refletidas no Map e vice-versa,
   Set<K> keySet()                   muito cuidado ao manipular.
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Recupera uma Collection
   V get(Object key)                 contendo todos os valores
   boolean containsKey(Object o)     deste Map.
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet() Alterações nesse Set são
   Set<K> keySet()                   refletidas no Map e vice-versa,
   Collection<V> values()            muito cuidado ao manipular.
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Informa a quantidade de pares
   V get(Object key)                 key-value existentes neste
   boolean containsKey(Object o)     mapa.
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map<K,V>:
   V put(K key, V value)
   void putAll(Map<? extends K,? extends V> m)
   V remove(Object key)
   void clear()                      Verifica se o Map é vazio
   V get(Object key)                 Método de comodidade, o
   boolean containsKey(Object o)     mesmo que (size() == 0)
   boolean containsValue(Object o)
   Set<Map.Entry<K, V>> entrySet()
   Set<K> keySet()
   Collection<V> values()
   int size()
   boolean isEmpty()
Collections
• Métodos de java.util.Map.Entry<K,V>:
  K getKey()
  V getValue()
  V setValue(V value)
Collections
• Métodos de java.util.Map.Entry<K,V>:
  K getKey()          //recupera a chave desta entrada
  V getValue()
  V setValue(V value)
Collections
• Métodos de java.util.Map.Entry<K,V>:
  K getKey()          //recupera a chave desta entrada
  V getValue()        //recupera o valor desta entrada
  V setValue(V value)
Collections
• Métodos de java.util.Map.Entry<K,V>:
  K getKey()          //recupera a chave desta entrada
  V getValue()        //recupera o valor desta entrada
  V setValue(V value) //altera o valor para esta chave
Collections
• A uma interface em maps que também é
  classificada java.util.SortedMap<K,V>:
  – Esta interface tem exatamente o mesmo funcionamento da
    Coleção SortedSet, porém se aplica a parte de Keys do Map
Collections
• Métodos de java.util.SortedMap<K,V>:
  Comparator<? super K> comparator()
  K firstKey()
  SortedMap<K,V> tailMap(K fromKey)
  K lastKey()
  SortedMap<K,V> headMap(K toKey)
  SortedMap<K,V> subMap(K fromKey, K toKey)
Collections
• Métodos de java.util.SortedMap<K,V>:
  Comparator<? super K> comparator()
  K firstKey()                             Funciona igual
  SortedMap<K,V> tailMap(K fromKey)     SortedSet para o Set
                                          de keys do Map
  K lastKey()
  SortedMap<K,V> headMap(K toKey)
  SortedMap<K,V> subMap(K fromKey, K toKey)
Collections
• Também existe a interface semelhante a
  NavigableSet com mais funcionalidades
  java.util.NavigableMap<K,V>:
  – Esta interface tem exatamente o mesmo
    funcionamento da Coleção NavigableSet,
    porém se aplica a parte de keys do Map
Collections
•   Métodos de java.util.NavigableMap<K,V>:
    K lowerKey(K key)
    Entry<K,V> lowerEntry(E key)
    K floorKey(K e)
    Entry<K,V> floorEntry(E key)                   Funciona igual
    E higherKey(K key)                         NavigableSet para o
    Entry<K,V> higherEntry(K key)               Set de keys do Map
    E ceilingKey(K key)
    Entry<K,V> ceilingEntry(K key)
    Entry<K,V> pollFirstEntry()
    Entry<K,V> pollLastEntry()
    NavigableSet<K> descendingKeySet()
    NavigableMap<K,V> descendingMap()
    NavigableMap<K,V> headMap(K toElement, boolean inclusive)
    NavigableMap<K,V> tailMap(K fromElement, boolean inclusive)
    NavigableMap<K,V> subMap(K from, boolean inc, K to, boolean inc)
Collections
• As classes concretas de Map que cai no
  exame são também muito semelhantes a
  classes concretas Collection que já
  estudamos:
  – Examinamos agora as classes concretas.
Collections
Collections
Collections

         Hashtable e HashMap
        Semelhanças: Não
        ordenadas, não
        classificadas, baseiam
        suas buscas em tabelas
        rash.
        Diferenças: Hashtable tem
        todos os seus métodos
        sincronizados enquanto
        HashMap não!
        é aconselhável o uso do
        HashMap
Collections

           LinkedHashMap
        Semelhanças: não
        classificadas, baseiam
        suas buscas em tabelas
        rash.
        Diferenças: A ordem de
        inserção é levada em
        conta, e a iteração de seus
        entrySet(), keySet() ou
        values() obedecem a
        ordem de inserção.
        Obs.: não é sincronizada.
Collections

      TreeMap

É um Map classificado
onde a ordem dos seus
elementos segue a
ordem de seu
Comparator (se
houver) ou a natural
de seus elementos.
Funciona semelhante
a TreeSet.
Collections
• Vários métodos utilitários podem ser
  encontrados na classe java.util.Collections,
  sim Collections com “s” no fim.
• Esta classe esta munida das principais
  operações que você precisará realizar com
  Coleções, e todos os seus métodos são
  estáticos.
• Sua documentação pode ser encontrada neste
  link:
  – http://java.sun.com/javase/6/docs/api/java/util/Collecti
    ons.html
Collections
• Vários métodos utilitários podem ser
  encontrados na classe java.util.Collections,
  sim Collections com “s” no fim.
• Esta classe esta munida das principais
  operações que você precisará realizar com
  Coleções, e todos os seus métodos são
  estáticos.
• Sua documentação pode ser encontrada neste
  link:
  – http://java.sun.com/javase/6/docs/api/java/util/Collecti
    ons.html
Collections
• Vários métodos utilitários podem ser
  encontrados na classe java.util.Collections,
  sim Collections com “s” no fim.
• Esta classe esta munida das principais
  operações que você precisará realizar com
  Coleções, e todos os seus métodos são
  estáticos.
• Sua documentação pode ser encontrada neste
  link:
  – http://java.sun.com/javase/6/docs/api/java/util/Collecti
    ons.html
Collections
•   Existe mais alguma interface ou classe concreta? Da Java
    Collections Framework ??
    – SIM, existe! Mas essas são todas que são usadas no exame.
•   Onde eu posso encontrar mais informações ?
    – GUJ: http://www.guj.com.br/
    – Sergio Taborda’s Weblog:
      http://sergiotaborda.wordpress.com/java/colecoes-em-java/
    – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/
    – Tutorial da sun:
      http://java.sun.com/docs/books/tutorial/collections/index.html
    – API Specification:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc
      e.html
    – The Java Collection Framework Documentations Contents:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht
      ml
Collections
•   Existe mais alguma interface ou classe concreta? Da Java
    Collections Framework ??
    – SIM, existe! Mas essas são todas que são usadas no exame.
•   Onde eu posso encontrar mais informações ?
    – GUJ: http://www.guj.com.br/
    – Sergio Taborda’s Weblog:
      http://sergiotaborda.wordpress.com/java/colecoes-em-java/
    – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/
    – Tutorial da sun:
      http://java.sun.com/docs/books/tutorial/collections/index.html
    – API Specification:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc
      e.html
    – The Java Collection Framework Documentations Contents:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht
      ml
Collections
•   Existe mais alguma interface ou classe concreta? Da Java
    Collections Framework ??
    – SIM, existe! Mas essas são todas que são usadas no exame.
•   Onde eu posso encontrar mais informações ?
    – GUJ: http://www.guj.com.br/
    – Sergio Taborda’s Weblog:
      http://sergiotaborda.wordpress.com/java/colecoes-em-java/
    – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/
    – Tutorial da sun:
      http://java.sun.com/docs/books/tutorial/collections/index.html
    – API Specification:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc
      e.html
    – The Java Collection Framework Documentations Contents:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht
      ml
Collections
•   Existe mais alguma interface ou classe concreta? Da Java
    Collections Framework ??
    – SIM, existe! Mas essas são todas que são usadas no exame.
•   Onde eu posso encontrar mais informações ?
    – GUJ: http://www.guj.com.br/
    – Sergio Taborda’s Weblog:
      http://sergiotaborda.wordpress.com/java/colecoes-em-java/
    – Tomaz Lavieri’s Blog: http://java-i9se.blogspot.com/
    – Tutorial da sun:
      http://java.sun.com/docs/books/tutorial/collections/index.html
    – API Specification:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/referenc
      e.html
    – The Java Collection Framework Documentations Contents:
      http://java.sun.com/javase/6/docs/technotes/guides/collections/index.ht
      ml
Collections
• Referencias Bibliográficas:
  – API Java 6:
    http://java.sun.com/javase/6/docs/technotes/g
    uides/collections/reference.html
  – Livro: Certificação Sun® Para Programador
    Java 6 – Guia de Estudos – 2° Edição

Java Collections - Tomaz Lavieri

  • 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 finaldesta 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 finaldesta 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 finaldesta 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 finaldesta 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 finaldesta 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.
  • 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 funcionaigualdade em Java ? pessoa1 == pessoa2
  • 24.
    Collections • Como funcionaigualdade em Java ? pessoa1 == pessoa2 • Isso irá testar apenas se as duas variáveis referenciam uma única instancia!
  • 25.
    Collections • Como entãosaber, por exemplo, quando dois objetos Pessoa são significantemente iguais?
  • 26.
    Collections • Como entãosaber, 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ãosaber, 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.
  • 29.
    Collections • Só issoresolve? – Não
  • 30.
    Collections • Só issoresolve? – Não • Por padrão o método equals de Object faz o mesmo que o operador ==
  • 31.
    Collections • Só issoresolve? – 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 sequeremos definir em nosso modelo que dois objetos Pessoa são iguais quando, por exemplo, seus cpf são iguais?
  • 33.
    Collections • Então sequeremos 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 sequeremos 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 sequeremos 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ãobasta simplesmente sobrescrever!
  • 37.
    Collections • Mas nãobasta 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 contratodiz 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 contratodiz 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 contratodiz 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 contratodiz 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 contratodiz 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 paranossa 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 paranossa 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 paranossa 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 paranossa 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 praque serve esse hashCode() ?
  • 51.
    Collections • E praque serve esse hashCode() ? – Calma que assim que chegar em coleções falaremos dele ao estudar HashSet, LinkedHashSet, HashMap, LinkedHashMap e Hashtable
  • 52.
    Collections • E praque 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 praque 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 contratodo 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 contratodo 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 contratodo 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 contratodo 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ãoo 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ãoo 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 nonosso 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 nonosso 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 paranossa 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 paranossa 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 paranossa 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 paranossa 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 aoque interesssa...
  • 68.
    Collections • Java CollectionsFramework (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 CollectionsFramework (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.
  • 71.
    Collections • E eupreciso saber de tudo isso ????
  • 72.
    Collections • E eupreciso saber de tudo isso ???? – SIM!!!!
  • 73.
    Collections • E eupreciso saber de tudo isso ???? – SIM!!!! Para a certificação e para a vida de programador java!
  • 74.
    Collections • E eupreciso 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.
  • 76.
    Collections • Interfaces daJFC • 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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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> extendsIterable<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á! ese eu quiser uma coleção sem deixar que os objetos se repitam ??
  • 100.
    Collections • Tá! ese 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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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íveltambé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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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 ecomo 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 ecomo 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 ecomo 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 ecomo 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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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> extendsCollection<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, masexiste 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, masexiste 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, masexiste 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, masexiste 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 vezesprecisamos 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 vezesprecisamos 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 vezesprecisamos 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 vamoslá! 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 vamoslá! 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 vamoslá! 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> extendsSet<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> extendsSet<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> extendsSet<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> extendsSet<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> extendsSet<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> extendsSet<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> extendsSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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> extendsSortedSet<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 maisinterfaces de Collection ? – Que descendam de Collection? nenhuma que vá cair na prova! Mas é bastante vasta a Java Collection Framework
  • 179.
    Collections • Existem maisinterfaces 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 maisinterfaces 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 resolveresse 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 resolveresse 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 resolveresse 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 resolveresse 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 melhorimplementado é 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çõesnã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çõesnã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 vamosconhecer 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 vamosconhecer 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 vamosconhecer 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 vamosconhecer 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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.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 dejava.util.Map.Entry<K,V>: K getKey() V getValue() V setValue(V value)
  • 224.
    Collections • Métodos dejava.util.Map.Entry<K,V>: K getKey() //recupera a chave desta entrada V getValue() V setValue(V value)
  • 225.
    Collections • Métodos dejava.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 dejava.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 umainterface 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 dejava.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 dejava.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 existea 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 classesconcretas 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.
  • 234.
  • 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étodosutilitá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étodosutilitá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étodosutilitá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