Verifique se uma lista contém elementos da outra

Tenho duas listas com objetos diferentes.

List<Object1> list1;
List<Object2> list2;

Quero verificar se o elemento da lista1 existe na lista2, com base no atributo específico (Object1 e Object2 têm (entre outros), um atributo mútuo (com tipo Long), denominado attributeSame).

agora, eu faço assim:

boolean found = false;
for(Object1 object1 : list1){
   for(Object2 object2: list2){
       if(object1.getAttributeSame() == object2.getAttributeSame()){
           found = true;
           //also do something
       }
    }
    if(!found){
        //do something
    }
    found = false;
}

Mas acho que existe uma maneira melhor e mais rápida de fazer isso :) Alguém pode sugerir?

Obrigado!

Se você precisa apenas testar a igualdade básica, isso pode ser feito com o JDK básico sem modificar as listas de entrada em uma linha

!Collections.disjoint(list1, list2);

Se você precisa testar uma propriedade específica, isso é mais difícil. Eu recomendaria, por padrão,

list1.stream()
   .map(Object1::getProperty)
   .anyMatch(
     list2.stream()
       .map(Object2::getProperty)
       .collect(toSet())
       ::contains)

... que coleta os valores distintos list2e testa cada valor em list1quanto à presença.

Você pode usar Apache Commons CollectionUtils :

if(CollectionUtils.containsAny(list1,list2)) {  
    // do whatever you want
} else { 
    // do other thing 
}  

Isso pressupõe que você sobrecarregou adequadamente a funcionalidade equals para seus objetos personalizados.

Para encurtar a lógica de Narendra, você pode usar isto:

boolean var = lis1.stream().anyMatch(element -> list2.contains(element));

Existe um método de Collectionnomeação, retainAllmas tendo alguns efeitos colaterais para sua referência

Retém apenas os elementos nesta lista que estão contidos na coleção especificada (operação opcional). Em outras palavras, remove desta lista todos os seus elementos que não estão contidos na coleção especificada.

verdadeiro se esta lista mudou como resultado da chamada

É como

boolean b = list1.retainAll(list2);

A resposta do Loius está correta, só quero adicionar um exemplo:

listOne.add("A");
listOne.add("B");
listOne.add("C");

listTwo.add("D");
listTwo.add("E");
listTwo.add("F");      

boolean noElementsInCommon = Collections.disjoint(listOne, listTwo); // true

maneira mais rápida exigirá espaço adicional.

Por exemplo:

1. coloque todos os itens em uma lista em um HashSet (você deve implementar a função hash sozinho para usar object.getAttributeSame ())

2. Percorra a outra lista e verifique se algum item está no HashSet.

Desta forma, cada objeto é visitado no máximo uma vez. e o HashSet é rápido o suficiente para verificar ou inserir qualquer objeto em O (1).

De acordo com o JavaDoc para .contains(Object obj):

Retorna verdadeiro se esta lista contém o elemento especificado. Mais formalmente, retorna true se e somente se esta lista contém pelo menos um elemento e tal que (o == null? E == null: o.equals (e)).

Portanto, se você substituir seu .equals()método para o objeto fornecido, deverá ser capaz de fazer:if(list1.contains(object2))...

Se os elementos será único (ie. Tem atributos diferentes), você poderia substituir o .equals()e .hashcode()e armazenar tudo em HashSets. Isso permitirá que você verifique se um contém outro elemento em tempo constante.

para torná-lo mais rápido, você pode adicionar uma pausa; dessa forma, o loop irá parar se encontrado for definido como verdadeiro:

boolean found = false;
for(Object1 object1 : list1){
   for(Object2 object2: list2){
       if(object1.getAttributeSame() == object2.getAttributeSame()){
           found = true;
           //also do something  
           break;
       }
    }
    if(!found){
        //do something
    }
    found = false;
}

Se você tivesse mapas em vez de listas com como chaves o attributeSame, você poderia verificar mais rapidamente se há um valor em um mapa se há um valor correspondente no segundo mapa ou não.

Você pode definir o tipo de dados que mantém? é big data? está classificado? Acho que você precisa considerar diferentes abordagens de eficiência, dependendo dos dados.

Por exemplo, se seus dados forem grandes e não classificados, você pode tentar iterar as duas listas juntas por índice e armazenar cada atributo de lista em outro auxiliar de lista. então você pode verificar os atributos atuais nas listas auxiliares.

boa sorte

editado: e eu não recomendaria sobrecarregar iguais. é perigoso e provavelmente contra o significado do objeto oop.

org.springframework.util.CollectionUtils

boolean containsAny(java.util.Collection<?> source, java.util.Collection<?> candidates)

Return true if any element in 'candidates' is contained in 'source'; otherwise returns false

Com java 8, podemos fazer o seguinte para verificar se uma lista contém algum elemento de outra lista

boolean var = lis1.stream().filter(element -> list2.contains(element)).findFirst().isPresent();

Se você quiser verificar se um elemento existe em uma lista, use o método contains.

if (list1.contains(Object o))
{
   //do this
}