Sejam bem vindos, esta é a décima segunda aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Estamos retornando hoje das férias e continuando a todo vapor com o curso. A partir de hoje fique atento, que as aulas voltarão todas as terças-feiras. O conteúdo de Java está no final, logo iremos começar nossa primeira aplicação Web com JSP.

Hoje iremos aprender alguns conceitos e técnicas para trabalhar com coleções.

Hashing

Hashing é uma maneira de identificar objetos com um número inteiro. Coisas iguais tem (ou deveriam ter) o mesmo número hash. Isso é extremamente útil para realização de comparações mais rápidas.

Em classes escritas por você mesmo, para isso funcionar corretamente, você deve sobrescrever a função .hashCode() e gerar seu próprio número hash.

A função .HashCode()

Esta função deve retornar um número inteiro. É definida na classe java.lang.Object e retorna altomaticamente um valor único para cada instância (para cada objeto).

Se sua classe tem comportamento diferente deste, você deve sobrescrever esta função.

As três premissas da função .HashCode() são:

• O hashCode de um objeto não deve mudar se o valor de um objeto não mudar.
• Dois objetos iguais DEVEM ter o mesmo hashCode
• É desejável que dois objetos diferentes tenham hashCode distintos (sempre que isso for possível)

Exemplos de hashCode:

String scott = "Scotty";
String scott2 = "Scotty";
String corey = "Corey";
System.out.println(scott.hashCode());
System.out.println(scott2.hashCode());
System.out.println(corey.hashCode());  // => -1823897190, -1823897190, 65295514
Integer int1 = 123456789;
Integer int2 = 123456789;
System.out.println(int1.hashCode());
System.out.println(int2.hashCode()); // => 123456789, 123456789

Classe NomeCompleto

Para prosseguir iremos definir uma classe chamada NomeCompleto, que será utilizada nos exemplos do restante da aula:

public class NomeCompleto {
  public String nome;
  public String sobrenome;
  public NomeCompleto(String nome, String sobrenome) {
    this.nome = nome;
    this.sobrenome = sobrenome;
  }
  public String toString() {
    return nome + " " + sobrenome;
  }
  public boolean equals(Object o) {
    return (o instanceof NomeCompleto &&((NomeCompleto) o).nome.equals(this.nome) &&((NomeCompleto) o).sobrenome.equals(this.sobrenome));
  }
}

Vamos verificar se esta classe NomeCompleto está funcionando corretamente:

NomeCompleto maria = new NomeCompleto("Maria", "Lúcia");
NomeCompleto jose = new NomeCompleto("José", "Silva");
NomeCompleto jose2 = new NomeCompleto("José", "Silva");
System.out.println(maria.equals(jose));
System.out.println(jose.equals(jose2));
System.out.println(maria.hashCode());
System.out.println(jose.hashCode());
System.out.println(jose2.hashCode()); // ⇒ false, true, 6718604, 7122755, 14718739

Objetos são iguais, mas o hashCode não é. Precisamos arrumar esta classe.

Você não pretende usar a classe hashCode, portanto não precisa se preocupar com isso não é? ERRADO! Você precisa resolver isso porque irá ter problemas com listas e coleções. As classes que implementam as listas pressupõem que a função hashCode() funciona corretamente.

Aliás, estamos vendo hashCode no início desta aula, justamente para podermos usar listas na continuação, e lembrá-lo que antes de usar listas deve sobrescrever esta função.

O que deve fazer a função hashCode mesmo? Gerar um número inteiro único para objetos com conteúdo iguais, e diferentes para objetos de conteúdo diferente.

Possível implementação para o nosso exemplo:

public class NomeCompleto {
  ...
  public int hashCode() {
    return nome.hashCode() *23 + sobrenome.hashCode();
  }
}

Veja que as classes String já implementam hashCode corretamente. Usamos “*23″ para que José Maria seja diferente de Maria José. Faça testes e verifique que sem a multiplicação o hashCode gerado é o mesmo.

Tenha certeza que entendeu este tópico antes de prosseguir. Funções hashCode não implementadas ou com código errado irão provocar problemas estranhos no uso de coleções. Estes problemas poderão te deixar realmente confuso. Se tiver dúvidas nesta parte pergunte no fórum, ou nos comentários antes de continuar.

Coleções

Coleções são implementações da biblioteca java para executar:

• Coleções de objetos
• Ordenação de objetos
• Estocagem de objetos
• Recuperação e busca de objetos estocados

Para usar Coleções deve-se incluir a importação de java.util.* no topo de cada arquivo *.java:

package lab2;
import java.util.*;
public class UsandoColecoes {
  List<String> lista = new ArrayList<String>();
  ... //resto da classe
}

Sintaxe básica de uma coleção de NomeCompleto:

• Adiciona um nome a lista: boolean add(NomeCompleto o);
• Verifica se um objeto está na lista: boolean contains(Object o);
• Remove um elemento da lista: boolean remove(NomeCompleto o);
• Verifica quantos elementos tem na lista: int size();

Exemplo de uso:

