Vérifiez si une liste contient un élément de l'autre

J'ai deux listes avec des objets différents.

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

Je veux vérifier si l'élément de list1 existe dans list2, basé sur un attribut spécifique (Object1 et Object2 ont (entre autres), un attribut mutuel (de type Long), nommé attributeSame).

maintenant, je le fais comme ceci:

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

Mais je pense qu'il existe un moyen meilleur et plus rapide de le faire :) Quelqu'un peut-il le proposer?

Merci!

Si vous avez juste besoin de tester l'égalité de base, cela peut être fait avec le JDK de base sans modifier les listes d'entrée sur une seule ligne

!Collections.disjoint(list1, list2);

Si vous avez besoin de tester une propriété spécifique, c'est plus difficile. Je recommanderais, par défaut,

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

... qui recueille les valeurs distinctes list2et teste chaque valeur list1pour la présence.

Vous pouvez utiliser Apache Commons CollectionUtils :

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

Cela suppose que vous avez correctement surchargé la fonctionnalité d'égalité pour vos objets personnalisés.

Pour raccourcir la logique de Narendra, vous pouvez utiliser ceci:

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

Il existe une méthode de Collectionnommer retainAllmais ayant des effets secondaires pour vous référence

Conserve uniquement les éléments de cette liste qui sont contenus dans la collection spécifiée (opération facultative). En d'autres termes, supprime de cette liste tous ses éléments qui ne sont pas contenus dans la collection spécifiée.

true si cette liste a changé suite à l'appel

C'est comme

boolean b = list1.retainAll(list2);

La réponse de Loius est correcte, je veux juste ajouter un exemple:

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

plus rapide nécessitera un espace supplémentaire.

Par exemple:

1. mettre tous les éléments dans une liste dans un HashSet (vous devez implémenter la fonction de hachage par vous-même pour utiliser object.getAttributeSame ())

2. Parcourez l'autre liste et vérifiez si un élément se trouve dans le HashSet.

De cette manière, chaque objet est visité au plus une fois. et HashSet est assez rapide pour vérifier ou insérer n'importe quel objet dans O (1).

Selon le JavaDoc pour .contains(Object obj):

Renvoie true si cette liste contient l'élément spécifié. Plus formellement, renvoie true si et seulement si cette liste contient au moins un élément e tel que (o == null? E == null: o.equals (e)).

Donc, si vous remplacez votre .equals()méthode pour votre objet donné, vous devriez pouvoir faire:if(list1.contains(object2))...

Si les éléments sont uniques (c'est-à-dire qu'ils ont des attributs différents), vous pouvez remplacer .equals()et .hashcode()et tout stocker dans HashSets. Cela vous permettra de vérifier si l'un contient un autre élément en temps constant.

pour le rendre plus rapide, vous pouvez ajouter une pause; de cette façon, la boucle s'arrêtera si found est défini sur true:

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 vous aviez des cartes au lieu de listes avec comme clés l'attributSame, vous pourriez rechercher plus rapidement une valeur dans une carte s'il existe une valeur correspondante dans la deuxième carte ou non.

Pouvez-vous définir le type de données que vous détenez? est-ce du big data? est-il trié? Je pense que vous devez envisager différentes approches d'efficacité en fonction des données.

Par exemple, si vos données sont volumineuses et non triées, vous pouvez essayer d'itérer les deux listes ensemble par index et stocker chaque attribut de liste dans un autre assistant de liste. alors vous pouvez recouper les attributs actuels dans les listes d'aide.

bonne chance

édité: et je ne recommanderais pas de surcharger les égaux. son dangereux et probablement contre votre sens objet 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

Avec java 8, nous pouvons faire comme ci-dessous pour vérifier si une liste contient un élément d'une autre liste

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

Si vous souhaitez vérifier si un élément existe dans une liste, utilisez la méthode contains.

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