Compruebe si una lista contiene elementos de la otra

Tengo dos listas con diferentes objetos en ellas.

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

Quiero verificar si el elemento de list1 existe en list2, según un atributo específico (Object1 y Object2 tienen (entre otros), un atributo mutuo (con tipo Long), llamado attributeSame).

ahora mismo, lo hago así:

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;
}

Pero creo que hay una manera mejor y más rápida de hacer esto :) ¿Alguien puede proponerlo?

¡Gracias!

Si solo necesita probar la igualdad básica, esto se puede hacer con el JDK básico sin modificar las listas de entrada en una línea

!Collections.disjoint(list1, list2);

Si necesita probar una propiedad específica, es más difícil. Recomendaría, por defecto,

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

... que recopila los distintos valores list2y prueba la list1presencia de cada valor .

Puede utilizar Apache Commons CollectionUtils :

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

Esto supone que ha sobrecargado correctamente la funcionalidad de iguales para sus objetos personalizados.

Para acortar la lógica de Narendra, puede usar esto:

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

Hay un método para Collectionnombrar retainAllpero que tiene algunos efectos secundarios para su referencia

Conserva solo los elementos de esta lista que están contenidos en la colección especificada (operación opcional). En otras palabras, elimina de esta lista todos sus elementos que no están contenidos en la colección especificada.

Verdadero si esta lista cambió como resultado de la llamada

Es como

boolean b = list1.retainAll(list2);

La respuesta de Loius es correcta, solo quiero agregar un ejemplo:

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

forma más rápida requerirá espacio adicional.

Por ejemplo:

1. ponga todos los elementos en una lista en un HashSet (debe implementar la función hash usted mismo para usar object.getAttributeSame ())

2. Revise la otra lista y verifique si algún elemento está en el HashSet.

De esta forma, cada objeto se visita como máximo una vez. y HashSet es lo suficientemente rápido para verificar o insertar cualquier objeto en O (1).

Según JavaDoc para .contains(Object obj):

Devuelve verdadero si esta lista contiene el elemento especificado. Más formalmente, devuelve verdadero si y solo si esta lista contiene al menos un elemento e tal que (o == null? E == null: o.equals (e)).

Entonces, si anula su .equals()método para su objeto dado, debería poder hacer:if(list1.contains(object2))...

Si los elementos serán únicos (es decir. Tener diferentes atributos) que podría invalidar la .equals()e .hashcode()y almacenar todo en HashSets. Esto le permitirá comprobar si uno contiene otro elemento en tiempo constante.

para hacerlo más rápido, puede agregar un descanso; de esa manera, el bucle se detendrá si se encuentra establecido en verdadero:

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;
}

Si tuviera mapas en lugar de listas con como claves el atributo Igual, podría verificar más rápido un valor en un mapa si hay un valor correspondiente en el segundo mapa o no.

¿Puede definir el tipo de datos que tiene? ¿es big data? esta ordenado? Creo que debe considerar diferentes enfoques de eficiencia en función de los datos.

Por ejemplo, si sus datos son grandes y no están clasificados, puede intentar iterar las dos listas juntas por índice y almacenar cada atributo de lista en otro asistente de lista. luego podría verificar los atributos actuales en las listas de ayuda.

buena suerte

editado: y no recomendaría sobrecargar iguales. es peligroso y probablemente en contra de su objeto oop significado.

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

Con java 8, podemos hacer lo siguiente para verificar si una lista contiene algún elemento de otra lista

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

Si desea verificar si un elemento existe en una lista, use el método contiene.

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