Java - Genéricos

BCC 221 - Programação Orientada a Objectos(POO)

Guillermo Cámara-Chávez

Departamento de Computação - UFOP

Genéricos

I A programação de genéricos nos permite criar modelos

genéricos

I Métodos genéricos especificam em uma única declaração um

conjunto de métodos de relacionados;

I Classes genéricas especificam em uma única declaração um

conjunto de tipos relacionados;

1/120
Métodos Genéricos

I Se as operações realizadas por diversos métodos

sobrecarregados são idênticas para todos os tipos de
argumentos, tais métodos podem ser mais
convenientemente codificados

I Usando um método genérico;

I Uma mesma declaração pode ser invocada com diferentes

parâmetros;

I O compilador trata cada chamada ao método de acordo com

os parâmetros enviados.

I O exemplo a seguir imprime o conteúdo de vetores, não

importando o tipo dos elementos
2/120
Métodos Genéricos (cont.)

I A declaração de métodos genéricos começa com a seção de

parâmetro de tipo, delimitado por < e >

I Antes do tipo de retorno no método;

I Cada seção contém um ou mais parâmetros de tipo, separados

por vı́rgulas.

3/120
Métodos Genéricos (cont.)

I Um parâmetro de tipo especifica o nome de um tipo genérico

I Pode ser utilizado para o tipo de retorno, tipo dos parâmetros

do método e também variáveis locais;

I Age como uma reserva para os tipos verdadeiros

4/120
Métodos Genéricos (cont.)

I O corpo de um método genérico é declarado de forma

semelhante a um método comum;

I Parâmetros de tipo podem somente representar tipos de

referências

I Tipos primitivos como int, double e char não;

I Todo os dados enviados como parâmetros devem ser objetos

de classes ou interfaces

5/120
Métodos Genéricos (cont.)

p u b l i c c l a s s GenericMethodTest {
//metodo generico
public s t a t i c < E > void printArray ( E [ ] inputArray
){
// exibe os elementos do vetor
f o r ( E element : inputArray )
System . o u t . p r i n t f ( " %s " , e l e m e n t ) ;
System . o u t . p r i n t l n ( ) ;
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
// cria vetores dos tipos Integer, Double e Character
Integer [ ] integerArray = {1 ,2 ,3 ,4 ,5 ,6};
Double [ ] d o u b l e A r r a y = { 1 . 1 , 2 . 2 , 3 . 3 , 4 . 4 , 5 . 5 , 6 . 6 } ;
C h a r a c t e r [ ] c h a r a c t e r A r r a y ={’H ’ , ’E ’ , ’L ’ , ’L ’ , ’O ’ } ;

6/120
Métodos Genéricos (cont.)

System . o u t . p r i n t l n ( "\ nintegerArray contains :" ) ;

p r i n t A r r a y ( i n t e g e r A r r a y ) ; // envia um vetor de Integer
System . o u t . p r i n t l n ( "\ ndoubleArray contains :" ) ;
p r i n t A r r a y ( d o u b l e A r r a y ) ; // envia um vetor de Double
System . o u t . p r i n t l n ( "\ ncharacterArray contains :" ) ;
// envia um vetor de Character
printArray ( characterArray ) ;
}
}

7/120
Métodos Genéricos (cont.)

integerArray contains
1 2 3 4 5 6

doubleArray contains
1.1 2.2 3.3 4.4 5.5 6.6

characterArray contains
H E L L O

8/120
Métodos Genéricos (cont.)

I No exemplo, declaramos o parâmetro de tipo E

I Aparece também na lista de parâmetros e no for aprimorado;

I Por padrão, o nome deve ser somente uma letra maiúscula.

I No main, diferentes vetores são passados para o método

genérico

I Inicialmente, o compilador procura uma versão do método

especı́fica para o parâmetro;

I Não encontrando, a versão genérica é utilizada.

9/120
Métodos Genéricos (cont.)

I Quando o compilador traduz o código para bytecode, os

métodos genéricos têm seus argumentos substituı́dos por tipos
de verdade

I Por padrão, o tipo Object é utilizado;

I Diferentemente do que ocorre em C++, em que uma cópia

para cada tipo utilizado é criada.

I A seguir é apresentado o equivalente ao método genérico do

código anterior depois de compilado

10/120
Métodos Genéricos (cont.)

p u b l i c s t a t i c void p r i n t A r r a y ( Object [ ] inputArray )

{
// exibe os elementos do vetor
f o r ( Object element : inputArray )
System . o u t . p r i n t f ( " %s " , e l e m e n t ) ;

System . o u t . p r i n t l n ( ) ;
}

11/120
Métodos Genéricos (cont.)

I Os métodos genéricos podem ser sobrecarregados

I Por outros métodos genéricos;

I Por métodos especı́ficos

I Inclusive tendo os mesmos parâmetros;

I Têm precedência maior em relação ao genérico

12/120
Classes Genéricas

I Os conceitos de estruturas de dados, como uma pilha, são

independentes dos tipos dos elementos que elas manipulam

I Desta forma, podemos criar uma classe que descreva o

comportamento de uma estrutura de dados, de uma maneira
independente

I Ao instanciarmos esta classe genérica, podemos especificar

qual é o tipo desejado;

I Esta capacidade permite um grande avanço na

reusabilidade de código.

I O tratamento dispensado pelo compilador às classes genéricas

é semelhante ao dispensado aos métodos genéricos.
13/120
Classes Genéricas (cont.)

I Estas classes são conhecidas como classes parametrizadas

I Ou tipos parametrizados, uma vez que podem receber um ou

mais parâmetros;

I Tais parâmetros representam apenas tipos de referência

I Ou seja, uma estrutura não poderia ser instanciada com um

tipo primitivo;

I No entanto, podemos utilizar o autoboxing para converter

tipos primitivos em objetos

14/120
Classes Genéricas (cont.)

I Autoboxing consiste em atribuir um tipo primitivo a uma

variável ou estrutura cujo tipo é uma classe empacotadora
(wrapper class)

I A conversão é implı́cita;

I Por exemplo, int para Integer

I O Auto-Unboxing é o processo contrário;

15/120
Classes Genéricas (cont.)

I Em Java há 8 classes empacotadoras

I Byte, Short, Integer, Long, Float, Double, Character e Boolean

I Todos declaradas no pacote [Link]

16/120
Classes Genéricas (cont.)

I O exemplo a seguir apresenta a declaração de uma classe que

descreve uma pilha genérica

I O parâmetro E representa o tipo dos elementos a serem

manipulados pela pilha

I Uma classe genérica pode possuir mais que um parâmetro de

tipo, separados por vı́rgula.

I Este parâmetro é utilizado ao longo do código nos trechos em

que é necessário indicar o tipo dos elementos

17/120
[Link]

p u b l i c c l a s s EmptyStackException extends
RuntimeException {

p u b l i c EmptyStackException () {
t h i s ( " Stack is empty " ) ;
}

p u b l i c E m p t y S t a c k E x c e p t i o n ( S t r i n g msg ) {
s u p e r ( msg ) ;
}
}

