Conjuntos (postagem 2 de 2)
Autor: Gustavo | Publicado: 2015-03-27T10:05:00-03:00


Utilizando
os Conjuntos




&nbsp; &nbsp; &nbsp;A
postagem de
hoje é
para dar continuidade a postagem de segunda-feira sobre conjuntos
vai
ser possovelmente minha maior postagem até o momento neste blog mas
a idéia
é mostrar todas
as classes apresentadas no post anterior em exemplos de código
para
aprendemos
melhor
o que até
então se
encontra na
teoria. 


&nbsp; &nbsp; &nbsp;Comecarei sendo breve mostrando
diferenças entre array e arrayList,  algumas alterações que
ocorreram entre a linguagem java 4 e 5 que afetaram na declaração
de conjuntos que é a utilização de genéricos em uma declaração
de lista.

&nbsp; &nbsp; &nbsp;Falarei sobre formas de se
classificar uma lista usando a classe Collections para
conjuntos primitivos e as
interfaces Comparable
e Comparator que
serão usadas na classificação personalizada
de objetos.

&nbsp; &nbsp; &nbsp;Conversões
entre Array e Listas será
outro assinto abordado pela necessidade de utilizar
várias formas de conjuntos
com as interfaces
List, Sets, Map e Queue. Finalizando com um pequeno comparativo entre
elas.

&nbsp; &nbsp; &nbsp;Espero que gostem do post e que possa
trazer algum aprendizado a vocês como pra mim. Colocarei no final o
link do gitHub como sempre para caso alguem queira baixar os códigos.




Fundamentos
de Arraylist




&nbsp; &nbsp; &nbsp;O
ArrayList e o array oferecem funcionalidades e facilidades muito
similares por serem um objeto que possui como finalidade armazenar
vários outros objetos. Apesar de suas familiaridades, elas possuem
difereças que devem ser distacadas como o crescimento dinâmico da
Arraylist e vários métodos que facilitam seu manuseio como
adicionar, remover, editar e buscar um elemento o que não é
oferecido pelo Array.

&nbsp; &nbsp; &nbsp;Com
a chegada da versão cinco do java, foi acrescido os
genéricos que disponibilizado
uma nova  forma de declaração
de um conjunto.
Os genéricos facilitaram
bastante ao desenvolvedor quanto a segurança de seus conjuntos
na aplicação e
veremos isso adiante.Antes
de tudo, vamos ver como era antes
da versão java 5 a
declaração
de um arrayList:




ArrayList
listaDeStrings
= new
ArrayList();




&nbsp; &nbsp; &nbsp;Não
é fácil sabermos do que é esta lista correto? Pode ser uma lista
de mil coisas diferentes como texto, inteiros, objetos... Agora
vejamos a nova forma:




ArrayList&lt;String&gt;
listaDeStrings
= new
ArrayList&lt;String&gt;();




&nbsp; &nbsp; &nbsp;Gostou?
Legal né? Veja que
podemos identificar o
que esta lista terá em seu conteudo. Mais fácil concorda? É claro
que estas alterações feitas em java 5, não impactam em todos os
códigos já desenvolvidos antes
em outras versões. Ainda é
possível trabalharmos da forma antiga e o máximo que irá ocorrer
em caso de você utilizar a forma antiga de se codificar em um
ambiente de java 5 ou posterior
é uma mensagem de atenção
ao compilar seu código. Mesmo assim ele irá compilar e gerará o
arquivo &lt;NomeDaClasse&gt;.class sem
sustos como previsto.
As alterações
na declaração de um conjunto, nos
deixa mais
tranquilos qunato a boxing de
variáveis pois isto será feito automaticamente uma vez que o
compilador já sabe o que a lista contém.

Exemplos:




		List&lt;Integer&gt;
nums
= new
ArrayList&lt;Integer&gt;(); //versao5

		nums.add(5);//versao5

		List
numsV4
= new
ArrayList();//declarando
na versao4

		numsV4.add(new
Integer(4));//versao4

		System.out.println(nums);//OK

		System.out.println(numsV4);//??




Saida:

[5]

[4]




&nbsp; &nbsp; &nbsp;Vale
ressaltar que na linha onde adicionamos o valor 4 ao array numsV4  é
uma simulação que deverá ser adicionado quando um elemento
utilizando a versão 4 do java for acrescido a uma lista. Pois se
utilizamos o compilador java 1.5 em diante, não será problema
nenhum colocarmos somente o algorismo 4.




