FramFramework Collection - Java.free.Orgework Collection - Java.free.Org

8/19/2019 FramFramework Collection - Java.free.Orgework Collection - Java.free.Org

1/14

O Collections Framework

"Desde a versão 1.2 do JDK (depois que o renomearam para Java 2 SDK), a plataforma J2SEinclui um frameor! de cole#es (a $ollections %rameor!). &ma coleão ' um oeto querepresenta um *rupo de oetos. &m frameor! de cole#es ' uma arquitetura unificada pararepresentaão e manipulaão de cole#es, permitindo que elas seam manipuladasindependentemente dos detal+es de sua implementaão.

s principais vanta*ens do collections frameor! são-

/eduão do esforo de pro*ramaão, fornecendo estruturas de dados e al*oritmos 0teis, para quenão sea necessrio reescrevlos.

umento da performance, fornecendo implementa#es de alta performance. $omo as vriasimplementa#es de cada interface são sustitu3veis, os pro*ramas podem ser facilmente refinadostrocandose as implementa#es.

4nteroperailidade entre 54s não relacionadas, estaelecendo uma lin*ua*em comum para passa*em de cole#es.

/eduão do esforo de aprendi6ado de 54s, eliminando a necessidade de se aprender vrias54s de cole#es diferentes.

/eduão do esforo de proetar e implementar 54s, eliminando a necessidade de se criar 54s decole#es pr7prias.

5romover o re0so de softare, fornecendo uma interface padrão para cole#es e al*oritmos paramanipullos.

8 $ollections %rameor! consiste em-

4nterfaces de cole#es representam diferentes tipos de coleão, como conuntos, listas e arra9sassociativos. Estas interfaces formam a ase do frameor!.

4mplementaão de uso *eral implementa#es sicas das interfaces de cole#es.

4mplementa#es le*adas as classes de cole#es de vers#es anteriores, :ector e ;as+tale, foramremodeladas para implementar as interfaces de cole#es (mantendo a compatiilidade).

4mplementa#es de rappers adicionam funcionalidades, como sincroni6aão, a outrasimplementa#es.

4mplementa#es convenientes "miniimplementa#es" de alta performance das interfaces decole#es.

4mplementa#es astratas implementa#es parciais das interfaces de cole#es, para facilitar acriaão de implementa#es personali6adas.

l*oritmos m'todos estticos que performam fun#es 0teis sore cole#es, como a ordenaão

de uma lista.


2/14

&tilitrios de rra9s fun#es utilitrias para arra9s de primitivas e oetos. Estritamentefalando, não pertence ao $ollections %rameor!, por'm, esta funcionalidadefoi adicionada <

plataforma Java ao mesmo tempo, e utili6a parte da mesma infraestrutura." (traduão livre de umtrec+o da documentaão do JDK )

Coleções

Collection

4nterface ase para todos os tipos de coleão. Ela define as opera#es mais sicas para cole#es deoetos, como adião (add) e remoão (remove) astratos (sem informa#es quanto < ordenaão doselementos), esva6iamento (clear), taman+o (si6e), conversão para arra9 (torra9), oeto de iteraão(iterator), e verifica#es de e=istncia (contains e isEmpt9).

List

4nterface que e=tende $ollection, e que define cole#es ordenadas (sequncias), onde se tem o controletotal sore a posião de cada elemento, identificado por um 3ndice num'rico. >a maioria dos casos, podeser encarado como um "arra9 de taman+o varivel" pois, como os arra9s primitivos, ' acess3vel por3ndices, mas al'm disso possui m'todos de inserão e remoão.

ArrayList

