Trabalhando com a Interface Set no Java

Veja neste artigo, as características, o mecanismo dos códigos da interface Set e das suas implementações HashSet, LinkedHashSet e TreeSet.

por Thiago Varallo Palmeira

A Interface Set

Considerada uma interface que faz parte do pacote “java.util” e representa grupos de elementos sem duplicatas, ou seja, são usados quando o programador não precisar ter nenhum dado duplicado na coleção. Segue abaixo na Figura 1 a hierarquia da interface Set.

Figura 1. Hierarquia da interface Set.

Características - Set

• Velocidade na pesquisa de dados, sendo mais rápida que um objeto do tipo List;
• A inserção de dados é mais lenta;
• Permite trabalhar com conjuntos e pode ser implementado como instâncias das classes HashSet ou TreeSet;
• Não precisa especificar a posição para adicionar um elemento;
• Não aceita valores duplicados. Se caso inserir um registro que já tenha no Set não será adicionado.
• Podem ser implementados como instâncias das classes HashSet ou TreeSet;

Declaração - Set

Quando está construindo objetos na classe Set é necessário informar que tipo de coleção será implementada.

Sintaxe: Set set = new Type();

E - é o objeto declarado, podendo ser classes Wrappers ou tipo de coleção.

Type - é o tipo de objeto da coleção a ser usado;

No caso da Listagem 2, é usado a classe HashSet que informa o mesmo tipo de objeto “Cliente” atribuído na interface Set. Então, para realizar alguns testes, será necessário criar a classe Cliente destacada na Listagem 1.

Listagem 1:Classe Cliente.

public class Cliente {	
	private String nome;
	private String endereco;
	private String fone;
	private static int count;
	
	public Cliente(String nome, String endereco, String fone) {
		super();
		this.nome = nome;
		this.endereco = endereco;
		this.fone = fone;
	}

	public String getEndereco() {
		return endereco;
	}

	public void setEndereco(String endereco) {
		this.endereco = endereco;
	}

	public String getFone() {
		return fone;
	}

	public void setFone(String fone) {
		this.fone = fone;
	}

	public String getNome() {
		return nome;
	}
	
	public void setNome(String nome) {
		this.nome = nome;
	}
	
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((endereco == null) ? 0 : endereco.hashCode());
		result = prime * result + ((fone == null) ? 0 : fone.hashCode());
		result = prime * result + ((nome == null) ? 0 : nome.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Cliente other = (Cliente) obj;
		if (endereco == null) {
			if (other.endereco != null)
				return false;
		} else if (!endereco.equals(other.endereco))
			return false;
		if (fone == null) {
			if (other.fone != null)
				return false;
		} else if (!fone.equals(other.fone))
			return false;
		if (nome == null) {
			if (other.nome != null)
				return false;
		} else if (!nome.equals(other.nome))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Cliente "+ ++count + ": " +nome + " | " + "Endereço: "+endereco + " | " + "Fone: "+fone;
	}
}

Na Listagem 2 é mostrado como imprimir dados a partir do objeto Cliente.

Listagem 2. Impressão de registros não duplicados do objeto Cliente.

import java.util.HashSet;
import java.util.Set;

public class TestesSet {
	public static void main(String[] args) {
		Set<String> colecaoSet = new HashSet<String>();
		colecaoSet.add("Site");
		colecaoSet.add("Varallos");
		colecaoSet.add("Fóruns Varallos");
		
		//dados duplicados não são inseridos no Set
		colecaoSet.add("Varallos");
		colecaoSet.add("Site");

		System.out.println("Tamanho coleção Set: "+colecaoSet.size());
		int count = 0;
		for(String valor : colecaoSet){
			System.out.println(++count + " -> " + valor);
		}
	}
}

Os métodos da interface Set podem ser encontrados no link abaixo: Metodos interface set.

Classe HashSet

Classe que faz parte do pacote “java.util” e que é uma implementação da interface Set onde utiliza uma tabela hash, por isso do nome da classe.

Características do HashSet

• Não tem ordenação na varredura ou impressão. A ordem de saída não é a mesma de entrada;
• Aceitam valores do tipo null;
• Não é sincronizada (thread-safe);
• Velocidade no acesso, leitura e modificação de dados;

Declaração - HashSet

