Arquivo Discussoes de Programacao e Tecnologia Bom Dia Pessoal,
Veja se alguém pode me ajudar por favor…
Tenho uma collection do tipo Collection que tem vários atributos preenchidos:
nome
idade
sexo
Quero fazer um for e pegar todo mundo que tem 30 anos…
Como faço para pegar o atributo idade dentro da collection para fazer um if dentro do for???
Tentei fazer conforme abixo e não rola.
Obrigada!!!
for(; i++) {int i = 0; i < collection.size()
collection.getIdade();
if…
}
Bom, então vamos do princípio, pra começar não é a Collection que tem atributos e sim o objeto que está dentro dela, sabendo isso basta fazer um for each com um if dentro, pegue a idade do objeto que for passado e verifique se é maior que 30, se for pegue o valor.
Exemplo:
for(Usuario usuario:colecao)
{
if(usuario.getIdade() > 29)
System.out.println(usuario.getNome());
}
Isto aqui deve funcionar. Você precisa usar uma Collection “tipada”.
class Pessoa {
private int idade;
public int getIdade() { return idade; }
....
}
...
class Teste {
public static void main(String[] args) {
Collection<Pessoa> pessoas = new ArrayList<Pessoa>();
....
for (Pessoa p : pessoas) {
System.out.println (p.getIdade());
}
}
}
Se eu transformar a collection em Array list…
ArrayList a = (ArrayList) collection;
Funciona!!! Pois eu consigo varrer o arraylist dando o get…
Valeu galera!!!
Em uma Collections voce não tem o get do List mas voce tem o iterador e para faciltiar o for-each
for(Pessoa p : lista){
//Aqui é como um for iterando e a cada iteração o objeto p é a proxima pessoa.
}
Pense nessa ideia... digamos que vc ja tenha 2 classes no seu pacote de utilidades... Filter.java e CollectionUtils.java
ve como seria simples... filtrar 1 coleção...
class Pessoa {
private int idade;
public int getIdade() { return idade; }
....
}
...
class Teste {
public static void main(String[] args) {
Collection<Pessoa> pessoas = getAllPessoas(); //aqui abstraio como vc pega a lista
//Criando o filtro de pessoas igual a 30 anos.
Filter<Pessoa> igualA30 = new Filter<Pessoa>() {
public boolean match(Pessoa pessoa) {
return object.getIdade() == 30;
}
}
//pegando os valores que passam no filtro
List<Pessoa> pessoasCom30Anos = CollectionUtils.findAllMatch(pessoas, igualA30);
}
}
Agora abaixo segue como criar as classes utilitarias e a interface... e pense que essa ideia é reutilizavel
Vc cria uma interface chamada FIltro... isso vc vai poder usar sempre que precisar agora... Filtro.java/**
* Filtro para de objetos.
* @author Tomaz Lavieri
* @param <T> o tipo de objeto do filtro.
*/
public interface Filter<T> {
/**
* Verifica se o objeto confere com o filtro.
* @param object o objeto a ser verificado.
* @return se o objeto passa no filtro.
*/
public boolean match(T object);
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* Classe utilitária para manipular coleções
* @author Tomaz Lavieri
*/
public class CollectionUtils {
/**
* Não é possivel instaciar CollectionUtils.
*/
private CollectionUtils(){}
/**
* Adciona a coleção <tt>recipient</tt> todos os objetos <tt>T</tt> da lista
* de <tt>candidates</tt> que coincidirem com o <tt>filter</tt>.
* <BR>
* <BR>Adciona o inverso dos itens de <tt>candidates</tt> que
* {@link #addAllNotMatch(Collection, Filter, Collection)} adcionaria.
* @param <T> o tipo de objeto a ser adcionado.
* @param candidates a coleção de candidatos a serem adcionados ao
* <tt>recipient</tt>.
* @param filter o filtro que será usado para <b><u>aceitar</u></b> um
* candidato a ser adcionado ao <tt>recipient</tt>.
* @param recipient coleção onde os objetos serão adicionados.
* @see #addAllNotMatch(Collection, Filter, Collection)
*/
public static <T> void addAllMatch(Collection<? extends T> candidates,
Filter<T> filter, Collection recipient) {
for (T object : candidates)
if (filter.match(object))
recipient.add(object);
}
/**
* Adciona a coleção <tt>recipient</tt> todos os objetos <tt>T</tt> da lista
* de <tt>candidates</tt> que não coincidirem com o <tt>filter</tt>.
* <BR>
* <BR>Adciona o inverso dos itens de <tt>candidates</tt> que
* {@link #addAllMatch(Collection, Filter, Collection)} adcionaria.
* @param <T> o tipo de objeto a ser adcionado.
* @param candidates a coleção de candidatos a serem adcionados ao
* <tt>recipient</tt>.
* @param filter o filtro que será usado para <b><u>recusar</u></b> um
* candidato a ser adcionado ao <tt>recipient</tt>.
* @param recipient coleção onde os objetos serão adicionados.
* @see #addAllNotMatch(Collection, Filter, Collection)
*/
public static <T> void addAllNotMatch(Collection<? extends T> candidates,
Filter<T> filter, Collection recipient) {
for (T object : candidates)
if (!filter.match(object))
recipient.add(object);
}
/**
* Busca todos os objetos <b>T</b> na lista de <tt>candidates</tt> que
* conferem com o <tt>filter</tt>.
* <BR>
* <BR>Tem o resultado inverso a {@link #findAllNotMatch(Collection, Filter)}
* @param <T> o tipo de objeto a ser buscado.
* @param candidates a coleção de condidatos aonde deseja-se realizar a
* busca.
* @param filter o filtro que será usado para <b><u>aceitar</u></b> um
* candidato no resultado da busca.
* @return todos os itens que passaram pelo filtro.
* @see #findAllNotMatch(Collection, Filter)
*/
public static <T> List<T> findAllMatch(Collection<? extends T> candidates,
Filter<T> filter) {
List<T> matchs = new ArrayList<T>(0);
addAllMatch(candidates, filter, matchs);
return matchs;
}
/**
* Busca todos os objetos <b>T</b> na lista de <tt>candidates</tt> que
* <u>não</u> conferem com o <tt>filter</tt>.
* <BR>
* <BR>Tem o resultado inverso a {@link #findAllMatch(Collection, Filter)}
* @param <T> o tipo de objeto a ser buscado.
* @param candidates a coleção de condidatos aonde deseja-se realizar a
* busca.
* @param filter o filtro que será usado para <b><u>negar</u></b> um
* candidato no resultado da busca.
* @return todos os itens que <u>não</u> passaram pelo filtro.
* @see #findAllMatch(Collection, Filter)
*/
public static <T> List<T> findAllNotMatch(Collection<? extends T> candidates,
Filter<T> filter) {
List<T> notMatchs = new ArrayList<T>(0);
addAllNotMatch(candidates, filter, notMatchs);
return notMatchs;
}
/**
* Busca o primeiro objeto <tt>T</tt> na coleção <tt>candidates</tt> que
* coincide com o <tt>filter</tt>.
* @param <T> o tipo de objeto a procurar.
* @param candidates a coleção de candidatos a ser pesquisados.
* @param filter o filtro que será usado para <b><u>aceitar</u></b> o
* candidato.
* @return O primeiro objeto de <tt>candidates</tt> que coincidir com o
* <tt>filter</tt>.
*/
public static <T> T findFirstMatch(Collection<? extends T> candidates,
Filter<T> filter) {
for (T object : candidates)
if (filter.match(object))
return object;
return null;
}
/**
* Busca o primeiro objeto <tt>T</tt> na coleção <tt>candidates</tt> que
* <u>não</u> coincide com o <tt>filter</tt>.
* @param <T> o tipo de objeto a procurar.
* @param candidates a coleção de candidatos a ser pesquisados.
* @param filter o filtro que será usado para <b><u>recusar</u></b> o
* candidato.
* @return O primeiro objeto de <tt>candidates</tt> que <u>não</u>
* coincidir com o <tt>filter</tt>.
*/
public static <T> T findFirstNotMatch(Collection<? extends T> candidates,
Filter<T> filter) {
for (T object : candidates)
if (!filter.match(object))
return object;
return null;
}
/**
* Remove da coleção de <tt>candidates</tt> todos os objetos <tt>T</tt> que
* coincidirem com o <tt>filter</tt>.
* <BR>
* <BR>Tem o resultado inverso a {@link #retainAll(Collection, Filter)}.
* @param <T> o tipo de objeto a ser filtrado.
* @param candidates a coleção que será filtrada.
* @param filter o filtro que será usado para <b><u>remover</u></b> os
* candidato, da coleção <tt>candidates</tt>.
* @throws UnsupportedOperationException caso a operação
* {@link Iterator#remove()} não seja suportada pelo
* {@link Iterator} gerado pela coleção <tt>candidates</tt>.
* @see Collection#iterator()
*/
public static <T> void removeAll(Collection<? extends T> candidates,
Filter<T> filter) throws UnsupportedOperationException {
for(Iterator<? extends T> itr = candidates.iterator(); itr.hasNext();)
if (filter.match(itr.next()))
itr.remove();
}
/**
* Retem na coleção de <tt>candidates</tt> apenas os objetos <tt>T</tt> que
* coincidirem com o <tt>filter</tt>.
* <BR>
* <BR>Tem o resultado inverso a {@link #removeAll(Collection, Filter)}.
* @param <T> o tipo de objeto a ser filtrado.
* @param candidates a coleção que será filtrada.
* @param filter o filtro que será usado para <b><u>reter</u></b> os
* candidato, da coleção <tt>candidates</tt>.
* @throws UnsupportedOperationException caso a operação
* {@link Iterator#remove()} não seja suportada pelo
* {@link Iterator} gerado pela coleção <tt>candidates</tt>.
* @see Collection#iterator()
*/
public static <T> void retainAll(Collection<? extends T> candidates,
Filter<T> filter) throws UnsupportedOperationException {
for(Iterator<? extends T> itr = candidates.iterator(); itr.hasNext();)
if (!filter.match(itr.next()))
itr.remove();
}
public static <T> T removeFirstMatch(Collection<? extends T> candidates,
Filter<T> filter) throws UnsupportedOperationException {
for(Iterator<? extends T> itr = candidates.iterator(); itr.hasNext();) {
T object = itr.next();
if (filter.match(object)) {
itr.remove();
return object;
}
}
return null;
}
public static <T> T removeFirstNotMatch(Collection<? extends T> candidates,
Filter<T> filter) throws UnsupportedOperationException {
for(Iterator<? extends T> itr = candidates.iterator(); itr.hasNext();) {
T object = itr.next();
if (!filter.match(object)) {
itr.remove();
return object;
}
}
return null;
}
}
Ai… tenho uma dúvida, na verdade não é sobre collection, mas o exemplo é…
por exemplo…
porque instancias uma hashset numa variavel set … por exemplo…
Set a = new HashSet();
pq não instanciar na propria variavel da collection tipo
HashSet a = new HashSet();
qual o motivo?
Obrigado
Opa e ai itopaulo bom cara?
sua pergunta é a seguinte usa-se:
Set a = new HashSet();
pq se esta linha de codigo sofrer um infactor por exemplo e vc querer utilzar nao mais o HashSet e sim um TreeSet vc consegue utilizar devido a Herança sobre o Set!
espero ter ajudado…
aaa. mas tipo mesmo eu tendo um
por exemplo
Set a = new HashSet()
eu terei todos os metodos de HashSet em a né?
aaa eh neh.. ja que HashSet herda set.. herda os métodos.. humm
mas tipo.. todo método de Hashset é também método de set? ou o HashSet tem métodos que que set n tem?
pq se isso for verdade.. quando eu tiver um Set que foi inicializado com um HashSet... ai eu não vou poder utilizar esse método ne?
eu posso fazer tipo....
LinkedHashSet b = new LinkedHashSet();
HashSet a = new HashSet( b );
Valeu everton...
HashSet() tem os metodos de Set mas tem Metodos especificos que Set não tem, se eu estiver errado alguem me corrija, mais é isso ai.
HashSet e TreeSet são implementações de Set. Você só deve criar os tipos filhos diretamente se efetivamente for usar os métodos específicos. Entretanto, isso é muito raro, já que são poucos métodos desse tipo.
Usualmente é melhor fazer:
Set set = new HashSet(); // você pode trocar, por exemplo, por um CopyOnWriteArraySet ou um LinkedHashSet
Set set = new TreeSet(); // se for usar como um conjunto normal e você não precisa de saber que é ordenado
SortedSet set = new TreeSet(); // se usar como um conjunto ordenado. Aí você pode trocar por um ConcurrentSkipListSet, por exemplo.
Não se deve usar o tipo concreto nas declarações de variáveis ou parâmetros, a menos que a situação assim o requeira, o que é muito raro, conforme o ViniGodoy ressaltou.