Classificando
Conjuntos




&nbsp; &nbsp; &nbsp;É
comum sempre que formos trabalharmos com conjuntos, necessitarmos
clasificacar de alguma forma
nossos conjuntos como
alfabética, numérica dentre outras.
Quando armazenamos valores primitivos em conjuntos, no nosso caso
ArrayList, é bem simples
realizar esta classificação conforme
abaixo:




		List&lt;String&gt;
placesToSurf
= new
ArrayList&lt;String&gt;();

		placesToSurf.add("Fernando
de Noronha");

		placesToSurf.add("Lima");

		placesToSurf.add("Piura");

		placesToSurf.add("Punta
Hermosa");

		placesToSurf.add("Punta
Rocas");

		placesToSurf.add("Senhoritas");

		placesToSurf.add("Caballeros");

		placesToSurf.add("La
Isla");

		System.out.println(placesToSurf);

		Collections.sort(placesToSurf);

		System.out.println(placesToSurf);




Saida:

[Fernando
de Noronha, Lima, Piura, Punta Hermosa, Punta Rocas, Senhoritas,
Caballeros, La Isla]

[Caballeros,
Fernando de Noronha, La Isla, Lima, Piura, Punta Hermosa, Punta
Rocas, Senhoritas]




	Podemos
ver logo na primeira linha que declaramos o array usando genéricos,
que nada mais é que colocando entre os espacos, &lt; (menor que) e &gt;
(maior que) o tipo dos elementos que que serão armazendos na lista.
Ao inserirmos todos os elemenos, imprimimos a lista e vemos que ela
se encontra totalmente fora da ordem alfabética. 	Utilizamos a
classe Collections
que possui várias utilidades dentre
elas o método sort( ),
para realizar este trabalho
pra gente. Imprimirmos
mais uma vez nossa lista para
 constatar
a nova da nossa lista.




Interface
Comparable




&nbsp; &nbsp; &nbsp;Já
sabemos que em caso de um conjunto de texto ou numerais (valores
primitivos), poderemos usar as utilidades de Collections mas e se
quisermos classificar uma lista de objetos? Vamos supor que queremos
constuir uma aplicação onde temos cadastros de  campeonatos e
necessitaremos classificar uma lista de surfistas em ordem
alfabética.&nbsp;&nbsp; &nbsp; &nbsp;Vamos por parte então e definir como seria a classe
Surfista.java




public
class
Surfista {




	String
nome;

	String
apelido;

	int
idade;

	int
id;

	public
Surfista() {	}

	public
Surfista(String nome,
String apelido,
int
idade,
int
id)
{

		setId(id);

		setApelido(apelido);

		setIdade(idade);

		setNome(nome);

	}




	//getters
e  setters,
construtores...
abaixo




&nbsp; &nbsp; &nbsp;Criamos
a classe surfista e dois construtores para facilitar a nossa
instanciação e  ainda o método mockSurfistas() que
retorna uma lista de surfistas para facilitar nosso desenvolvimento
de agora em diante.




public
static
List&lt;Surfista&gt; mockSurfistas() {

	List&lt;Surfista&gt;
toReturn
= new
ArrayList&lt;Surfista&gt;();

		toReturn.add(new
Surfista("Gabriel
Medina",
"Medina",
19, 1));

		toReturn.add(new
Surfista("Miguel
Pupo",
"Dropador",
21, 2));

		toReturn.add(new
Surfista("Adriano
Souza",
"Rasgador",
26, 3));

		toReturn.add(new
Surfista("Raone
Monteiro",
"Monteiro",
30, 4));

		toReturn.add(new
Surfista("Alejo
Muniz",
"novato",
23, 5));

		toReturn.add(new
Surfista("Felipe
Toledo",
"cacula",
18, 6));

	return
toReturn;

}




&nbsp; &nbsp; &nbsp;Agora
pensamos que está tudo muito bom, tudo muito bem e decidimos ordenar
nossa lista de surfista da seguinte forma abaixo:




		List&lt;Surfista&gt;
surfistas =
new
ArrayList&lt;Surfista&gt;();

		surfistas
= Surfista.mockSurfistas();//
carrega listas
de
surfistas

		System.out.println(surfistas);//
imprime listas
de
surfistas

		Collections.sort(surfistas);//
tenta ordenar listas
de
surfistas

		System.out.println(surfistas);//
imprime listas
de
surfistas







Executamos
e nos deparamos com o seguinte erro:




Exception
in thread "main" java.lang.Error: Unresolved compilation
problems: 


	Bound
mismatch: The generic method sort(List&lt;T&gt;) of type Collections
is not applicable for the arguments (List&lt;Surfista&gt;). The
inferred type Surfista is not a valid substitute for the bounded
parameter &lt;T extends Comparable&lt;? super T&gt;&gt;

	The
method sort(List&lt;T&gt;, Comparator&lt;? super T&gt;) in the type
Collections is not applicable for the arguments (List&lt;Surfista&gt;,
Surfista)




	at
br.com.blog.gmachado1.genericos.TestandoArrayList.main(TestandoArrayList.java:48)




&nbsp; &nbsp; &nbsp;Se
estivermos usando uma IDE (eclipse, NetBeans...) já será possivel
ver o erro antes mesmo de tentarmos rodar a aplicação e
não é preciso ser um gênio para saber o que pode ser. Como
estamos definindo
acima qual atributo de surfista será pego para ser ordenado?

&nbsp; É
aí que entra a classe Comparable. &lt;o/ 


&nbsp; &nbsp; &nbsp;Vimos
no primeiro exemplo de classificação, que o método sort()
da classe Collections é
sobrecarregado e algumas
das várias formas
é da seguinte forma sort(List&lt;T&gt; list):void - 
Collecions.

&nbsp; &nbsp; &nbsp;Então
os mais aflitos perguntariam
se é preciso
criar uma lista de Comparable passar
os valores da lista atual para a lista comparable e depois ordena-la
para voltar a lista de ArrauList? É
por aí, mas gracas a OO tudo fica mais simples. Uma vez que
sabemos que uma classe que implementa uma interface, entra no
relacionamento É-UM, se pegarmos nossa classe Surfista e
implementarmos a interface Comparable, já
podemos dizer que estamos nos referindo a uma lista de Comparable
correto?  Por
sua vez, esta classe possui o
método compareTo(SuaClasse t) que
deverá ser implementado e
tudo estará solucionado.

&nbsp; &nbsp; &nbsp;O
método implementado retorna sempre um inteiro onde::





	Se
	&lt;instanciaA&gt; for menor que &lt;instanciaB&gt;, retornará um
	inteiro negativo;


	Se
	&lt;instanciaA&gt; for maior que &lt;instanciaB&gt;, retornará um
	inteiro positivo;


	Se
	&lt;instanciaA&gt; for igual &lt;instanciaB&gt;, retornará zero;






&nbsp; &nbsp; &nbsp;Pegamos
nossa classe Surfista e a alteramos na seguinte forma:




public
class
Surfista implements
Comparable&lt;Surfista&gt;{




	String
nome;

	String
apelido;

	int
idade;

	int
id;

//getters
e  setters abaixo

	public
Surfista(String nome,
String apelido,
int
idade,
int
id)
{

		setId(id);

		setApelido(apelido);

		setIdade(idade);

		setNome(nome);

	}

	public
Surfista() {}




	@Override
//para
o compilador
saber que
esta
sobrecarregando
Boas
práticas

	public
int
compareTo(Surfista o)
{

		return
nome.compareTo(o.getNome());

	}




&nbsp; &nbsp; &nbsp;Agora
ao executarmos o caso acima nos deparamos com as seguintes saidas:




[br.com.blog.gmachado1.model.Surfista@4d8,br.com.blog.gmachado1.model.Surfista@4f7,
br.com.blog.gmachado1.model.Surfista@5d0,br.com.blog.gmachado1.model.Surfista@66b,
br.com.blog.gmachado1.model.Surfista@4f7,
br.com.blog.gmachado1.model.Surfista@49a]




[br.com.blog.gmachado1.model.Surfista@5d0,
br.com.blog.gmachado1.model.Surfista@4f7,
br.com.blog.gmachado1.model.Surfista@49a,
br.com.blog.gmachado1.model.Surfista@4d8,
br.com.blog.gmachado1.model.Surfista@4f7,
br.com.blog.gmachado1.model.Surfista@66b]




	Entendeu
alguma coisa? Caso não tenha idéia do que aconteceru basta
ler meu post sobre 
sobrescrevendo
o modo toString() para
entender melhor. Caso adicione conforme
abaixo nossa classe Surfista:

	public
String toString() {

		return
"Surfista
[nome="
+ nome
+ "
, apelido="
+ apelido+
",
										idade="
+ idade
+ "]";

	}




Resultado
da saida será:




[Surfista
[nome=Gabriel Medina , apelido=Medina, idade=19], Surfista
[nome=Miguel Pupo , apelido=Dropador, idade=21], Surfista
[nome=Adriano Souza , apelido=Rasgador, idade=26], Surfista
[nome=Raone Monteiro , apelido=Monteiro, idade=30], Surfista
[nome=Alejo Muniz , apelido=novato, idade=23], Surfista [nome=Felipe
Toledo , apelido=cacula, idade=18]]




[Surfista
[nome=Adriano Souza , apelido=Rasgador, idade=26], Surfista
[nome=Alejo Muniz , apelido=novato, idade=23], Surfista [nome=Felipe
Toledo , apelido=cacula, idade=18], Surfista [nome=Gabriel Medina ,
apelido=Medina, idade=19], Surfista [nome=Miguel Pupo ,
apelido=Dropador, idade=21], Surfista [nome=Raone Monteiro ,
apelido=Monteiro, idade=30]]




Pronto,
temos nossa lista ordenada por nome :-) 





Interface
Comparator




&nbsp; &nbsp; &nbsp;Assim
como Comparable, esta interface possui um método a ser
implementado quando a interface for definida junto a definição da
classe. Se desejar é possível inclusive Implementar as duas
interfaces na mesma classe e utilizar implementações diferentes
afim de oferecer duas formas de classificação diferente. Seu método
a ser implementado no entanto é o compare(), muito semelhante
ao outro não é mesmo? Acredito que muitos acabam se confundindo..

&nbsp; &nbsp; &nbsp;Uma
vez que já implementamos a classificação por nome da nossa lista,
iremos implementar uma classificação por apelido para que fique um
pouco diferente do anterior, quanto ao comportamento do método
compare() é exatamente igual ao da interfaces Comparable
onde o retorno em caso de
igualdade entre os elementos é
zero, quando o primeiro elemento for maior que
o segundo o retorno é um
inteiro positivo e quando o segundo
elemento for maior que o primeiro,
seu retorno é negativo.

Vamos
falar um pouquinho de código?

&nbsp; &nbsp; &nbsp;A
implementação da interface Comparator ficaria da seguinte forma na
nossa classe Surfista:




public
class
Surfista implements
Comparator&lt;Surfista&gt;{




	String
nome;

	String
apelido;

	int
idade;

	int
id;




	@Override

	public
int
compare(Surfista o1,
Surfista o2)
{

		return
o1.getApelido().compareTo(o2.getApelido());

	}

//getters
e  setters toString
equals : abaixo






Quanto
a nossa classe que realiza a chamada ao método compare( )
faria o seguinte procedimento:




		List&lt;Surfista&gt;
surfistas
= new
ArrayList&lt;Surfista&gt;();

		surfistas
= Surfista.mockSurfistas();//
carrega
listas
de
surfistas



		System.out.println(surfistas);//
listas
sem
classificacao

		Surfista
s3
= new
Surfista();

		Collections.sort(surfistas,
s3);//classificaca

		System.out.println(surfistas);//
listas
com
classificacao




Saida:

[Surfista
[nome=Gabriel Medina , apelido=Medina, idade=19], Surfista
[nome=Miguel Pupo , apelido=Dropador, idade=21], Surfista
[nome=Adriano Souza , apelido=Rasgador, idade=26], Surfista
[nome=Raone Monteiro , apelido=Monteiro, idade=30], Surfista
[nome=Alejo Muniz , apelido=novato, idade=23], Surfista [nome=Felipe
Toledo , apelido=cacula, idade=18]]




[Surfista
[nome=Miguel Pupo , apelido=Dropador, idade=21], Surfista
[nome=Gabriel Medina , apelido=Medina, idade=19], Surfista
[nome=Raone Monteiro , apelido=Monteiro, idade=30], Surfista
[nome=Adriano Souza , apelido=Rasgador, idade=26], Surfista
[nome=Felipe Toledo , apelido=cacula, idade=18], Surfista [nome=Alejo
Muniz , apelido=novato, idade=23]]




Observações
em uma Classificação




&nbsp; &nbsp; &nbsp;Finalizaremos
aqui a parte de classificação fazendo algumas observações que
podem ser básicas mas muitas vezes não prestamos atenção então
sempre vale a atenção:





	Classificar
	um array de objetos funciona da mesma forma que classificar conjunto
	de objetos. O método Arrays.sort() é sobrescrito da mesma forma
	que o método Collections.sort().


	Os
	métodos Arrays.sort() que classificam tipos primitivos sempre o
	fazem com base na ordem natural.


	Os
	metodos sort() de Arrays e Collection são estáticos, não é
	necessário que instancie os mesmos para a utilização do método.


	Ambos
	os métodos sort() de Arrays e Collections alteram o objeto e suas
	referências, classificando-as ao contrário que muitos podem pensar
	que elas retornam uma lista já classificada.


	Só
	é possível classificar objetos que são mutualmente
	classificáveis. Não temos como classificar por exemplo uma lista
	de objetos onde se encontra objetos do tipo Surfista com outro
	objeto como Campeonato que não possa classifica-lo mutuamente.









Buscas
em Conjuntos e Arrays




&nbsp; &nbsp; &nbsp;Tanto
a classe Arrays quanto a classe Collections possuem o método de
busca binarySearch() para que possamos encontrar um elemento
em nossa lista ou conjunto.

	Antes
de realizar a busca binária, sempre será necessário classificar a
lista para depois realizar a buscar por um elemento, caso contrário
suas buscas poderão não ser confiáveis, existe 2 formas diferente
de realizar a classificação em de uma lista. 	Classificação pela
ordem natural crescente e numérica ou alfabética, onde só é
necessário passar a lista como parâmentro, ou utilizando a classe
Comparator ou Comparable, conforme já foi demonstrando
anteriormente sobrescrecendo os métodos  compareTo() e
compare().&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp; &nbsp;Realizando desta outra forma, a
classificação da busca deverá receber como parâmetro não só a
lista como a classe que a classificou para efetuar a busca na mesma
forma que a classificação da lista. Isto porque o método
binarySearch() sempre irá retornar um numeral inteiro
relativo a sua posição na lista.

	Em
caso do método binarySearch() não encontrar na lista o
elemento a ser encontrado, fará com que retorne um valor negativo e
inteiro, este valor é como se fosse o  valor relativo a sua posição
na lista.

Exemplo:




		int
[] listIt
= {2,1,6,5,4};

		Arrays.sort(listIt);//classificado
ordem crescrescente




&nbsp; &nbsp; &nbsp;Realizar
uma busca pelo algarismo 3, terá o retorno de -3 que seria sua
posição caso este item estivesse na lista.




System.out.println(Arrays.binarySearch(listIt,3));//lista
e o algarismo 3




Saida:

-3

	

Aqui
faremos um outro exemplo com texto




public
class
BinarySearch {




	public
static
void
main(String args[]){

		//criando
uma lista
manobras
em formato texto

		String
[] manobras
= {"Snaking","Cutback","Pump",

								"Floater","Re-entry"};

		//classifica
em ordem alfabética

		Arrays.sort(manobras);

		//imprime
cada uma 


		for(String
s:manobras)

			System.out.print(s+"
- ");

		//busca
pela manobra 'CutBack'

		System.out.println("\nmanobras1:CutBack
=

					
"+Arrays.binarySearch(manobras,
"Cutback"));

		System.out.println("ordem
decrescente");

		//Intencia
classe que utiliza Comparator que elabora uma 


		//CLASSIFICACAO
em ordem decrescente

		DescSorcComparator
dsc=new
DescSorcComparator();

		//classifica
em ordem decrescente

		Arrays.sort(manobras,dsc);

		//imprime
em ordem decrescente

		for(String
s:manobras)

			System.out.print(s+"
- ");

		//busca
a manobra 'Cutback' como se fosse uma lista 


		//
classificada em ordem crescente

		System.out.println("\nmanobras2:CutBack"

					+Arrays.binarySearch(manobras,
"Cutback"));

		//busca
a manobra 'Cutback' como se fosse uma lista 


		//
classificada em ordem decrescente

		System.out.println("manobras3:CutBack
"

					+Arrays.binarySearch(manobras,
"Cutback",dsc));

	}

	static
class
DescSorcComparator implements
Comparator&lt;String&gt;{




		@Override

		public
int
compare(String o1,
String o2)
{

			return
o2.compareTo(o1);

		}

		

	}

}




Saida:

Cutback
- Floater - Pump - Re-entry - Snaking - 


manobras1:CutBack
= 0

ordem
decrescente

Snaking
- Re-entry - Pump - Floater - Cutback - 


manobras2:CutBack-1

manobras3:CutBack
 4

##################
 LISTS

tamanho
: 5

indice
3: Floater

Snaking
- Shoulder - Pump - Aéreo - Cutback - 


indice
1: Shoulder




Converções
entre listas




&nbsp; &nbsp; &nbsp;Por
haverem várias formas de se armazenar alementos em diferentes listas
disponiveis pelas APIs Java, sempre é bom conhecermos formas fáceis,
práticas e confiáveis para realizar a converção entre tipos de
lista diferentes é aí que entra o método Arrays.asList(String[]
array). Este método permite que ao passa um array como
parâmentro lhe retorna uma lista do tipo List, o inverso
também ocorre como podemos ver usando a classe List seu método
.toArray(List list) passando uma lista como parâmetro List e
converte em array.




		//criando
uma array
list

		String
[] manobras
= {"Snaking","Cutback","Pump",

								"Floater","Re-entry"};

		//converte
em List		

		List
lista
= Arrays.asList(manobras);

		System.out.println("tamanho
: "+lista.size());

		System.out.println("indice
3: "+lista.get(3));

		//altera
o elemento de indice 3 na List

		lista.set(3,"Aéreo");

		//altera
o elemento de indice 1 no array

		manobras[1]="Shoulder";

		//imprime
o array

		for(String
s:manobras)

			System.out.print(s+
"
- ");

		//imprime
o indice 1 de
List

		System.out.println("\nindice
1: "+lista.get(1));




Saida:

tamanho
: 5

indice
3: Floater

Snaking
- Shoulder - Pump - Aéreo - Cutback - 


indice
1: Shoulder




Itarator




&nbsp; &nbsp; &nbsp;Com
as novas versões do Java, houve uma facilidade na criação de novas
iterações com os loops, for, do e while. Mas apesar de estar cada
vez mais escasso, é possível encontrar em alguns códigos terações
com listas utllizando a class Iterator.

&nbsp; &nbsp; &nbsp;Se
observarmos, tanto ArrayList, List, LisnkedList,  entre outras
possuem um método iterator()
que faz retornar um objeto com valores da lista e possuindo vários
métodos que facilitam na iteração entre elementos conforme
mostramos no exemplo abaixo:




	public
int
calculaSoma(List
lista)
{

		Iterator
it
= lista.iterator();

		int
toReturn
= 0;

		while(it.hasNext()){

			int
i
= ((Integer)it.next()).intValue();

			toReturn
+=i;

		}

		return
toReturn;

	}




Utilizando
Sets

	



&nbsp; &nbsp; &nbsp;Sempre
que formos trabalhar com uma lista onde
você não pretende
obter elementos repetidos,
deve considerar
as listas que implementem a
interface Set. Isto porque antes de realizar a inserção de um
elemento em sua lista, todas
as listas que implementam esta interface, percorer
os
métodos
dos elementos hasCode()
e  o método equals()
e caso valide que o elemento
esteja repetido,
o mesmo não
irá ser adicionado.

&nbsp; &nbsp; &nbsp;Tanto
TreeSet, HashSet e LinkedHashSet possuem esta particularidade
por terem o relacionamento É-Um com
Set. Logo
qualquer uma destas listas possuem a mesma característica quanto a
verificação de um elemento antes de ser adicionado e
todas devem ter seus métodos equals e hashCode bem elaborados.
Entretanto, nem tudo são flores, a utilização destas
listas para adicionar uma
carga de muitos elementos
poderá ser custosa quanto
ao processamento entretando pode ser
muito mais rápido em uma busca (levando em consideração que seu
código hashcode é eficiente) .

&nbsp; &nbsp; &nbsp;Vejamos
abaixo um exemplo de código de uma das listas que implementa Sets




		boolean[]
ba
= new
boolean[5];//
boolean array de
5 elementos




		Set&lt;Surfista&gt;
s
= new
HashSet&lt;Surfista&gt;();

		ba[0]
= s.add(Surfista.mockSurfistas().get(0));

		ba[1]
= s.add(Surfista.mockSurfistas().get(1));

		ba[2]
= s.add(Surfista.mockSurfistas().get(0));//repetindo

		ba[3]
= s.add(Surfista.mockSurfistas().get(3));

		ba[4]
= s.add(Surfista.mockSurfistas().get(4));

		

		for(int
i=0;i&lt;ba.length;i++){

			System.out.println(ba[i]);

		}

		for(Object
o:s){

			System.out.println(o);

		}

		System.out.println("#############
TREE SET");

		

		Set&lt;Surfista&gt;
t
= new
TreeSet&lt;Surfista&gt;();

		ba[0]
= t.add(Surfista.mockSurfistas().get(0));

		ba[1]
= t.add(Surfista.mockSurfistas().get(1));

		ba[2]
= t.add(Surfista.mockSurfistas().get(0));//repetindo

		ba[3]
= t.add(Surfista.mockSurfistas().get(3));

		ba[4]
= t.add(Surfista.mockSurfistas().get(4));

		

		for(int
i=0;i&lt;ba.length;i++){

			System.out.println(ba[i]);

		}

		for(Object
o:t){

			System.out.println(o);

		}

		public
static
List&lt;Surfista&gt; mockSurfistas() {

		List&lt;Surfista&gt;
toReturn
= new
ArrayList&lt;Surfista&gt;();

		toReturn.add(new
Surfista("Gabriel
Medina",
"Medina",
19, 1));

		toReturn.add(new
Surfista("Miguel
Pupo",
"Dropador",
21, 2));

		toReturn.add(new
Surfista("Adriano
Souza",
"Rasgador",
26, 3));

		toReturn.add(new
Surfista("Raone
Monteiro",
"Monteiro",
30, 4));

		toReturn.add(new
Surfista("Alejo
Muniz",
"novato",
23, 5));

		toReturn.add(new
Surfista("Felipe
Toledo",
"cacula",
18, 6));

		return
toReturn;

		}




Saida:

true

true

false

true

true

Surfista
[nome=Alejo Muniz , apelido=novato, idade=23]

Surfista
[nome=Raone Monteiro , apelido=Monteiro, idade=30]

Surfista
[nome=Miguel Pupo , apelido=Dropador, idade=21]

Surfista
[nome=Gabriel Medina , apelido=Medina, idade=19]

#############
TREE SET

true

true

false

true

true

Surfista
[nome=Alejo Muniz , apelido=novato, idade=23]

Surfista
[nome=Gabriel Medina , apelido=Medina, idade=19]

Surfista
[nome=Miguel Pupo , apelido=Dropador, idade=21]

Surfista
[nome=Raone Monteiro , apelido=Monteiro, idade=30]







&nbsp; &nbsp; &nbsp;Vale
lembrar que a ordem pode não coincidir conforme ocorreu no nosso
exemplo, isto porque HashSet nem TreeSet que foram as classe
utilizadas por aqui não obedecem uma ordenação padrão. 


&nbsp; &nbsp; &nbsp;Outra
observação que devemos salientar é quanto a lista booleana onde
vemos que em ambos os casos possue um item que possui valor falso por
não ter sido inserido na lista.




Utilizando
Map




&nbsp; &nbsp; &nbsp;O
comportamento das listas que imeplementam a interface Map são bem
diferentes das que vimos até então. Elas possuem uma mistura com o
que vimos anteriormente, onde cria a necessidade de codificar seus
métodos hashCode( ) e equals( ) sobrescritos para
tirar proveito das informações da lista e seus elementos caso
contrário não terá muita utilidade mas elas mapeiam suas
entidades criando um identificador e o elemento...

&nbsp; &nbsp; &nbsp;Tudo
fica mais fácil demonstrando e é o que farei abaixo com este
exemplo declarando uma lista de Maps, veremos que ao adicionar cada
um dos elementos, realizamos buscas por cada elemento, imprimindo
seus dados, mas o último elemento “Hauli” que é da classe
declarada logo abaixo onde não possui o método equals( ) e
hashCode( ) não é encontrada, demonstrando que o
elemento retorna null por ficar perdido dentro da lista.




class
Hauli {}




public
class
ClasseTeste{

	public
static
void
main(String
ar[]){




		Map&lt;Object,Object&gt;
ml
= new
HashMap&lt;Object,Object&gt;();




		ml.put("t1",
new
Surfista("Gustavo
Machado","Gus",32,2));

		ml.put("t2",
Thread.MAX_PRIORITY);

		ml.put(Thread.MIN_PRIORITY,
"Prioridade
minima");

		Surfista
s
= Surfista.mockSurfistas().get(0);

		ml.put(s,
"Medina");

		ml.put(3,
"numeral
3");

		ml.put(new
Hauli(), "Hauli");//classe
sem equals e hasCode

		

		System.out.println(ml.get("t1"));

		String
t2
= "t2";//teste2

		System.out.println(ml.get(t2));

		int
t=1;//Thread.MIN_PRIORITY

		System.out.println(ml.get(t));

		System.out.println(ml.get(Thread.MIN_PRIORITY));

		System.out.println(ml.get(s));

		System.out.println(ml.size());

		System.out.println(ml.get(new
Hauli()));//NULL




	}

}







		Saida:




		Surfista
[nome=Gustavo Machado , apelido=Gus, idade=32]

		10

		Prioridade
minima

		Prioridade
minima

		Medina

		6

		null




&nbsp; &nbsp; &nbsp;Outro
caso que vale ser observado em uma lista de Map também, é colocar
uma enumeração (Enum) como chave do elemento. Aqui funcionou
mas por motivos dos métodos equals( ) e hashCode( ) serem
sobrescritos nos enums, pode não ser seguro defini-los como chave.




Utilizando
Priority Queue




&nbsp; &nbsp; &nbsp;Esta
classe que é a mais diferene de todas as outras, entrou como
funcionalidade a partir da versão java 1.5. Ela tem sua ordenação
e prioridade padrão baseada na “ordem natural” de entrada no
Heap mas nada impede que você utilze a classe Comparator para
realizar uma classificação personalizada.

&nbsp; &nbsp; &nbsp;Uma
diferença bem peculiar que encontramos ao utlizarmos esta classe é
a presenca de métodos diferentes tais como peek( ) , poll( ) e
offer( ) só encontrados nesta classe. O primeiro
retorna o elemento com prioridade mais alta na fila sem o remover, já
o segundo retorna o elemento com prioridade
alta removendo-o da fila já o último método serve para
colocar o elementos no fila.




public
class
TestandoPriorityQueue {




	public
static
void
main(String args[])
{

		int[]
ia
= { 1, 5, 4, 9, 2, 6, 7, 0 };

		PriorityQueue&lt;Integer&gt;
pqi
= new
PriorityQueue&lt;Integer&gt;();




		for
(int
i
: ia)

			pqi.offer(i);

		for
(int
x
: ia)

			System.out.print(pqi.poll()
+ "
");

		System.out.println();

		PQsort
pqs
= new
PQsort();

		PriorityQueue&lt;Integer&gt;
pqi2
= new
PriorityQueue&lt;Integer&gt;(10, pqs);

		for
(int
i
: ia)

			pqi2.offer(i);

		System.out.println("tamanho
: "
+ pqi2.size());

		System.out.println("peek
: "
+ pqi2.peek());

		System.out.println("tamanho
: "
+ pqi2.size());

		System.out.println("poll
: "
+ pqi2.poll());//remove
da
lista

		System.out.println("tamanho
: "
+ pqi2.size());

		for
(int
i
: ia)
{

			System.out.print(":
"
+ pqi2.poll());

		}

		

		

		

		System.out.println("\ncom
Strings");

		

		String[]
sa
= { "&gt;g&lt;",
"&gt;
g&lt;",
"&gt;g
&lt;",
"&gt;G&lt;","&gt;GG&lt;"
 };

		PriorityQueue&lt;String&gt;
pqS
= new
PriorityQueue&lt;String&gt;();




		for
(String i
:sa
)

			pqS.offer(i);

		for
(String x
: sa)

			System.out.print(pqS.poll()
+ "
");

		System.out.println();

		PQ.PQsortString
pqSort
= new
PQsortString();

		PriorityQueue&lt;String&gt;
pqs2
= new
PriorityQueue&lt;String&gt;(10, pqSort);

		for
(String i
: sa)

			pqs2.offer(i);

		System.out.println("tamanho
: "
+ pqs2.size());

		System.out.println("peek
: "
+ pqs2.peek());

		System.out.println("tamanho
: "
+ pqi2.size());

		System.out.println("poll
: "
+ pqs2.poll());//remove
da
lista

		System.out.println("tamanho
: "
+ pqs2.size());

		for
(String i
: sa)
{

			System.out.print(":
"
+ pqs2.poll());

		}




	}




}




class
PQ {

	static
class
PQsort implements
Comparator&lt;Integer&gt; {

		public
int
compare(Integer o1,
Integer o2)
{

			return
o2
- o1;

		}

	}

	static
class
PQsortString implements
Comparator&lt;String&gt; {

		public
int
compare(String o1,
String o2)
{

			return
o2.compareTo(o1);

		}

	}

}



 


Saida:

0
1 2 4 5 6 7 9 


tamanho
: 8

peek
: 9

tamanho
: 8

poll
: 9

tamanho
: 7

:
7: 6: 5: 4: 2: 1: 0: null





Git=
https://github.com/gmachado1/blog/tree/branche1/GenericosEConjuntos