List<NomeCompleto> iapjava = new ArrayList<NomeCompleto>();
iapjava.add(new NomeCompleto("Luis", "Lima");
iapjava.add(new NomeCompleto("José", "Silva");
System.out.println(iapjava.size()); // => 2
iapjava.remove(new NomeCompleto("José", "Silva");
System.out.println(iapjava.size());  // => 1
List<NomeCompleto> iapruby = new ArrayList<NomeCompleto>();
Iapruby.add(new NomeCompleto("Marcos", "Fontes"));
iapjava.addAll(iapruby);
System.out.println(iapjava.size()); // => 2

Coleções Genéricas

É permitido definir uma coleção que só armazene objetos de um determinado tipo como no exemplo acima. Porém também é permitido definirmos coleções genéricas que armazenam objetos de qualquer tipo.
Exemplo de coleções genéricas:

List untyped = new ArrayList();
List<String> typed = new ArrayList<String>();
Object obj = untyped.get(0);
String sillyString = (String) obj;
String smartString = typed.get(0);

As coleções não genéricas ou tipadas são mais práticas de manipular.

Recuperando todos os dados de uma lista:

Dado uma coleção de NomeCompleto chamada “colecaox” podemos usar duas ferramentas para recuperar cada item da coleção: Iterator e For each.

Iterator

Iterator<NomeCompleto> it = colecaox.iterator();
while (it.hasNext) {
        NomeCompleto obj = it.next();
        // Fazer alguma coisa com cada objeto
}

for (NomeCompleto obj : colecaox) {
        // Fazer alguma coisa com cada objeto
}

Excluir objetos da lista enquanto se está recuperando os mesmo:

Não é permitido remover objetos de uma coleção enquanto a mesma está em um laço for-each. Para remover uma lista enquanto se está recuperando é necessário usar o Iterator:

Iterator<NomeCompleto> it = colecaox.iterator();
while (it.hasNext) {
   NomeCompleto obj = it.next();
   it.remove(obj); // Veja que só se remove pelo Iterator não pela coleção: colecaox.remove(Obj);
}

Tipos de Coleção disponíveis:

• Listas:
  • ArrayList;
• Conjunto: (set)
  • HashSet
  • TreeSet
• Mapeamento (map)
  • HashMap

Listas

ArrayList é uma lista de objetos ordenados, similar a um Array, porém sem tamanho pré-definido. A lista é ordenada de acordo com a ordem de inserção.

Definindo e inserindo itens na lista:

List<String> strings = new ArrayList<String>();
strings.add("one");
strings.add("two");
strings.add("three");
// strings = [ "one", "two", "three"]

Inserindo objetos em uma determinada posição

List<String> strings = new ArrayList<String>();
strings.add("one");
strings.add("three");
strings.add(1, "two");
// strings = [ "one", "two", "three"]

Recuperando objetos de uma determinada posição:

s.o.print(strings.get(0))   // => "one"
s.o.print(strings.indexOf("one")) // => 0

Conjuntos (set)

Coleção sem tamanho e sem ordem definida. Não é permitido duplicidade de objetos no conjunto.

Exemplo:

Set<NomeCompleto> nomes = new HashSet<NomeCompleto>();
nomes.add(new NomeCompleto("José", "Silva"));
nomes.add(new NomeCompleto("José", "Silva"));
System.out.println(names.size()); => 1

Regra de ouro para Conjuntos (set):
Um elemento do conjunto não pode mudar se isso poderá afetá-la a ponto de torná-lo igual a um outro objeto do conjunto. (ou a outro objeto a ser inserido no conjunto mesmo após a mudança)

Se não respeitar esta regra, pode se preparar para coisas realmente estranhas. De preferência sempre use objetos imutáveis com conjuntos.

Mapas (map)

Mapas são conjuntos de pares Chave/Valor. Para cada chave o mapa armazena um valor correspondente. Com o valor da chave a coleção map pode recuperar o valor previamente armazenado. Uma chave deve ser única, porém valores podem repetir.

É um serviço muito útil para armazenamento e posterior recuperação de dados com valor chave. Utilíssimo para uso com banco de dados relacionais. Iremos usar isso muito, então não deixe dúvidas a respeito

Mapas não implementam as funções add e contais, em seu lugar temos as seguintes funções:

• boolean put(Foo chave, Bar valor);
• boolean contaisKey(Foo chave);
• boolean contaisvalue(Bar value);

(neste exemplos Foo e Bar são duas classes de qualquer tipo)

Exemplo de uso:

Map<String, String> dns = new HashMap<String, String>();
dns.put("scotty.mit.edu", "18.227.0.87");
System.out.println(dns.get("scotty.mit.edu"));
System.out.println(dns.containsKey("scotty.mit.edu"));
System.out.println(dns.containsValue("18.227.0.87"));
dns.remove("scotty.mit.edu");
System.out.println(dns.containsValue("18.227.0.87"));
// => "18.227.0.87", true, true, false

Outros métodos úteis em mapas (map):

• keySet() – retorna um Set de todos as chaves
• values() – retorna uma Collection de todos os valores (use ArrayList ou Set para armazená-lo)
• entrySet() – returna um Set de pares “chave,valor”. Cada par é um objeto Map.Entry. Map.Entry suporta getKey, getValue, setValue ;

Comparação e Ordenação

Para uso das coleções ordenadas é preciso também definirmos a função compareTo nas classes que definirmos. Esta função é usada para decidir, entre dois objetos, qual é o maior ou se são iguais.

(a.compareTo(b)) deverá resultar em um número menor que zero se a < b, em zero se a = b e, finalmente, em um número maior que zero se a > b .

Exemplos de comparação:

Integer um = 1;
System.out.println(um.compareTo(3));
System.out.println(um.compareTo(-50));
String jose= "José";
System.out.println(jose.compareTo("Ana"));
System.out.println(jose.compareTo("Zé"));
// => -1 , 1, 4, -2

Veja que as classes String e Integer já implementam uma função compareTo corretamente. Nas classes definidas pelo programador esta função deverá ser definida corretamente. Mais a frente iremos definí-la para nosso exemplo NomeCompleto. Por enquanto vamos ver como usar compareTo com listas para ordenar alfabeticamente uma lista:

List<String> nomes = new ArrayList<String>();
nomes.add("Sailor");
nomes.add("Lula");
nomes.add("Bobby");
nomes.add("Santos");
nomes.add("Dell");
Collections.sort(nomes);
// nomes => [ "Bobby", "Dell", "Lula", "Sailor",  "Santos" ]

Interface Comparable

Podemos usar Colletions.sort com a lista acima porque Strings implementam Comparable. Isto é, Strings tem uma ordem natural. Para que uma classe NomeCompleto seja “Comparable”, você deve implementar:

int compareTo(NomeCompleto obj);

Exemplo:

public class NomeCompleto implements Comparable<NomeCompleto> {
  ...
  public int compareTo(NomeCompleto o) {
    int compare = this.sobrenome.compareTo(o.sobrenome)
    if (compare != 0)
      return compare;
      else return this.nome.compareTo(o.nome);
  }
}

Usando a nova classe Comparable NomeCompleto:

List<NomeCompleto> nomes = new ArrayList<NomeCompleto>();
nomes.add(new NomeCompleto("Nicolas", "Cage"));
nomes.add(new NomeCompleto("Laura", "Dern"));
nomes.add(new NomeCompleto("Harry", "Stanton"));
nomes.add(new NomeCompleto("Diane", "Ladd"));
nomes.add(new NomeCompleto("William", "Morgan"));
nomes.add(new NomeCompleto("Dirty", "Glover"));
nomes.add(new NomeCompleto("Johnny", "Cage"));
nomes.add(new NomeCompleto("Metal", "Cage"));
System.out.println(nomes);
Collections.sort(nomes);
System.out.println(nomes);
// => [Johnny Cage, Metal Cage, Nicolas Cage, Laura Dern, Crispin Glover,
// Diane Ladd, William Morgan, Harry Stanton]

Objetos Comparadores (Comparator)

Para criar mais de um método de ordenação você deve definir classes Comparadoras. A classe comparadora simplesmente é uma classe com a implementação da função compateTo entre dois objetos:

int compare(Foo o1, Foo o2);

Exemplo de Comparador, ordenando primeiro nome primeiro:

public class PrimeiroNomePrimeiro implements
    Comparator<NomeCompleto> {
    public int compare(Nome n1, Nome n2) {
      int ret = n1.nome.compareTo(n2.nome);
      if (ret != 0)
        return ret;
        else return n1.sobrenome.compareTo(n2.sobrenome);
    }
}

Isso deverá ser feito em arquivo separado do NomeCompleto.java: PrimeiroNomePrimeiro.java

Para usar o Comparador:

List<NomeCompleto> nomes = new ArrayList<NomeCompleto>();
...
Comparator<NomeCompleto> primeiroNome = new PrimeiroNomePrimeiro();
Collections.sort(nomes, primeiroNome);
System.out.println(nomes);
// => [Crispin Glover, Diane Ladd, Harry Stanton, Johnny
// Cage, Laura Dern, Metal Cage, Nicolas Cage, William
// Morgan]

Outra maneira de ordenar é usando TreeSet. Isso faz a ordenação de maneira automática, sem precisar chamar a função sort. Para funcionar os objetos da TreeSet devem ser “Comparable” ou você deve definir uma classe Comparator.

SortedSet<NomeCompleto> nomes = new TreeSet<NomeCompleto>(new PrimeiroNomePrimeiro());
nomes.add(new NomeCompleto("Laura", "Dern"));
nomes.add(new NomeCompleto("Harry", "Stanton"));
nomes.add(new NomeCompleto("Diane", "Ladd"));
System.out.println(nomes);
// => [Diane Ladd, Harry Stanton, Laura Dern]

Aprofundando

Procurar e estudar na documentação do java as classes apresentadas nesta aula: (veja java.util.*) em http://java.sun.com/j2se/1.5.0/docs/api

Durante os próximos estudos de java é essencial manter este endereço aberto em uma janela do navegador, de modo a tirar dúvidas a respeito do funcionamento de alguma classe java.

Na Seqüência

• dia 29 de janeiro: Exceções e outros truques

Dúvidas? vá para o fórum.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.