4mplementaão de ?ist que utili6a internamente um arra9 de oetos. Em uma inserão onde otaman+o do arra9 interno não ' suficiente, um novo arra9 ' alocado (de taman+o i*ual a 1.@ ve6eso arra9 ori*inal), e todo o conte0do ' copiado para o novo arra9. Em uma inserão no meio da lista(3ndice AltB taman+o), o conte0do posterior ao 3ndice ' deslocado em uma posião. Estaimplementaão ' a recomendada quando o taman+o da lista ' previs3vel (evitando realoca#es) eas opera#es de inserão e remoão são feitas, em sua maioria, no fim da lista (evitandodeslocamentos), ou quando a lista ' mais lida do que modificada (otimi6ado para leitura aleat7ria).

LinkedList

4mplementaão de ?ist que utili6a internamente uma lista encadeada. locali6aão de umelemento na n'sima posião ' feita percorrendose a lista da ponta mais pr7=ima at' o 3ndicedeseado. inserão ' feita pela adião de novos n7s, entre os n7s adacentes, sendo que antes 'necessria a locali6aão desta posião. Esta implementaão ' recomendada quando asmodifica#es são feitas em sua maioria tanto no in3cio quanto no final da lista, e o percorrimento 'feito de forma sequencial (via 4terator) ou nas e=tremidades, e não aleat7ria (por 3ndices). &me=emplo de uso ' como um fila (%4%8 %irst4n%irst8ut), onde os elementos são retirados dalista na mesma sequncia em que são adicionados.

Vector

http://java.sun.com/j2se/1.5.0/docs/guide/collections/overview.htmlhttp://java.sun.com/j2se/1.5.0/docs/guide/collections/overview.html


3/14

4mplementaão de ?ist com o mesmo comportamento da rra9?ist, por'm, totalmentesincroni6ada. 5or ter seus m'todos sincroni6ados, tem performance inferior ao de uma rra9?ist,mas pode ser utili6ado em um amiente multitarefa (acessado por vrias t+reads) sem peri*o de

perda da consistncia de sua estrutura interna.Em sistemas reais, essa sincroni6aão acaa adicionando um over+ead desnecessrio, pois mesmoquando + acesso multitarefa < lista (o que não acontece na maioria das ve6es), quase sempre '

preciso fa6er uma nova sincroni6aão nos m'todos de ne*7cio, para Catomi6aremC opera#esse*uidas sore o :ector. 5or e=emplo, uma c+amada ao m'todo contains(), se*uida de uma

c+amada do m'todo add() caso o elemento não e=ista, podem causar condi#es de corrida, se +acessos de vrioas t+reads ao mesmo tempo. ssim, acaa sendo necessria uma sincroni6aãoadicional, en*loando estas duas opera#es e tornando desnecessria a sincroni6aão inerente daclasse.5ortanto, a não ser que +aam acessos simultneos de vrias t+reads < lista, e a sincroni6aãosimples, provida pela classe :ector, sea o astante, prefira outras implementa#es como rra9?iste ?in!ed?ist, que oferecem performance superior.

Stack

4mplementaão de ?ist que oferece m'todos de acesso para uso da lista como uma pil+a (?4%8 ?ast4n%irst8ut), como pus+(), pop() e pee!(). Estende :ector, portanto +erda as vanta*ens edesvanta*ens da sincroni6aão deste. 5ode ser usado para se aproveitar as implementa#es dasopera#es espec3ficas de pil+a.

Set

4nterface que define uma coleão, ou conunto, que não cont'm duplicatas de oetos. 4sto ', são i*noradasas adi#es caso o oeto ou um oeto equivalente e=ista na coleão. 5or oetos equivalentes, entendase oetos que ten+am o mesmo c7di*o +as+ (retornado pelo m'todo +as+$ode()) e que retornemverdadeiro na comparaão feita pelo m'todo equals().

>ão ' *arantida a ordenaão dos oetos, isto ', a ordem de iteraão dos oetos não necessariamente temqualquer relaão com a ordem de inserão dos oetos. 5or isso, não ' poss3vel inde=ar os elementos por3ndices num'ricos, como em uma ?ist.

HashSet

4mplementaão de Set que utili6a uma taela +as+ (a implementaão da Sun utili6a a classe

;as+Fap internamente) para *uardar seus elementos. >ão *arante a ordem de iteraão, nem que aordem permanecer constante com o tempo (uma modificaão da coleão pode alterar a ordenaão*eral dos elementos). 5or utili6ar o al*oritmo de taela +as+, o acesso ' rpido, tanto para leituraquanto para modificaão.

LinkedHashSet

4mplementaão de Set que estende ;as+Set, mas adiciona previsiilidade < ordem de iteraãosore os elementos, isto ', uma iteraão sore seus elementos (utili6ando o 4terator) mant'm a

ordem de inserão (a inserão de elementos duplicados não altera a ordem anterior). 4nternamente,' mantida uma lista duplamente encadeada que mant'm esta ordem. 5or ter que manter uma lista


4/14

paralelamente < taela +as+, a modificaão deste tipo de coleão acarreta em uma leve queda na performance em relaão < ;as+Set, mas ainda ' mais rpida que uma GreeSet, que utili6acompara#es para determinar a ordem dos elementos.

SortedSet

4nterface que estende Set, adicionando a semntica de ordenaão natural dos elementos. posião doselementos no percorrimento da coleão ' determinado pelo retorno do m'todo compareGo(o), caso oselementos implementem a interface $omparale, ou do m'todo compare(o1, o2) de um oeto au=iliar queimplemente a interface $omparator.

TreeSet

4mplementaão de SortedSet que utili6a internamente uma GreeFap, que por sua ve6 utili6a o

al*oritmo /edHlac! para a ordenaão da rvore de elementos. 4sto *arante a ordenaãoascendente da coleão, de acordo com a ordem natural dos elementos, definida pelaimplementaão da interface $omparale ou $omparator. &se esta classe quando precisar de umconunto (de elementos 0nicos) que deve estar sempre ordenado, mesmo sofrendo modifica#es.5ara casos onde a escrita ' feita de uma s7 ve6, antes da leitura dos elementos, talve6 sea maisvantaoso fa6er a ordenaão em uma ?ist, se*uida de uma c7pia para uma ?in!ed;as+Set(dependendo do taman+o da coleão e do n0mero de repeti#es de elementos).

Map

4nterface que define um arra9 associativo, isto ', ao inv's de n0meros, oetos são usados como c+aves para se recuperar os elementos. s c+aves não podem se repetir (se*uindo o mesmo princ3pio da interfaceSet), mas os valores podem ser repetidos para c+aves diferentes. &m Fap tam'm não possuinecessariamente uma ordem definida para o percorrimento.

HashMap

4mplementaão de Fap que utili6a uma taela +as+ para arma6enar seus elementos. 8 tempo deacesso aos elementos (leitura e modificaão) ' constante (muito om) se a funão de +as+ for emdistriu3da, isto ', a c+ance de dois oetos diferentes retornarem o mesmo valor pelo m'todo+as+$ode() ' pequena.

LinkedHashMap

4mplementaão de Fap que estende ;as+Fap, mas adiciona previsiilidade < ordem de iteraãosore os elementos, isto ', uma iteraão sore seus elementos (utili6ando o 4terator) mant'm aordem de inserão (a inserão de elementos duplicados não altera a ordem anterior). 4nternamente,

' mantida uma lista duplamente encadeada que mant'm esta ordem. 5or ter que manter uma lista paralelamente < taela +as+, a modificaão deste tipo de coleão acarreta em uma leve queda na


5/14

performance em relaão < ;as+Fap, mas ainda ' mais rpida que uma GreeFap, que utili6acompara#es para determinar a ordem dos elementos.

Hashtable

ssim como o :ector, a ;as+tale ' um le*ado das primeiras vers#es do JDK, i*ualmentesincroni6ado em cada uma de suas opera#es. 5elos mesmos motivos da classe :ector, d

preferncia a outras implementa#es, como a ;as+Fap, ?in!ed;as+Fap e GreeFap, pelo *an+ona performance.

roperties

$lasse que estende ;as+tale, especiali6ada para traal+ar com Strin*s. >ão ' propriamente umacoleão ( que se restrin*e asicamente a Strin*s), mas serve como e=emplo de umaimplementaão especiali6ada da interface Fap.

!dentityHashMap

4mplementaão de Fap que intencionalmente viola o contrato da interface, utili6ando a identidade(operador II) para definir equivalncia das c+aves. Esta implementaão deve ser usada apenas emcasos raros onde a semntica de identidade referencial deve ser usada para equivalncia.

"eakHashMap

4mplementaão de Fap que utili6a referncias fracas (ea!/eference) como c+aves, permitindo adesalocaão pelo ara*e $ollector dos oetos nela contidos. Esta classe pode ser usada como

ase para a implementaão de cac+es temporrios, com dados automaticamente desalocados emcaso de pouca utili6aão.

SortedMap

4nterface que estende Fap, adicionando a semntica de ordenaão natural dos elementos, anlo*o <SortedSet. Gam'm adiciona opera#es de partião da coleão, com os m'todos +eadFap(!) que retornaum SortedFap com os elementos de c+aves anteriores a ! , suFap(!1,!2) que retorna um SortedFapcom os elementos de c+aves compreendidas entre !1 e !2 e tailFap(!) que retorna um SortedFap com

os elementos de c+aves posteriores a !.

TreeMap

4mplementaão de SortedFap que utili6a o al*oritmo /edHlac! para a ordenaão da rvore deelementos. 4sto *arante a ordenaão ascendente da coleão, de acordo com a ordem natural doselementos, definida pela implementaão da interface $omparale ou $omparator. &se esta classequando precisar de um conunto (de elementos 0nicos) que deve estar sempre ordenado, mesmosofrendo modifica#es. nlo*o ao GreeSet, para casos onde a escrita ' feita de uma s7 ve6, antesda leitura dos elementos, talve6 sea mais vantaoso fa6er a ordenaão em uma ?ist, se*uida de

uma c7pia para uma ?in!ed;as+Set (dependendo do taman+o da coleão e do n0mero derepeti#es de c+aves).


6/14

!nter#aces a$%iliares

8 frameor! $ollections define ainda uma s'rie de interfaces au=iliares, que definem opera#es deoetos retornados por m'todos das interfaces de cole#es.

Iterator

4nterface que define as opera#es sicas para o percorrimento dos elementos da coleão. &tili6a o patternde mesmo nome (4terator, o%), desacoplando o c7di*o que utili6a as cole#es de suas estruturas internas.L poss3vel remover elementos da coleão ori*inal utili6ando o m'todo remove(), que remove o elementoatual da iteraão, mas esta operaão ' de implementaão opcional, e uma &nsupported8perationE=ceptionser lanada caso esta não estea dispon3vel.

ListIterator

4nterface que estende 4terator, adicionando fun#es espec3ficas para cole#es do tipo ?ist. L otida atrav'sdo m'todo list4terator() de uma ?ist, e possui opera#es de percorrimento em amos os sentidos(permitido pela inde=aão dos elementos feita pela ?ist).

Comparable

4nterface que define a operaão de comparaão do pr7prio oeto com outro, usado para definir a ordem

natural dos elementos de uma coleão. 5ode ser usado caso os oetos que serão adicionados na coleão implementem a interface (4nte*er, Doule, Strin*, etc.), ou serão implementados pelo pro*ramador, quetem a c+ance de emutir esta interface em seu c7di*o.

Comparator

4nterface que define a operaão de comparaão entre dois oetos por um oeto e=terno. L utili6adoquando os oetos a serem adicionados não podem ser modificados para aceitarem a interface $omparale(são de uma ilioteca de terceiros, por e=emplo), ou ' necessria a troca da estrat'*ia de ordenaão emtempo de e=ecuão (ordenaão das lin+as de uma taela, por e=emplo). Esta interface prov maior

fle=iilidade, sem custo adicional si*nificativo. 5refira seu uso, ao inv's da interface $omparale, a nãoser que esta sea necessria (isto ', voc usa uma classe que espera oetos que a implementem) ou se a

pr7pria semntica dos oetos e=ia esa ordem natural (o que ' em suetivo e espec3fico dodom3nioMsistema).

Enumeration

CncestralC da interface 4terator, que prov as mesmas fun#es, a não ser a retirada de elementos dacoleão. 8s nomes de seus m'todos são em mais lon*os +asForeElements() e ne=tElement() contra+as>e=t() e ne=t() o que dificulta a di*itaão e a leitura do c7di*o. L utili6ada asicamente apenas nas

classes :ector e ;as+tale, podendo ser praticamente i*norada e sustitu3da pela interface 4terator.


7/14

RandomAccess

4nterface marcadora (mar!er interface), que apenas assinala que determinadas implementa#es de ?ist sãootimi6adas para acesso aleat7rio (por 3ndice num'rico, ao inv's de iterators). 4sta informaão pode serusada por al*umas classes, para que estas possam alterar suas estrat'*ias internas para *an+o de

performance.

Classes &tilit'rias

$lasses utilitrias, como assumidas aqui, são classes que possuem apenas m'todos estticos, provendoal*oritmos comuns.

Collections

8ferece m'todos que efetuam opera#es sore cole#es. l*umas opera#es dispon3veis são- usca inria em listasB sustituião dos elementos de uma lista por um determinado oetoB usca pelo menor

ou maior elemento (de acordo com a ordem natural definida pelas interfaces $omparale ou $omparator)Binversão de uma listaB emaral+amentoB deslocamento dos elementosB otenão de cole#es sincroni6adasou imutveis, aseadas em cole#es e=istentes (atrav's do pattern Decorator).

Arrays

$lasse utilitria que oferece opera#es sore arra9s, incluindo- ordenaão, procura inria, comparaãoentre arra9s, preenc+imento, clculo do +as+$ode aseados nos elementos de um arra9, transformaão emStrin* e o inv7lucro de um arra9 por uma implementaão de taman+o fi=o de ?ist.

ro(ramando por !nter#aces

8 $ollections frameor! do Java nos fornece toda uma infraestrutura para estruturas de dados. E, por usar interfaces sicas em definidas ($ollection, ?ist, Set, SortedSet, Fap, SortedFap), cria tam'mastra#es que aumentam a fle=iilidade e a facilidade de modificaão.

Nuando pro*ramamos usando estas classes, devemos sempre referencilas pelas interfaces. l*u'm podedi6er- "Fas não d pra instanciar interfacesO" $laro que não. Nuando precisamos instanciar uma coleão,

utili6amos a implementaão concreta mais apropriada, mas os tipos de parmetros e retornos dos m'todosdevem sempre ser uma destas interfaces sicas.

5or e=emplo, no c7di*o se*uinte-


8/14

vie plain print P1. private :ector listaDe$omprasB2. pulic void set?istaDe$ompras(:ector lista) Q

R. t+is.listaDe$ompras I listaB

. T

@. pulic :ector *et?istaDe$ompras() Q

U. return t+is.listaDe$omprasB

V. T

Supon+a que ten+amos notado que não + acesso concorrente a este oeto, e a sincroni6aão inerente do:ector est impactando na performance do sistema. 5ara alterarmos o tipo de :ector para rra9?ist,eliminando o over+ead desnecessrio da sincroni6aão, temos que alterar todas as classes que utili6am este

m'todo, pois elas passam e esperam um :ector, não um rra9?ist.

8u pior- supon+a que estas classes que utili6am nossa lista de compras (criadas por outras equipes, portanto, mais dif3ceis de serem alteradas) tam'm tm suas pr7prias estruturas internas de dados,utili6ando a classe ?in!ed?ist. 8 inferno est mais pr7=imo do que voc ima*inaO 5ara passar parmetrosou receer valores ' preciso fa6er convers#es entre cole#es diferentes, copiando os elementos de uma

para outra, aumentando ainda mais o prolema de performance, al'm de dificultar a leitura e amanutenão do c7di*o.

>estes casos, se no lu*ar de :ector tiv'ssemos usado a interface ?ist, astaria alterar o local deinstanciaão da classe, que todo o resto do c7di*o teria automaticamente a nova implementaão, sem

modifica#es. &ma coleão criada em um componente poderia facilmente ser utili6ada por outro, poistudo o que ele espera ' uma implementaão de ?ist, e não uma classe concreta.

5ortanto, utili6e interfaces sempre que puder, principalmente em assinaturas de m'todos p0licos, e limiteao m=imo referncias a classes concretas, mesmo internamente na classe.

) *$e inter#ace $sar+

Gemos a*ora pelo menos seis interfaces para escol+er- $ollection, ?ist, Set, SortedSet, Fap e SortedFap.Se acrescentarmos as au=iliares de acesso < coleão, temos ainda a 4terator e a ?ist4terator. Nual delasusarP

http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654


9/14

$ollection ' a mais *en'rica, portanto ' a mais indicada sempre, certoP

ErradoO 5or ser tão *en'rica, suas opera#es são muito restritas, dificultando sua manipulaão. 5ore=emplo, ela não permite o acesso direto a um elemento, toda a leitura deve ser feita atrav's de seu4terator. Se a coleão ser sempre lida como uma sequncia de elementos, e o acesso aleat7rio (por 3ndice)não fa6 sentido, isto não ' prolema. Fas se este tipo de acesso ' necessrio (ou mesmo conveniente), fa6

mais sentido usar uma interface ?ist.

Este ' um prolema sem uma resposta definitiva, pois depende muito de cada caso. Fas posso listaral*umas re*ras sicas, otidas da min+a pr7pria e=perincia. >ão que isso sea *rande coisa, mas vale atentativa. -5

interface $ollection normalmente ' usada para conuntos descartveis, isto ', que vão ser lidosapenas uma ve6, e não *uardados internamente e manipulados (no m=imo copiados para umaoutra estrutura).

interface Set serve mais como um marcador da semntica esperada, pois ela não acrescentanen+uma operaão < $ollection.

s interfaces SortedSet e SortedFap servem para forar um contrato, de que os elementos dacoleão virão ordenados. parecem, principalmente, como parmetros de m'todos que esperam

por esta ordenaão. 5or'm, na maioria das ve6es, as classes GreeSet e GreeFap serão usadasapenas localmente, como containers temporrios de ordenaão.

)%emplos de $so,

?oop t3pico em uma $ollection, usando o 4terator-

vie plain print P1. 4terator it I colecao.iterator()B2. +ile (it.+as>e=t()) Q

R. Strin* item I (Strin*) it.ne=t()B

. S9stem.out.println(item)B

@. T



10/14

?oop t3pico em um Fap, usando o 4terator-

vie plain print P1. Fap mapa I ne ;as+Fap()B

2. 4terator it$+aves I mapa.!e9Set().iterator()B

R. +ile (it$+aves.+as>e=t()) Q

. 8ect c+ave I it$+aves.ne=t()B

@. 8ect valor I mapa.*et(c+ave)B

U. S9stem.out.println(c+ave W " I " W valor)B

V. T

&sando um iterator para retirar elementos de uma coleão-

vie plain print P1. 4terator it I lista$ores.iterator()B2. +ile (it.+as>e=t()) Q

R. Strin* item I (Strin*) it.ne=t()B

. if (item.c+art(X) II CvC) Q MMretirando as cores que comeam com CvC

http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654http://www.javafree.org/javabb/viewtopic.jbb?t=847654


11/14

@. it.remove()B

U. T

V. T

&tili6ando um GreeSet para listar o conte0do de um FapM5roperties de maneira ordenada-

vie plain print P1. 5roperties p I ne 5roperties()B2. MM...

R. 4terator it I ne GreeSet(p.!e9Set()).iterator()B MMordena as c+aves antes de criar o iterator

. +ile (it.+as>e=t()) Q

@. Strin* !e9 I (Strin*) it.ne=t()B

U. S9stem.out.println(!e9 W "I" W p.*et5ropert9(!e9))B

V. T

4niciali6aão de uma $ollection-



12/14

vie plain print P1. MM :ersão normal-2. ?ist lista$ores I ne rra9?ist()B

R. lista$ores.add("vermel+o")B

. lista$ores.add("verde")B

@. lista$ores.add("amarelo")B

U. lista$ores.add("ranco")B

V.Y. MM :ersão areviada utili6ando um arra9

Z. ?ist lista$ores I ne rra9?ist(rra9s.as?ist(ne Strin*[\ Q

1X. "vermel+o", "verde", "amarelo", "ranco" T))B

$riando e ordenando uma $ollection-

vie plain print P1. ?ist lista$ores I ne rra9?ist(rra9s.as?ist(ne Strin*[\ Q2. "vermel+o", "verde", "amarelo", "ranco" T))B

R.

. $ollections.sort(lista$ores)B



13/14

$riando e ordenando uma $ollection-

vie plain print P1. ?ist lista$ores I ne rra9?ist(rra9s.as?ist(ne Strin*[\ Q

2. "vermel+o", "verde", "amarelo", "ranco" T))B

R.

. $ollections.sort(lista$ores)B

4ntersecão de conuntos utili6ando Set-

vie plain print P1. Set coresNuentes I ne ;as+Set(rra9s.as?ist(ne Strin*[\ Q2. "vermel+o", "larana", "amarelo" T))B

R.

. Set conunto$ores I ne ;as+Set(rra9s.as?ist(ne Strin*[\ Q

@. "vermel+o", "verde", "amarelo", "ranco" T))B

U.

V. conunto$ores.retainll(coresNuentes)B MM conunto$ores II Q"vermel+o", "amarelo"T



14/14

Documents

FramFramework Collection - Java.free.Orgework Collection - Java.free.Org