18/120
[Link]

public c l a s s FullStackException extends

RuntimeException {

public FullStackException () {
t h i s ( " Stack is full " ) ;
}

p u b l i c F u l l S t a c k E x c e p t i o n ( S t r i n g msg ) {
s u p e r ( msg ) ;
}
}

19/120
[Link]
p u b l i c c l a s s Stack < E >
{
p r i v a t e f i n a l i n t s i z e ; // numero de elementos da pilha
p r i v a t e i n t t o p ; // indice do topo
p r i v a t e E [ ] e l e m e n t s ; // vetor para armazenar os elementos

// o tamanho padrao e 10
p u b l i c Stack ()
{
t h i s ( 10 ) ;
}

// constroi uma pilha com um tamanho especificado

p u b l i c Stack ( i n t s )
{
size = s > 0 ? s : 10;
t o p = −1; // pilha vazia inicialmente

e l e m e n t s = ( E [ ] ) new O b j e c t [ s i z e ] ; // cria o vetor

}
20/120
[Link] (cont.)
p u b l i c v o i d push ( E p u s h V a l u e )
{
i f ( t o p == s i z e − 1 )
t h r o w new F u l l S t a c k E x c e p t i o n ( S t r i n g . f o r m a t ( "
Stack is full , cannot push %s" , p u s h V a l u e
) );

e l e m e n t s [ ++t o p ] = p u s h V a l u e ;
}

p u b l i c E pop ( )
{
i f ( t o p == −1 )
t h r o w new E m p t y S t a c k E x c e p t i o n ( " Stack is empty
, cannot pop " ) ;

r e t u r n e l e m e n t s [ top−− ] ;
}
}
21/120
Classes Genéricas

I O mecanismo dos genéricos em Java não permite que tipos

passados por parâmetro sejam utilizados para a criação de
vetores

I É necessário criar um vetor de Object e realizar um cast;

I Gera um warning “unchecked cast”;

I No entanto, o compilador não pode garantir totalmente que o

vetor nunca conterá objetos de outros tipos que não sejam o
passado como parâmetro.

22/120
Classes Genéricas (cont.)

I O escopo do parâmetro de tipo de uma classe genérica é a

classe inteira

I No entanto, os parâmetros não podem ser utilizados em

declarações do tipo static.

23/120
Classes Genéricas (cont.)

I Vejamos como exemplo uma aplicação que utiliza métodos

genéricos para testar a classe genérica vista anteriormente

I Para os tipos Integer e Double;

I Os métodos que testam os métodos push e pop também

recebem como parâmetro o tipo a ser utilizado nos testes;

I Elementos destes tipos são enviados aos métodos push e

retornados pelo método pop

I Note a utilização de classes adaptadoras.

24/120
[Link]
p u b l i c c l a s s StackTest {
p r i v a t e d o u b l e [ ] d o u b l e E l e m e n t s ={1.1 , 2 . 2 , 3 . 3 , 4 . 4 ,
5.5 , 6.6};
private int [ ] integerElements = { 1 , 2 , 3 , 4 , 5 , 6 ,
7 , 8 , 9 , 1 0 , 11 } ;

p r i v a t e Stack < Double > d o u b l e S t a c k ; // pilha de Double

p r i v a t e Stack < I n t e g e r > i n t e g e r S t a c k ; // pilha de Integer

public void testStacks () {

d o u b l e S t a c k = new Stack < Double >( 5 ) ;
i n t e g e r S t a c k = new Stack < I n t e g e r >( 10 ) ;

t e s t P u s h ( " doubleStack " , d o u b l e S t a c k ,

doubleElements ) ;
t e s t P o p ( " doubleStack " , d o u b l e S t a c k ) ;
t e s t P u s h ( " integerStack " , i n t e g e r S t a c k ,
integerElements ) ;
t e s t P o p ( " integerStack " , i n t e g e r S t a c k ) ;
}
25/120
[Link] (cont.)
// metodo generico que testa o metodo push da classe generica
p u b l i c < T > v o i d t e s t P u s h ( S t r i n g name ,
Stack < T > s t a c k , T [ ] e l e m e n t s ) {
try {
System . o u t . p r i n t f ( "\ nPushing elements onto %s
\n" , name ) ;

f o r ( T element : elements ) {
System . o u t . p r i n t f ( " %s " , e l e m e n t ) ;
s t a c k . push ( e l e m e n t ) ;
}
}
catch ( FullStackException fullStackException )
{
System . o u t . p r i n t l n ( ) ;
fullStackException . printStackTrace () ;
}
}

26/120
[Link] (cont.)
// metodo generico que testa o metodo pop da classe generica
p u b l i c < T > v o i d t e s t P o p ( S t r i n g name , Stack < T >
stack ) {
try {
System . o u t . p r i n t f ( "\ nPopping elements from %s
\n" , name ) ;
T popValue ;

while ( true ) {
p o p V a l u e = s t a c k . pop ( ) ;
System . o u t . p r i n t f ( " %s " , p o p V a l u e ) ;
}
}
catch ( EmptyStackException emptyStackException ) {
System . o u t . p r i n t l n ( ) ;
emptyStackException . printStackTrace () ;
}
}

27/120
[Link] (cont.)

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
S t a c k T e s t a p p l i c a t i o n = new S t a c k T e s t ( ) ;
application . testStacks () ;
}
}

28/120
[Link] (cont.)

Pushing elements onto doubleStack

1.1 2.2 3.3 4.4 5.5 6.6
j a v a s t a c k g e n e r i c o . F u l l S t a c k E x c e p t i o n : Stack i s f u l l ,
c a n n o t push 6 . 6
a t j a v a s t a c k g e n e r i c o . S t a c k . push ( S t a c k . j a v a : 2 0 )
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . testPush (
JavaStackGenerico . java :36)
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . t e s t S t a c k s (
JavaStackGenerico . java :21)
a t j a v a s t a c k g e n e r i c o . J a v a S t a c k G e n e r i c o . main (
JavaStackGenerico . java :69)

29/120
[Link] (cont.)

Popping e l e m e n t s from d o u b l e S t a c k
5.5 4.4 3.3 2.2 1.1
j a v a s t a c k g e n e r i c o . E m p t y S t a c k E x c e p t i o n : S t a c k i s empty ,
c a n n o t pop
a t j a v a s t a c k g e n e r i c o . S t a c k . pop ( S t a c k . j a v a : 2 6 )
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . testPop (
JavaStackGenerico . java :56)
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . t e s t S t a c k s (
JavaStackGenerico . java :22)
a t j a v a s t a c k g e n e r i c o . J a v a S t a c k G e n e r i c o . main (
JavaStackGenerico . java :69)

30/120
[Link] (cont.)

Pushing elements onto i n t e g e r S t a c k

1 2 3 4 5 6 7 8 9 10 11
j a v a s t a c k g e n e r i c o . F u l l S t a c k E x c e p t i o n : Stack i s f u l l ,
c a n n o t push 11
a t j a v a s t a c k g e n e r i c o . S t a c k . push ( S t a c k . j a v a : 2 0 )
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . testPush (
JavaStackGenerico . java :36)
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . t e s t S t a c k s (
JavaStackGenerico . java :23)
a t j a v a s t a c k g e n e r i c o . J a v a S t a c k G e n e r i c o . main (
JavaStackGenerico . java :69)

31/120
[Link] (cont.)

Popping e l e m e n t s from i n t e g e r S t a c k
10 9 8 7 6 5 4 3 2 1
j a v a s t a c k g e n e r i c o . E m p t y S t a c k E x c e p t i o n : S t a c k i s empty ,
c a n n o t pop
a t j a v a s t a c k g e n e r i c o . S t a c k . pop ( S t a c k . j a v a : 2 6 )
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . testPop (
JavaStackGenerico . java :56)
at j a v a s t a c k g e n e r i c o . JavaStackGenerico . t e s t S t a c k s (
JavaStackGenerico . java :24)
a t j a v a s t a c k g e n e r i c o . J a v a S t a c k G e n e r i c o . main (
JavaStackGenerico . java :69)

32/120
Tipos “Crus”

I Os exemplos anteriores instanciavam a classe Stack com tipos

Integer e Double passados por argumento

I Também é possı́vel instanciar uma classe genérica sem

especificar o tipo, como a seguir:
// nenhum tipo especificado
S t a c k o b j e c t S t a c k = new S t a c k ( 5 ) ;

I Neste caso, dizermos que o objeto possui um tipo “cru” (raw

type);

I O compilador utiliza o tipo Object implicitamente, criando

uma pilha para qualquer tipo de elemento;

I Há insegurança quanto ao tipo dos dados armazenados em um

tipo cru
33/120
Tipos “Crus” (cont.)

I Os tipos crus são importante para a compatibilidade das

versões antigas do Java

I É possı́vel atribuir uma estrutura de tipo cru a uma estrutura

que especifique o tipo, como abaixo:
S t a c k r a wT y p eStack2 = new Stack < Double >( 5 ) ;

34/120
Coringas em Métodos Genéricos

I Quando não pudermos determinar a classe especı́fica dos

elementos que serão passados a um genérico, podemos utilizar
um coringa (wildcard)

I Por exemplo, em um método que soma os elementos de um

vetor, podemos não saber se tais elementos serão dos tipos
Integer ou Double
I Podemos então indicar simplesmente que o tipo será o de uma
classe que estende a classe Number

I De fato, Integer e Double são subclasses de Number

I Um parâmetro coringa é indicado por uma ?, como abaixo:

A r r a y L i s t < ? e x t e n d s Number > l i s t

35/120
Coringas em Métodos Genéricos (cont.)

p u b l i c s t a t i c d o u b l e sum ( A r r a y L i s t < ? e x t e n d s
Number > l i s t )
{
double t o t a l = 0;

f o r ( Number e l e m e n t : l i s t )
t o t a l += e l e m e n t . d o u b l e V a l u e ( ) ;

return total ;
}

36/120
Coringas em Métodos Genéricos (cont.)

I Uma desvantagem desta sintaxe é que o sı́mbolo ? não pode

ser utilizado como o nome de um tipo ao longo do método

I Por exemplo, no for aprimorado não podemos substituir

Number por ?

I Uma alternativa é declarar o método como a seguir:

p u b l i c s t a t i c <T e x t e n d s Number> d o u b l e sum (
ArrayList < T > l i s t )

37/120
Genéricos e Herança

I Genéricos podem ser utilizados com herança em diversas

maneiras:

I Uma classe genérica pode ser derivada de uma classe não

genérica;

I Uma classe genérica pode ser derivada a partir de outra;

I Uma classe não genérica pode ser derivada a partir de uma

classe genérica;

I Um método genérico em uma subclasse pode sobrescrever um

método genérico da superclasse, se as assinaturas forem
idênticas.

38/120
Coleções

I Uma coleção é um objeto que mantém referências a outros

objetos

I As interfaces do collections framework declaram operações

que podem ser realizadas genericamente em vários tipos de
coleções

I Pacote [Link]

I Várias implementações destas interfaces são fornecidas pelo

framework

I Podemos também criar nossas próprias implementações.

39/120
Coleções (cont.)

40/120
Classe Arrays

I A classe Arrays fornece métodos estáticos para manipular

vetores

I sort: ordena vetores (sobrecarregado com versões genéricas);

I binarySearch: busca binária (sobrecarregado com versões

genéricas);

I equals: compara vetores de elementos primitivos e objetos da

classe Object;

I fill: preenche o vetor com valores de tipos primitivos e objetos

da classe Object.

41/120
[Link]
import java . u t i l . Arrays ;

public c l a s s UsingArrays {
private int intArray [ ] = { 1 , 2 , 3 , 4 , 5 , 6 };
p r i v a t e double doubleArray [ ] = { 8.4 , 9.3 , 0.2 , 7.9 ,
3.4 };
p r i v a t e i n t f i l l e d I n t A r r a y [ ] , intArrayCopy [ ] ;

public UsingArrays () {
f i l l e d I n t A r r a y = new i n t [ 10 ] ;
i n t A r r a y C o p y = new i n t [ i n t A r r a y . l e n g t h ] ;

A r r a y s . f i l l ( f i l l e d I n t A r r a y , 7 ) ; // preenche com 7s
A r r a y s . s o r t ( d o u b l e A r r a y ) ; // ordena crescentemente

// preenche os vetores
System . a r r a y c o p y ( i n t A r r a y , 0 , i n t A r r a y C o p y , 0 ,
intArray . length ) ;
}
42/120
[Link] (cont.)
public void printArrays () {
System . o u t . p r i n t ( " doubleArray : " ) ;
f o r ( double doubleValue : doubleArray )
System . o u t . p r i n t f ( " %.1f " , d o u b l e V a l u e ) ;

System . o u t . p r i n t ( "\ nintArray : " ) ;

for ( int intValue : intArray )
System . o u t . p r i n t f ( " %d " , i n t V a l u e ) ;

System . o u t . p r i n t ( "\ nfilledIntArray : " ) ;

System . o u t . p r i n t l n ( A r r a y s . t o S t r i n g ( f i l l e d I n t A r r a y
));

System . o u t . p r i n t ( "\ nintArrayCopy : " ) ;

for ( i n t intValue : intArrayCopy )
System . o u t . p r i n t f ( " %d " , i n t V a l u e ) ;

System . o u t . p r i n t l n ( "\n" ) ;
}
43/120
[Link] (cont.)
// pesquisa um valor no vetor
public int searchForInt ( int value )
{
return Arrays . binarySearch ( intArray , value ) ;
}

// compara o conteudo dos vetores

public void printEquality ()
{
boolean b = Arrays . equals ( intArray , intArrayCopy
);
System . o u t . p r i n t f ( " intArray %s intArrayCopy \n" ,
( b ? " == " : " != " ) ) ;

b = Arrays . equals ( intArray , f i l l e d I n t A r r a y ) ;

System . o u t . p r i n t f ( " intArray %s filledIntArray \n" ,
( b ? " == " : " != " ) ) ;
}

44/120
[Link] (cont.)
p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
U s i n g A r r a y s u s i n g A r r a y s = new U s i n g A r r a y s ( ) ;
usingArrays . printArrays () ;
usingArrays . printEquality () ;
int location = usingArrays . searchForInt ( 5 ) ;
i f ( l o c a t i o n >= 0 )
System . o u t . p r i n t f ( " Found 5 at element %d in
intArray \n" , l o c a t i o n ) ;
else
System . o u t . p r i n t l n ( "5 not found in intArray " ) ;

l o c a t i o n = u s i n g A r r a y s . s e a r c h F o r I n t ( 8763 ) ;
i f ( l o c a t i o n >= 0 )
System . o u t . p r i n t f ( " Found 8763 at element %d
in intArray \n" , l o c a t i o n ) ;
else
System . o u t . p r i n t l n ( " 8763 not found in
intArray " ) ;
}
}
45/120
[Link] (cont.)

doubleArray : 0.2 3.4 7.9 8.4 9.3

intArray : 1 2 3 4 5 6
filledIntArray : 7 7 7 7 7 7 7 7 7 7
intArrayCopy : [1 , 2 , 3 , 4 , 5 , 6]

i n t A r r a y == i n t A r r a y C o p y
i n t A r r a y != f i l l e d I n t A r r a y
Found 5 a t e l e m e n t 4 i n i n t A r r a y
8763 n o t f o u n d i n i n t A r r a y

46/120
Interface Collection e Classe Collections

I A interface Collection é a interface-raiz da hierarquia de

todas interfaces de coleções

I Contém operações realizadas em coleções inteiras (bulk

operations)

I Adicionar elementos;

I Esvaziar;

I Comparar.

47/120
Interface Collection e Classe Collections (cont.)

I Também contém operações que retornam iteradores (objetos

Iterator), que nos permitem percorrer uma coleção.

I Comumente utilizada como um tipo de parâmetro nos

métodos para permitir processamento polimórfico

48/120
Interface Collection e Classe Collections (cont.)

I A classe Collections fornece métodos que manipulam

coleções polimorficamente

I Implementam algoritmos para pesquisa e ordenação, entre

outros;

I Também fornece métodos adaptadores

I Permitem que uma coleção seja tratada como sincronizada ou

imutável

49/120
Listas

I A interface é implementada por diversas classes

I Incluindo ArrayList, LinkedList e Vector

I Novamente, ocorre autoboxing quando adicionamos elementos

de tipos primitivos a estas coleções.

50/120
Listas (cont.)

I Arraylists se comportam como os Vectors

I No entanto, não são sincronizados

I Mais rápidos.

I Podem ser utilizados para criar pilhas, filas, árvores e deques

I O Collections Framework fornece algumas implementações

destas estruturas

51/120
ArrayList e Iterator

I O exemplo a seguir demonstra vários recursos da interface

Collection

I O programa insere dois vetores de objetos String em dois

ArrayLists

I Usa iteradores para remover do primeiro ArrayList os

elementos contidos no segundo ArrayList

52/120
ArrayList e Iterator (cont.)
import java . util . List ;
import java . util . ArrayList ;
import java . util . Collection ;
import java . util . Iterator ;

public class CollectionTest {

p r i v a t e s t a t i c f i n a l S t r i n g [ ] c o l o r s = { " MAGENTA " ,
" RED " , " WHITE " , " BLUE " , " CYAN " } ;
p r i v a t e s t a t i c f i n a l S t r i n g [ ] r e m o v e C o l o r s = {" RED " ,
" WHITE " , " BLUE " } ;

// cria um ArrayList, adiciona cores e manipula

public CollectionTest () {
L i s t <S t r i n g > l i s t = new A r r a y L i s t < S t r i n g >() ;
L i s t <S t r i n g > r e m o v e L i s t =new A r r a y L i s t <S t r i n g >() ;

// adiciona elementos a lista

for ( String color : colors )
l i s t . add ( c o l o r ) ;
53/120
ArrayList e Iterator (cont.)
// adiciona elementos a lista
f o r ( String c o l o r : removeColors )
r e m o v e L i s t . add ( c o l o r ) ;

System . o u t . p r i n t l n ( " ArrayList : " ) ;

// exibe o conteudo
f o r ( i n t c o u n t = 0 ; c o u n t < l i s t . s i z e ( ) ; c o u n t++)
System . o u t . p r i n t f ( " %s " , l i s t . g e t ( c o u n t ) ) ;

// remove elementos
removeColors ( l i s t , removeList ) ;

System . o u t . p r i n t l n ( "\n\ nArrayList after calling

removeColors : " ) ;
// exibe o conteudo
for ( String color : l i s t )
System . o u t . p r i n t f ( " %s " , c o l o r ) ;
}

54/120
ArrayList e Iterator (cont.)
// remove elementos especificados em collection2 de collection1
p r i v a t e void removeColors (
Collection < String > collection1 ,
Collection < String > collection2 ) {
// retorna o iterador
Iterator < String > iterator = collection1 .
i t e r a t o r () ;

// percorre a colecao enquanto houverem itens

w h i l e ( i t e r a t o r . hasNext ( ) )
i f ( c o l l e c t i o n 2 . contains ( i t e r a t o r . next () ) )
i t e r a t o r . remove ( ) ; // remove
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
new C o l l e c t i o n T e s t ( ) ;
}
}

55/120
ArrayList e Iterator (cont.)

ArrayList :
MAGENTA RED WHITE BLUE CYAN

ArrayList a f t e r c a l l i n g removeColors :
MAGENTA

56/120
ArrayList e Iterator (cont.)

I Note que ArrayList é uma classe genérica do Java

I Podemos especificar o tipo dos elementos como argumento

I A classe Iterator também é genérica

I O método hasNext determina se há um próximo elemento na

coleção;

I O método next obtém uma referência a este próximo

elemento;

I O método remove apaga o elemento da coleção.

57/120
ArrayList e Iterator (cont.)

I Se uma coleção é alterada por um método próprio depois de

ter sido criado um iterador, o mesmo se torna inválido

I Qualquer operação com o iterador gerará uma

ConcurrentModificationException

58/120
ArrayList e Iterator (cont.)
A r r a y L i s t <S t r i n g > a r r = new A r r a y L i s t <S t r i n g >() ;
I t e r a t o r i t = arr . i t e r a t o r () ;
a r r . add ( " bom " ) ;
a r r . add ( " dia " ) ;
a r r . add ( " hoje " ) ;

w h i l e ( i t . hasNext ( ) ) {
System . o u t . p r i n t l n ( i t . n e x t ( ) ) ;
}

A r r a y L i s t <S t r i n g > a r r = new A r r a y L i s t <S t r i n g >() ;

a r r . add ( " bom " ) ;
a r r . add ( " dia " ) ;
a r r . add ( " hoje " ) ;

I t e r a t o r i t = arr . i t e r a t o r () ;
w h i l e ( i t . hasNext ( ) ) {
System . o u t . p r i n t l n ( i t . n e x t ( ) ) ;
}
59/120
LinkedList

I O exemplo a seguir demonstra operações em LinkedLists

I O programa cria duas LinkedLists que contém Strings;

I Os elementos de uma são adicionados à outra;

I Então todas as Strings são convertidas para letras maiúsculas,

e um intervalo destes elementos é removido.

60/120
LinkedList (cont.)
import java . u t i l . L i s t ;
import java . u t i l . LinkedList ;
import java . u t i l . L i s t I t e r a t o r ;

public class ListTest {

p r i v a t e s t a t i c f i n a l S t r i n g c o l o r s [ ] = { " black " ,
" yellow " , " green " , " blue " , " violet " , " silver " } ;
p r i v a t e s t a t i c f i n a l S t r i n g c o l o r s 2 [ ] = { " gold " ,
" white " , " brown " , " blue " , " gray " , " silver " } ;

// define e manipula objetos LinkedList

public ListTest () {
L i s t < S t r i n g > l i s t 1 =new L i n k e d L i s t < S t r i n g >() ;
L i s t < S t r i n g > l i s t 2 =new L i n k e d L i s t < S t r i n g >() ;

// adiciona elementos
for ( String color : colors )
l i s t 1 . add ( c o l o r ) ;

61/120
LinkedList (cont.)

// adiciona elementos
for ( String color : colors2 )
l i s t 2 . add ( c o l o r ) ;

l i s t 1 . a d d A l l ( l i s t 2 ) ; // concatena as listas
l i s t 2 = n u l l ; // libera
p r i n t L i s t ( l i s t 1 ) ; // exibe os elementos
// converte para maiusculas
convertToUppercaseStrings ( l i s t 1 ) ;
p r i n t L i s t ( l i s t 1 ) ; // exibe os elementos

System . o u t . p r i n t ( "\ nDeleting elements 4 to 7" ) ;

r e m o v e I t e m s ( l i s t 1 , 4 , 7 ) ; // remove os itens 4-7 da lista
p r i n t L i s t ( l i s t 1 ) ; // exibe os elementos
// exibe os elementos na ordem inversa
printReversedList ( list1 ) ;
}

62/120
LinkedList (cont.)

// exibe os elementos da lista

public void p r i n t L i s t ( List < String > l i s t ) {
System . o u t . p r i n t l n ( "\ nlist : " ) ;

for ( String color : l i s t )

System . o u t . p r i n t f ( " %s " , c o l o r ) ;

System . o u t . p r i n t l n ( ) ;
}

63/120
LinkedList (cont.)
// converte para maiusculas
private void convertToUppercaseStrings (
List < String > l i s t ) {
ListIterator < String > iterator =
l i s t . l i s t I t e r a t o r () ;

w h i l e ( i t e r a t o r . hasNext ( ) ) {
S t r i n g c o l o r = i t e r a t o r . n e x t ( ) ; // retorna o item
i t e r a t o r . s e t ( c o l o r . t o U p p e r C a s e ( ) ) ; // converte
}
}

// obtem a sublista e a deleta usando o metodo clear

p r i v a t e void removeItems ( Li st < S t r i n g > l i s t ,
i n t s t a r t , i n t end ) {
l i s t . s u b L i s t ( s t a r t , end ) . c l e a r ( ) ; // remove os
itens
}

64/120
LinkedList (cont.)
// imprime a lista invertida
private void printReversedList ( List < String > l i s t
) {
ListIterator < String > iterator =
l i s t . l i s t I t e r a t o r ( l i s t . size () ) ;

System . o u t . p r i n t l n ( "\ nReversed List :" ) ;

// imprime a lista invertida

while ( i t e r a t o r . hasPrevious () )
System . o u t . p r i n t f ( " %s " , i t e r a t o r . p r e v i o u s ( ) ) ;
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] )
{
new L i s t T e s t ( ) ;
}
}

65/120
LinkedList (cont.)

list :
black yellow green blue v i o l e t s i l v e r g o l d w h i t e brown
blue gray s i l v e r

list :
BLACK YELLOW GREEN BLUE VIOLET SILVER GOLD WHITE BROWN
BLUE GRAY SILVER

D e l e t i n g elements 4 to 7 . . .
list :
BLACK YELLOW GREEN BLUE WHITE BROWN BLUE GRAY SILVER

Reversed L i s t :
SILVER GRAY BLUE BROWN WHITE BLUE GREEN YELLOW BLACK

66/120
LinkedList (cont.)

I O método AddAll adiciona todos os elementos ao final da

lista;

I O método listIterator retorna um iterador bidirecional

I A classe ListIterator é uma classe genérica.

I O método set substitui um elemento da coleção por outro;

67/120
LinkedList (cont.)
I Os iteradores também possuem métodos hasPrevious e
previous

I Determina se há algum elemento anterior e retorna este

elemento, respectivamente.

I Na classe List, o método sublist obtém um intervalo de

valores contidos na lista original

I Os parâmetros são o inı́cio e o final do intervalo, sendo que o

final não está incluı́do entre os valores.

I A classe Arrays fornece o método estático asList que permite

ver um vetor como uma coleção List

I Que encapsula o comportamento similar ao de uma lista

encadeada
68/120
LinkedList (cont.)

I O exemplo a seguir demonstra como criar uma LinkedList a

partir de um vetor visto como uma List

69/120
[Link]

import java . u t i l . LinkedList ;

import java . u t i l . Arrays ;

p u b l i c c l a s s UsingToArray
{
// cria uma LinkedList, adiciona elementos e converte para um vetor
p u b l i c UsingToArray ( )
{
S t r i n g c o l o r s [ ] = { " black " , " blue " , " yellow " } ;

L i n k e d L i s t <S t r i n g > l i n k s =
new L i n k e d L i s t < S t r i n g >( A r r a y s . a s L i s t ( c o l o r s ) )
;

links . a d d L a s t ( " red " ) ; // adiciona o ultimo item

links . add ( " pink " ) ; // adiciona ao final
links . add ( 3 , " green " ) ; // adiciona no indice 3
links . a d d F i r s t ( " cyan " ) ; // adiciona como primeiro item

70/120
[Link] (cont.)
// converte para um vetor
c o l o r s = l i n k s . t o A r r a y ( new S t r i n g [ l i n k s . s i z e ( ) ] ) ;

System . o u t . p r i n t l n ( " colors : " ) ;

for ( String color : colors ){
System . o u t . p r i n t f ( " %s " , c o l o r ) ;
}

System . o u t . p r i n t l n ( "\ nlinks :" ) ;

I t e r a t o r i t = l i n k s . i t e r a t o r () ;
w h i l e ( i t . hasNext ( ) ) {
System . o u t . p r i n t f ( " %s " , i t . n e x t ( ) ) ;
}
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] )
{
new U s i n g T o A r r a y ( ) ;
}
}
71/120
[Link] (cont.)

colors :
cyan b l a c k b l u e y e l l o w green red pink
links
cyan b l a c k b l u e y e l l o w green red pink

72/120
[Link] (cont.)

I Uma vez que obtemos uma List criada pelo método asList
(sem alocar memória), o único método de modificação que
podemos utilizar é o set

I Qualquer outra tentativa de alteração gera

UnsupportedOperationException

I Como criamos uma LinkedList a partir do retorno do método

asList, podemos alterá-la.

L i s t <S t r i n g > l i n k s 2 = A r r a y s . a s L i s t ( c o l o r s ) ;
l i n k s 2 . s e t ( 2 , " gray " ) ;

73/120
[Link] (cont.)

I A partir de uma List também podemos obter um vetor com os

mesmos elementos

I Método toArray

74/120
Vector

I Assim como ArrayLists, os Vectors fornecem uma estrutura

parecida com um vetor

I Pode se redimensionar automaticamente

I Embora o comportamento sejam similares, os Vectors são

sincronizados

I Permitem operações que se valem do paralelismo de

processamento.

I Vários dos métodos dos Vectors são demonstrados no exemplo

a seguir.

75/120
[Link]

import java . u t i l . Vector ;

import j a v a . u t i l . NoSuchElementException ;

p ub l ic c l a s s VectorTest
{
p r i v a t e s t a t i c f i n a l S t r i n g c o l o r s [ ] = { " red " , "
white " , " blue " } ;

p ub l ic VectorTest ()
{
V e c t o r < S t r i n g > v e c t o r = new V e c t o r < S t r i n g >() ;
printVector ( vector ) ;

// adiciona elementos
for ( String color : colors )
v e c t o r . add ( c o l o r ) ;

printVector ( vector ) ;

76/120
[Link] (cont.)

// imprime o primeiro e o ultimo elementos

try {
System . o u t . p r i n t f ( " First element : %s\n" ,
vector . firstElement () ) ;
System . o u t . p r i n t f ( " Last element : %s\n" ,
vector . lastElement () ) ;
}
catch ( NoSuchElementException e x c e p t i o n ) {
exception . printStackTrace () ;
}

// testa se o vetor contem red”

i f ( v e c t o r . c o n t a i n s ( " red " ) )
System . o u t . p r i n t f ( "\n \" red \" found at index %d\n
\n" , v e c t o r . i n d e x O f ( " red " ) ) ;
else
System . o u t . p r i n t l n ( "\n \" red \" not found \n" ) ;

77/120
[Link] (cont.)

v e c t o r . remove ( " red " ) ; // remove a string red”

System . o u t . p r i n t l n ( " \" red \" has been removed " ) ;
p r i n t V e c t o r ( v e c t o r ) ; //

// testa se o vetor contem red”depois da remocao

i f ( v e c t o r . c o n t a i n s ( " red " ) )
System . o u t . p r i n t f ( " \" red \" found at index %d\n
" , v e c t o r . i n d e x O f ( " red " ) ) ;
else
System . o u t . p r i n t l n ( " \" red \" not found " ) ;
System . o u t . p r i n t f ( "\ nSize : %d\ nCapacity : %d\n" ,
vector . size () , vector . capacity () ) ;
}

78/120
[Link] (cont.)
p r i v a t e v o i d p r i n t V e c t o r ( Vector< S t r i n g >
vectorToOutput ) {
i f ( vectorToOutput . isEmpty ( ) )
System . o u t . p r i n t ( " vector is empty " ) ;
e l s e { // itera pelos elementos
System . o u t . p r i n t ( " vector contains : " ) ;
//exibe os elementos
f o r ( S t r i n g element : vectorToOutput )
System . o u t . p r i n t f ( " %s " , e l e m e n t ) ;
}

System . o u t . p r i n t l n ( "\n" ) ;
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
new V e c t o r T e s t ( ) ;
}
}

79/120
[Link] (cont.)

v e c t o r i s empty
vector contains : red white blue

F i r s t element : red
Last element : blue

" red " f o u n d a t i n d e x 0

" red " h a s been removed
vector contains : white blue

" red " n o t f o u n d

Size : 2
C a p a c i t y : 10

80/120
Algoritmos

I O Java Collections Framework fornece vários algoritmos de

alta performance para manipular elementos de uma coleção

I Alguns operam em Lists, outros em Collections

I Todos os algoritmos são polimórficos

81/120
Algoritmos (cont.)

I Alguns algoritmos utilizam um recurso chamado comparador

(comparator)

I Objeto de uma classe que implementa a interface

Comparator, um tipo genérico que recebe um parâmetro

I O método compare deve ser implementado

I Retorna um valor positivo se o primeiro elemento for maior ou

um valor negativo se o primeiro elemento for menor;

I Caso contrário retorna zero.

82/120
Algoritmos (cont.)

83/120
Pilhas

I A classe Stack estende a classe Vector para implementar a

estrutura de dados pilha

I Ocorre autoboxing quando adicionamos um tipo primitivo a

uma Stack

I Só armazena referências a objetos.

I O exemplo a seguir demonstra vários métodos da classe Stack

84/120
Pilhas (cont.)

import java . u t i l . Stack ;

import java . u t i l . EmptyStackException ;

p u b l i c c l a s s StackTest
{
p u b l i c StackTest ()
{
Stack < Number > s t a c k = new Stack < Number >() ;

// cria os numeros a serem armazenados na pilha

Long longNumber = 12L ;
I n t e g e r intNumber = 3 4 5 6 7 ;
Float floatNumber = 1.0F ;
Double doubleNumber = 1 2 3 4 . 5 6 7 8 ;

85/120
Pilhas (cont.)

// usa o metodo push

s t a c k . push ( longNumber ) ;
printStack ( stack ) ;
s t a c k . push ( intNumber ) ;
printStack ( stack ) ;
s t a c k . push ( f l o a t N u m b e r ) ;
printStack ( stack ) ;
s t a c k . push ( doubleNumber ) ;
printStack ( stack ) ;
// remove os itens da pilha

86/120
Pilhas (cont.)

try
{
Number r e m o v e d O b j e c t = n u l l ;

while ( true )
{
r e m o v e d O b j e c t = s t a c k . pop ( ) ;
System . o u t . p r i n t f ( " %s popped \n" ,
removedObject ) ;
printStack ( stack ) ;
}
}
catch ( EmptyStackException emptyStackException )
{
emptyStackException . printStackTrace () ;
}
}

87/120
Pilhas (cont.)
p r i v a t e v o i d p r i n t S t a c k ( Stack < Number > s t a c k ) {
i f ( s t a c k . isEmpty ( ) )
System . o u t . p r i n t ( " stack is empty \n\n" ) ; //
pilha vazia
else {
System . o u t . p r i n t ( " stack contains : " ) ;

// itera atraves dos elementos

f o r ( Number number : s t a c k )
System . o u t . p r i n t f ( " %s " , number ) ;

System . o u t . p r i n t ( "( top ) \n\n" ) ; // indica o topo

da pilha
}
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
new S t a c k T e s t ( ) ;
}
}
88/120
Pilhas (cont.)

s t a c k c o n t a i n s : 12 ( t o p )

s t a c k c o n t a i n s : 12 34567 ( t o p )

s t a c k c o n t a i n s : 12 34567 1 . 0 ( t o p )

s t a c k c o n t a i n s : 12 34567 1 . 0 1 2 3 4 . 5 6 7 8 ( t o p )

1 2 3 4 . 5 6 7 8 popped
s t a c k c o n t a i n s : 12 34567 1 . 0 ( t o p )

1 . 0 popped
s t a c k c o n t a i n s : 12 34567 ( t o p )

89/120
Pilhas (cont.)

34567 popped
s t a c k c o n t a i n s : 12 ( t o p )

12 popped

s t a c k i s empty
java . u t i l . EmptyStackException
at j a v a . u t i l . Stack . peek ( Stack . j a v a : 1 0 2 )
a t j a v a . u t i l . S t a c k . pop ( S t a c k . j a v a : 8 4 )
a t j a v a s t a c k . J a v a S t a c k .< i n i t >( J a v a S t a c k . j a v a : 3 3 )
a t j a v a s t a c k . J a v a S t a c k . main ( J a v a S t a c k . j a v a : 5 5 )

90/120
Filas de Prioridade

I A interface Queue estende Collection e adiciona novos

métodos para inserir, remover e inspecionar elementos de uma
fila

I A classe PriorityQueue implementa esta interface e ordena os

elementos de acordo com o método compareTo (Comparable)
ou um objeto Comparator

I As inserções são ordenadas e as remoções são realizadas no

inı́cio da estrutura

I O primeiro elemento é o de maior prioridade.

91/120
Filas de Prioridade (cont.)

I As operações mais comuns são:

I offer: insere um elemento na posição apropriada de acordo

com sua prioridade;

I poll: remove o elemento de maior prioridade;

I peek: retorna uma referência ao objeto de maior prioridade,

sem removê-lo;

I clear: remove todos os elementos;

I size: retorna o número de elementos.

92/120
[Link]

import java . u t i l . PriorityQueue ;

public class PriorityQueueTest {

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
// fila de capacidade 11
P r i o r i t y Q u e u e < Double > queue = new P r i o r i t y Q u e u e
< Double >() ;

// insere os elementos na fila

queue . o f f e r ( 3 . 2 );
queue . o f f e r ( 9 . 8 );
queue . o f f e r ( 5 . 4 );

93/120
[Link] (cont.)

System . o u t . p r i n t ( " Polling from queue : " ) ;

// exibe os elementos da fila

w h i l e ( queue . s i z e ( ) > 0 )
{
System . o u t . p r i n t f ( " %.1f " , queue . p e e k ( ) ) ; //
exibe o elemento do topo
queue . p o l l ( ) ; // remove o elemento do topo
}
}
}

94/120
[Link] (cont.)

P o l l i n g from queue : 3 . 2 5 . 4 9 . 8

95/120
Conjuntos (Set)

I O Java Collections Framework possui diversas implementações

da interface Set, incluindo

I HashSet: armazena os elementos em uma tabela hash;

I TreeSet: armazena os elementos em uma árvore.

96/120
Conjuntos (Set) (cont.)

I Uma interface interessante que também implementa a

interface Set:

I SortedSet: mantém os elementos ordenados, seja pela ordem

natural dos tipos primitivos, seja pelo uso de comparadores.

I O exemplo a seguir utiliza HashSet para remover Strings

duplicadas de uma List

97/120
[Link]

import java . util . List ;

import java . util . Arrays ;
import java . util . HashSet ;
import java . util . Set ;
import java . util . Collection ;

p u b l i c c l a s s SetTest
{
p r i v a t e s t a t i c f i n a l S t r i n g c o l o r s [ ] = { " red " , "
white " , " blue " , " green " , " gray " , " orange " , " tan "
, " white " , " cyan " , " peach " , " gray " , " orange " } ;

// cria e exibe o ArrayList

p u b l i c SetTest () {
List < String > l i s t = Arrays . a s L i s t ( colors ) ;
System . o u t . p r i n t f ( " ArrayList : %s\n" , l i s t ) ;
printNonDuplicates ( l i s t ) ;
}

98/120
[Link] (cont.)
//cria o conjunto a partir do vetor, para eliminar duplicatas
private void printNonDuplicates ( Collection < String
> collection ) {
// cria o HashSet
Set< S t r i n g > s e t = new HashSet< S t r i n g >(
collection ) ;

System . o u t . p r i n t l n ( "\ nNonduplicates are : " ) ;

for ( String s : set )

System . o u t . p r i n t f ( " %s " , s ) ;

System . o u t . p r i n t l n ( ) ;
}

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
new S e t T e s t ( ) ;
}
}
99/120
[Link] (cont.)

A r r a y L i s t : [ r e d , w h i t e , b l u e , g r e e n , g r a y , o r a n g e , tan ,
w h i t e , cyan , peach , g r a y , o r a n g e ]

Nonduplicates are :
red cyan white tan gray green orange b l u e peach

100/120
Mapas

I Três das várias classes que implementam a interface Map são:

I Hashtable e HashMap: armazenam os elementos em tabelas

hash

I TreeMap: armazenam os elementos em árvores.

101/120
Mapas (cont.)

I Algumas interfaces interessantes que também implementam a

interface Map incluem:

I MultiMap: permite uma coleção de valores para uma mesma

chave;

I SortedMap: mantém os elementos ordenados, seja pela ordem

natural dos tipos primitivos, seja pelo uso de comparadores.

I O exemplo a seguir utiliza HashMap para contar o número de

ocorrências de palavras em uma String

102/120
[Link]

import java . util . StringTokenizer ;

import java . util . Map ;
import java . util . HashMap ;
import java . util . Set ;
import java . util . TreeSet ;
import java . util . Scanner ;

p u b l i c c l a s s WordTypeCount {
p r i v a t e Map< S t r i n g , I n t e g e r > map ;
p r i v a t e Scanner scanner ;

p u b l i c WordTypeCount ( ) {
// cria o HashMap
map = new HashMap< S t r i n g , I n t e g e r >() ;
s c a n n e r = new S c a n n e r ( System . i n ) ;
c r e a t e M a p ( ) ; // cria o mapa baseado na entrada
d i s p l a y M a p ( ) ; // exibe o conteúdo do mapa
}

103/120
[Link] (cont.)

p r i v a t e v o i d createMap ( ) {
System . o u t . p r i n t l n ( " Enter a string :" ) ;
String input = scanner . nextLine () ;

// cria um StringTokenizer para a entrada

S t r i n g T o k e n i z e r t o k e n i z e r = new S t r i n g T o k e n i z e r (
input ) ;

104/120
[Link] (cont.)
// processa o texto da entrada
w h i l e ( t o k e n i z e r . hasMoreTokens ( ) ) // enquanto
houver entrada
{
S t r i n g word = t o k e n i z e r . n e x t T o k e n ( ) .
t o L o w e r C a s e ( ) ; // pega a
palavra

// se o mapa contem a palavra

i f ( map . c o n t a i n s K e y ( word ) ) {
i n t c o u n t = map . g e t ( word ) ; // retorna a
contagem atual
map . p u t ( word , c o u n t + 1 ) ; // incrementa a
contagem
}
else
map . p u t ( word , 1 ) ; // adiciona uma nova palavra
com o contador valendo 1
}
}
105/120
[Link] (cont.)
p r i v a t e void displayMap () {
Set< S t r i n g > k e y s = map . k e y S e t ( ) ; // obtem as chaves

// ordena as chaves
T r e e S e t < S t r i n g > s o r t e d K e y s = new T r e e S e t <
S t r i n g >( k e y s ) ;

System . o u t . p r i n t l n ( " Map contains :\ nKey \t\ tValue "

);

// gera a saı́da para cada chave no mapa

f o r ( S t r i n g key : s o r t e d K e y s )
System . o u t . p r i n t f ( " %-10s %10s\n" , key , map . g e t
( key ) ) ;

System . o u t . p r i n t f ( \ n s i z e : %d\ n i s E m p t y: %b\n" , map .

size () , map . isEmpty () );
}

106/120
[Link] (cont.)

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
new WordTypeCount ( ) ;
}
}

107/120
[Link] (cont.)
E n t e r a s t r i n g : To be o r n o t t o be : t h a t i s t h e
q u e s t i o n Whether ’tis nobler to suffer
Map contains :
Key Value
’tis 1
be 1
be : 1
is 1
nobler 1
not 1
or 1
question 1
suffer 1
that 1
the 1
to 3
whether 1

s i z e :13
isEmpty : f a l s e
108/120
Mapas

I Um StringTokenizer quebra uma string em palavras

individuais

I Determinadas por espaços em branco;

I O método hasMoreTokens determina se ainda há palavras a

serem processadas;

I O método nextToken retorna o token em uma String.

109/120
Mapas (cont.)

I Outros métodos utilizados incluem:

I containsKey: determina se a chave está contida no mapa

I put: cria uma nova entrada chave/valor no mapa;

I get: obtém o valor associado a uma chave;

I keySet: retorna o conjunto de chaves do mapa;

I size: retorna a quantidade de pares chave/valor do mapa;

I isEmpty: retorna true ou false para indicar se o mapa está

vazio

110/120
Exemplo de ordenação

Seja a classe Conta que consta dos atributos codigo e nome. Gerar
uma lista que contenha um conjunto de Contas, ordenar os dados
baseados no código da conta usando a interface Comparable (a
comparação é realizada entre o objeto que chama o método e o
objeto passado como parâmetro)

111/120
Exemplo de ordenação (cont.)

p u b l i c c l a s s Conta i m p l e m e n t s Comparable<Conta> {
p r i v a t e i n t num ;
p r i v a t e S t r i n g nome ;

p u b l i c Conta ( ) {
t h i s ( 0 , "" ) ;
}

p u b l i c Conta ( i n t num , S t r i n g nome ) {

t h i s . num = num ;
t h i s . nome = nome ;
}

112/120
Exemplo de ordenação (cont.)

p u b l i c i n t compareTo ( Conta o ) {
i f ( t h i s . num < o . num )
r e t u r n −1;
i f ( t h i s . num > o . num )
return 1;
return 0;
}

public String toString () {

r e t u r n S t r i n g . f o r m a t ( "\n %d %s" , num , nome ) ;
}

p u b l i c S t r i n g getNome ( ) {
r e t u r n nome ;
}
}

113/120
Exemplo de ordenação (cont.)
import java . util . ArrayList ;
import java . util . Collections ;
import java . util . Comparator ;
import java . util . List ;

p u b l i c c l a s s JAvaOrdena {

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
L i s t <Conta> c o n t a = new A r r a y L i s t <>() ;
Conta o b j = new Conta ( 2 6 6 , " Marco " ) ;
c o n t a . add ( o b j ) ;
Conta o b j 2 = new Conta ( 2 9 , " Pedro " ) ;
c o n t a . add ( o b j 2 ) ;
Conta o b j 3 = new Conta ( 1 0 1 , " Andre " ) ;
c o n t a . add ( o b j 3 ) ;

// ordena por codigo

C o l l e c t i o n s . s o r t ( conta ) ;
f o r ( Conta elem : c o n t a )
System . o u t . p r i n t l n ( elem ) ;
114/120
Exemplo de ordenação (cont.)

// ordena por nome

C o l l e c t i o n s . s o r t ( c o n t a , new Comparator ( ) {
p u b l i c i n t compare ( O b j e c t o1 , O b j e c t o2 ) {
S t r i n g nome1 = ( ( Conta ) o1 ) . getNome ( ) ;
S t r i n g nome2 = ( ( Conta ) o2 ) . getNome ( ) ;
r e t u r n nome1 . compareTo ( nome2 ) ;
}
})
}
}

115/120
Exemplo de ordenação

Seja a classe Conta que consta dos atributos codigo e nome. Gerar
uma lista que contenha um conjunto de Contas, ordenar os dados
baseados no nome usando a interface Comparator (a comparação é
realizada entre dois objetos passados como parâmetro)

116/120
Exemplo de ordenação (cont.)
p u b l i c c l a s s Conta {
p r i v a t e i n t num ;
p r i v a t e S t r i n g nome ;

p u b l i c Conta ( ) {
t h i s ( 0 , "" ) ;
}

p u b l i c Conta ( i n t num , S t r i n g nome ) {

t h i s . num = num ;
t h i s . nome = nome ;
}

public String toString () {

r e t u r n S t r i n g . f o r m a t ( "\n %d %s" , num , nome ) ;
}

p u b l i c S t r i n g getNome ( ) {
r e t u r n nome ;
}
} 117/120
Exemplo de ordenação (cont.)

i m p o r t j a v a . u t i l . Comparator ;

p u b l i c c l a s s SortbyName i m p l e m e n t s Comparator<Conta >{

p u b l i c i n t compare ( Conta a , Conta b ) {
r e t u r n a . getNome ( ) . compareTo ( b . getNome ( ) ) ;
}
}

118/120
Exemplo de ordenação (cont.)
import java . util . ArrayList ;
import java . util . Collections ;
import java . util . Comparator ;
import java . util . List ;

p u b l i c c l a s s JAvaOrdena {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
L i s t <Conta> c o n t a = new A r r a y L i s t <>() ;
Conta o b j = new Conta ( 2 6 6 , " Marco " ) ;
c o n t a . add ( o b j ) ;
Conta o b j 2 = new Conta ( 2 9 , " Pedro " ) ;
c o n t a . add ( o b j 2 ) ;
Conta o b j 3 = new Conta ( 1 0 1 , " Andre " ) ;
c o n t a . add ( o b j 3 ) ;

C o l l e c t i o n s . s o r t ( c o n t a , new SortbyName ( ) ) ;
f o r ( Conta elem : c o n t a )
System . o u t . p r i n t l n ( elem ) ;
}
}
119/120
FIM

120/120