Pesquisando um objeto numa collection

Vc jah subscreveu o metodo equals? e acho que vc deveria passar um activeDirectoryDTO como parametro do metodo, deve ser isso.

Abraços.

Essa função da collection (contains) verifica se existe o objeto na outra collection … Nao precisando usar o equals …
E estou passando um parametro de um activeDirectoryDTO …

for (activeDirectoryDTO objLDAP : listaNomesLdap) {

é o seguinte, como sua Collection é do tipo activeDirectoryDTO,

Collection<activeDirectoryDTO> retornaNomesBanco = null;

entao vc deve passar um activeDirectoryDTO como parametro, e nao uma string,

(retornaNomesBanco.contains(objLDAP.getNomeUsuario().trim())){

só que ai ela nao vai saber qual logica vc quer usar pra diferenciar se um objeto activeDirectoryDTO é igual a outro activeDirectoryDTO, entao vc precisa ensinar isso, subscrevendo o metodo equals. não se esqueca de instanciar os objetos antes chamar qualquer metodo.

if (retornaNomesBanco.contains(objLDAP.getNomeUsuario().trim())){

retornaNomesBanco é null

Esqueci, pelo que notei vc quer sejam iguais quando o nome do usuario for igual, então…

keltonribeiro:

Essa função da collection (contains) verifica se existe o objeto na outra collection … Nao precisando usar o equals …
E estou passando um parametro de um activeDirectoryDTO …

for (activeDirectoryDTO objLDAP : listaNomesLdap) {

engano seu…

collection.contains(item);

faz um iterator pela collection mais ou menos assim

for (Object o : collection) if (o.equals(item)) return true; return false;

ou seja… se vc não implementar o equals… o resultado pode ser diferente do esperado…

Amigo ,
Posso estar falando besteira , mas o que quero fazer é que a minha collection seja percorrida e tente achar o valor do meu objeto do tipo collection … E não simplesmente verificar se um valor é igual a outro …

keltonribeiro:

Amigo ,
Posso estar falando besteira , mas o que quero fazer é que a minha collection seja percorrida e tente achar o valor do meu objeto do tipo collection … E não simplesmente verificar se um valor é igual a outro …

</blockquote>

e como vc acha que ele encontra ?? ele encontra verificando se o objeto que vc passou é igual a algum objeto que esta la dentro da collection … o.O

e para tal ele testa essa igualdade atraves de equals

package java.util;

public abstract class AbstractCollection<E> implements Collection<E> {
//....
    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the elements in the collection,
     * checking each element in turn for equality with the specified element.
     *
     * @throws ClassCastException   {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
	    public boolean contains(Object o) {
	    	Iterator<E> e = iterator();
	    	if (o==null) {
	    	    while (e.hasNext())
	    		if (e.next()==null)
	    		    return true;
	    	} else {
	    	    while (e.hasNext())
	    		if (o.equals(e.next()))
	    		    return true;
	    	}
	    	return false;
	    }
//...
}

resumindo... tentar usar contains(Object o) ... sem implementar Object.equals ... vai fazer com que a coleção teste via hashCode() ... o que só retornará verdade caso os 2 objetos compartilhem uma única referencia na memoria ...

Então seria melhor eu usar o Interator pra essa pesquisa ?

seria melhor vc implementar o equals no seu objeto ^^ … é bem + simples… caso contrario… sempre que vc for usar contains, vai ter que se lembrar de fazer um procedimento que já esta escrito dentro da propria collection… basta implementar o equal no seu objeto

Então ficaria dessa forma :

for (activeDirectoryDTO objLDAP : listaNomesLdap) {
				nomeLdap = objLDAP.getNomeUsuario().trim();
				System.out.println("Valor vindo do servidor Ldap -->" + nomeLdap);
				
				 if (retornaNomesBanco.equals(objLDAP.getNomeUsuario().trim())){    
					 System.out.println("Este nome já contém no banco de dados -->" + objLDAP.getNomeUsuario().trim());
				 }
				else {
						novoNome.setNomeUsuario(nomeLdap);
						armazenaNomes.add(novoNome);
						System.out.println("  === > Novo nome incluído na collection -->" + nomeLdap);
						
					}	
			}

No meu debug aqui, eu vejo realmente que o objeto (um ArrayList,) tenta comparar uma string de valor (Nome) … mesmo usando o equals …

na verdade o ideal é assim... o que vc quer comprar ??? .... activeDirectoryDTO (estranho uma classe com letra minuscula no inicio mas tudo bem...)

vc quer fazer compração do tipo...

activeDirectoryDTO.equals(String s); onde a string é o nome do usuario... então seria assim

public class activeDirectoryDTO {
//...

public boolean equals(activeDirectoryDTO  o) {
    if (o == null)
        return false;
    return this.getNomeUsuario().trim().equals(o.getNomeUsuario().trim());
}
//...
}

retornaNomesBanco.equals(objLDAP)

poderia usar isso diretamente... e saber se existe o objeto na sua lista

........

#          Collection<activeDirectoryDTO> retornaNomesBanco = null;    
#     
#          Collection<activeDirectoryDTO> listaNomesLdap = null;    
#          listaNomesLdap = adUsuario.ImprimeUsuarios();    
#              
#              
#     
#          for (activeDirectoryDTO objLDAP : listaNomesLdap) {           
#             System.out.println("Valor vindo do servidor Ldap -->" + objLDAP.getNomeUsuario().trim());    
#                 
#                 
#             if (retornaNomesBanco.contains(objLDAP)){    
#                System.out.println("Este nome já contém no banco de dados -->" + objLDAP.getNomeUsuario().trim());    
#                    
#             }else {    
#                activeDirectoryDTO novoNome = new activeDirectoryDTO();    
#                novoNome.setNomeUsuario(objLDAP.getNomeUsuario());    
#                armazenaNomes.add(novoNome);    
#                System.out.println("Novo nome incluído no banco de dados  -->" + objLDAP.getNomeUsuario().trim());    
#             }       
#          }

Kelton, vc continua passando um String

if (retornaNomesBanco.contains(objLDAP.getNomeUsuario().trim())){

vc deve passar um activeDirectoryDTO

f (retornaNomesBanco.contains(objLDAP)){

no equal vc coloca a condição e que objetos activeDirectoryDTO serão iguais se o nomeUsuario forem iguais, o resto ele faz só, jah que ele vai chamar o metodo equals do seu objeto, ou seja, o que vc acabou de implementar.

Não se esqueça de instanciar o retornaNomesBanco.

Paulo, agora entendi … só que tem mais uma pergunta :
Posso comparar um objeto do tipo ArrayList com outro objeto Collection ?

veja esta parte que atribuo uma collection para receber um arraylist

try {
			sql.delete(0, sql.length());
			sql.append("SELECT * FROM ad_usuarios");
			ps = conexao.prepareStatement(sql.toString());
			ResultSet rs = ps.executeQuery();
			retornaNomesBanco = new ArrayList<activeDirectoryDTO>();
			armazenaNomes = new ArrayList<activeDirectoryDTO>();

			while (rs.next()) {
				activeDirectoryDTO listaNomesBanco = new activeDirectoryDTO();
				listaNomesBanco.setNomeUsuario(rs.getString("nome"));
				retornaNomesBanco.add(listaNomesBanco);
				System.out.println(" Nome vindo do bando de dados --> " + listaNomesBanco);
			}
		
			listaNomesLdap = adUsuario.ImprimeUsuarios();
			activeDirectoryDTO novoNome = new activeDirectoryDTO();

			for (activeDirectoryDTO objLDAP : listaNomesLdap) {
				nomeLdap = objLDAP.getNomeUsuario().trim();
				System.out.println("Valor vindo do servidor Ldap -->" + nomeLdap);
				
				 if (retornaNomesBanco.equals(objLDAP)){    
					 System.out.println("Este nome já contém no banco de dados -->" + objLDAP.getNomeUsuario().trim());
				 }
				else {
						novoNome.setNomeUsuario(nomeLdap);
						armazenaNomes.add(novoNome);
						System.out.println("  === > Novo nome incluído na collection -->" + nomeLdap);
						
					}	
			}

ArrayList implementa a interface List, que por sua vez implementa a interface Collection, então como ele vai tah trabalhando com os objetos do tipo Collection, não vejo problemas, ma seria bom vc colocar no teu equals algo do tipo:

if (obj instanceof activeDirectoryDTO) {
return true;

assim ele compararia só com objetos do tipo activeDirectoryDTO

Paulo Aguiar:

ArrayList implementa a interface List, que por sua vez implementa a interface Collection, então como ele vai tah trabalhando com os objetos do tipo Collection, não vejo problemas, ma seria bom vc colocar no teu equals algo do tipo:

if (obj instanceof activeDirectoryDTO) {
return true;

assim ele compararia só com objetos do tipo activeDirectoryDTO

Apenas um detalhe: você quis dizer a coisa certa, mas disse do jeito errado: uma interface sempre ESTENDE outra(s) e nunca as implementa. Apenas uma classe pode implementar interfaces. Portanto, entenda-se o seguinte:

ArrayList implementa a interface List, que por sua vez estende a interface Collection…

Foi só pra ver se tinha alguem prestando atenção, risos

Obrigado a todos que me ajudaram neste código …

Foram muito cordiais e companheiros … muito obrigado mesmo !!!

Tive que abandonar a collection e usar um arraylist de strings … e deu certo !!!

valews !!!