Na classe HashSet para construir objetos é a mesma ideia da interface Set, precisa informar que tipo de coleção será implementada.

Sintaxe: HashSet<E> set = new Type<E>();

• E - é o objeto declarado, podendo ser classes Wrappers ou tipo de coleção.
• Type - é o tipo de objeto da coleção a ser usado;

Na Listagem 3, está sendo adicionado, comparado e exibido valores através do HashSet. Nesse caso, para varrer os dados e realizar a impressão está sendo utilizado o Iterator, sendo a mesma forma de acesso do “for aprimorado” utilizado no exemplo da interface Set.

Listagem 3. Trabalhando com a classe HashSet.

import java.util.HashSet;
import java.util.Iterator;

public class TestesHashSet {

	public static void main(String[] args) {
		HashSet<Cliente> hsc = new HashSet<Cliente>();
		hsc.add(new Cliente("João Delfino","Rua da Várzea","3232-1232"));
		hsc.add(new Cliente("Maria Tijuca","Av. Brasil","8569-99988"));
		hsc.add(new Cliente("Pedro de Lara","Rua 20 de março","7568-8524"));
		
		Cliente clienteJoao = new Cliente("João Delfino","Rua da Várzea","3232-1232");
		if(hsc.contains(clienteJoao)){
			System.out.println("Existe o cliente João Delfino");
		}
		
		System.out.println("Tamanho coleção HashSet: "+hsc.size());
		
		//Percorrendo o HashSet<Cliente> e imprimindo os valores
		Iterator<Cliente> it = hsc.iterator();
		while(it.hasNext()){
			Cliente valorCliente = (Cliente)it.next();
			System.out.println(valorCliente);
		}
	}
}

Os métodos da interface HashSet podem ser encontrados no link oficial.

Classe TreeSet

Essa classe fornece objetos de coleção de ordenação natural e faz parte da implementação da interface Set e está localizada dentro do pacote “java.util”.

Características

• Os elementos inseridos dentro desse tipo de conjunto devem implementar a interface Comparable;
• A ordenação é por elementos únicos;
• Não suporta objetos nulos, se caso um elemento ser nulo é lançado a exceção NullPointerException;

Declaração - TreeSet

Nessa classe para construir objetos é a mesma ideia da interface Set, precisa informar que tipo de coleção será implementada.

Sintaxe: Set<E> set = new TreeSet<E>();

E - é o objeto declarado, podendo ser classes Wrappers ou tipo de coleção.

Os métodos da interface TreeSet podem ser encontrados no link oficial.

Listagem 4. Ordenação de registros do tipo String.

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class TesteTreeSet {
	public static void main(String[] args) {
		
		Set<String> cursos = new HashSet<String>();
		cursos.add("PHP");
		cursos.add("Java");
		cursos.add("PL/SQL");
		cursos.add("Adobe");
		cursos.add("PHP");
		
		Set<String> ord = new TreeSet<String>(cursos);
		
		System.out.println("Sem ordenação: "+cursos);
		System.out.println("Com ordenação: "+ord);
	}
}

Na Listagem 5, é mostrado a ordenação através do objeto Cliente. Nesse caso específico, quando trabalhado com objetos precisa ser implementado a interface “Comparable” para realizar a ordenação com o objeto TreeSet, pois é configurado o conjunto de objetos como parâmetro do construtor.

Listagem 5. Ordenação de registros com o objeto Cliente.

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TesteTreeSet {
	public static void main(String[] args) {
		Set<Cliente> hsc = new HashSet<Cliente>();
		hsc.add(new Cliente("Pedro de Lara","Rua 20 de março","7568-8524"));
		hsc.add(new Cliente("João Delfino","Rua da Várzea","3232-1232"));
		hsc.add(new Cliente("Maria Tijuca","Av. Brasil","8569-99988"));

		
		Set<Cliente> ordena = new TreeSet<Cliente>(hsc);
		Iterator<Cliente> it = ordena.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}
}

Conclusão

A interface Set e suas classes que a implementam ajudam a facilitar alguns problemas enfrentados pelos programadores em casos de ordenação e desempenho de listas. Pelo fato, de que muitas vezes é necessário realizar uma ordenação específica para tal necessidade, sendo que essa interface oferece muitas opções quando se trata disso para coleções de dados.