web-dev-qa-db-fra.com

Eléments communs dans deux listes

J'ai deux objets ArrayList avec trois entiers chacun. Je veux trouver un moyen de retourner les éléments communs des deux listes. Quelqu'un a-t-il une idée de la façon dont je peux atteindre cet objectif? 

javaarraylistelement
78
zenitis

Utilisez Collection#retainAll() .

listA.retainAll(listB);
// listA now contains only the elements which are also contained in listB.

Si vous souhaitez éviter que des modifications ne soient affectées dans listA, vous devez en créer un nouveau.

List<Integer> common = new ArrayList<Integer>(listA);
common.retainAll(listB);
// common now contains only the elements which are contained in listA and listB.
137
BalusC

Vous pouvez utiliser des opérations de définition d'intersection avec vos objets ArrayList.

Quelque chose comme ça:

List<Integer> l1 = new ArrayList<Integer>();

l1.add(1);
l1.add(2);
l1.add(3);

List<Integer> l2= new ArrayList<Integer>();
l2.add(4);
l2.add(2);
l2.add(3);

System.out.println("l1 == "+l1);
System.out.println("l2 == "+l2);

List<Integer> l3 = new ArrayList<Integer>(l2);
l3.retainAll(l1);

    System.out.println("l3 == "+l3);
    System.out.println("l2 == "+l2);

Maintenant, l3 ne devrait avoir que des éléments communs entre l1 et l2.

CONSOLE OUTPUT
l1 == [1, 2, 3]
l2 == [4, 2, 3]
l3 == [2, 3]
l2 == [4, 2, 3]
34
Pablo Santa Cruz

Pourquoi réinventer la roue? Utiliser Collections communes :

CollectionUtils.intersection(Java.util.Collection a, Java.util.Collection b)
26
user647772

Utilisation de la méthode Stream.filter() de Java 8 en combinaison avec List.contains() :

import static Java.util.Arrays.asList;
import static Java.util.stream.Collectors.toList;

/* ... */

List<Integer> list1 = asList(1, 2, 3, 4, 5);
List<Integer> list2 = asList(1, 3, 5, 7, 9);

List<Integer> common = list1.stream().filter(list2::contains).collect(toList());
15
Robby Cornelissen

 enter image description here 

            List<String> lista =new ArrayList<String>();
            List<String> listb =new ArrayList<String>();

            lista.add("Isabella");
            lista.add("Angelina");
            lista.add("Pille");
            lista.add("Hazem");

            listb.add("Isabella");
            listb.add("Angelina");
            listb.add("Bianca");

            // Create an aplusb list which will contain both list (list1 and list2) in which common element will occur twice 
            List<String> listapluslistb =new ArrayList<String>(lista);    
            listapluslistb.addAll(listb);

            // Create an aunionb set which will contain both list (list1 and list2) in which common element will occur once
            Set<String> listaunionlistb =new HashSet<String>(lista);
            listaunionlistb.addAll(listb);

            for(String s:listaunionlistb)
            {
                listapluslistb.remove(s);
            }
            System.out.println(listapluslistb);
4
Pawan Kumar Baranwal
List<Integer> listA = new ArrayList<>();
    listA.add(1);
    listA.add(5);
    listA.add(3);
    listA.add(4);   

List<Integer> listB = new ArrayList<>();
    listB.add(1);
    listB.add(5);
    listB.add(6);
    listB.add(7);
System.out.println(listA.stream().filter(listB::contains).collect(Collectors.toList()));


Java 1.8 Stream API Solutions

Sortie [1, 5]

3
Rajeev Ranjan

Vous pouvez obtenir les éléments communs entre deux listes à l’aide de la méthode "RetentionAll". Cette méthode supprimera tous les éléments sans correspondance de la liste à Auxquels elle s'applique.

Ex.: list.retainAll(list1);

Dans ce cas de la liste, tous les éléments qui ne sont pas dans la liste1 seront supprimés et il ne restera que ceux qui sont communs à list et à.

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(13);
list.add(12);
list.add(11);

List<Integer> list1 = new ArrayList<>();
list1.add(10);
list1.add(113);
list1.add(112);
list1.add(111);
//before retainAll
System.out.println(list);
System.out.println(list1);
//applying retainAll on list
list.retainAll(list1);
//After retainAll
System.out.println("list::"+list);
System.out.println("list1::"+list1);

Sortie: 

[10, 13, 12, 11]
[10, 113, 112, 111]
list::[10]
list1::[10, 113, 112, 111]

REMARQUE: Une fois que retenueAll a été appliqué à la liste, la liste contient un élément commun entre List et list1.

3
Vivek Kumar Sihare
public <T> List<T> getIntersectOfCollections(Collection<T> first, Collection<T> second) {
        return first.stream()
                .filter(second::contains)
                .collect(Collectors.toList());
    }
2
Ruslan Taghiyev
    // Create two collections:
    LinkedList<String> listA =  new LinkedList<String>();
    ArrayList<String> listB =  new ArrayList<String>();

    // Add some elements to listA:
    listA.add("A");
    listA.add("B");
    listA.add("C");
    listA.add("D");

    // Add some elements to listB:
    listB.add("A");
    listB.add("B");
    listB.add("C");

    // use 

    List<String> common = new ArrayList<String>(listA);
    // use common.retainAll

    common.retainAll(listB);

    System.out.println("The common collection is : " + common);
0
Ryagh

Certaines des réponses ci-dessus sont similaires, mais pas identiques, alors publiez-les comme une nouvelle réponse.

Solution:
1. Utilisez HashSet pour contenir des éléments à supprimer
2. Ajouter tous les éléments de list1 à HashSet
3. itérer list2 et supprimer des éléments d'un HashSet présents dans list2 ==> et présents dans list1 et list2
4. Maintenant, parcourez HashSet et supprimez les éléments de list1 (puisque nous avons ajouté tous les éléments de list1 à set), enfin, list1 a tous les éléments communs
Note: Nous pouvons ajouter tous les éléments de list2 et dans une 3ème itération, nous devrions supprimer des éléments de list2. 

Complexité temporelle: O (n)
Complexité de l'espace: O(n) 

Code:

import com.Sun.tools.javac.util.Assert;
import org.Apache.commons.collections4.CollectionUtils;

    List<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);
    list1.add(5);

    List<Integer> list2 = new ArrayList<>();
    list2.add(1);
    list2.add(3);
    list2.add(5);
    list2.add(7);
    Set<Integer> toBeRemoveFromList1 = new HashSet<>(list1);
    System.out.println("list1:" + list1);
    System.out.println("list2:" + list2);
    for (Integer n : list2) {
        if (toBeRemoveFromList1.contains(n)) {
            toBeRemoveFromList1.remove(n);
        }
    }
    System.out.println("toBeRemoveFromList1:" + toBeRemoveFromList1);
    for (Integer n : toBeRemoveFromList1) {
        list1.remove(n);
    }
    System.out.println("list1:" + list1);
    System.out.println("collectionUtils:" + CollectionUtils.intersection(list1, list2));
    Assert.check(CollectionUtils.intersection(list1, list2).containsAll(list1));

sortie:

list1:[1, 2, 3, 4, 5]
list2:[1, 3, 5, 7]
toBeRemoveFromList1:[2, 4]
list1:[1, 3, 5]
collectionUtils:[1, 3, 5]
0
dkb

Si vous voulez le faire vous-même ..

List<Integer> commons = new ArrayList<Integer>();

for (Integer igr : group1) {
    if (group2.contains(igr)) {
        commons.add(igr);
    }
}

System.out.println("Common elements are :: -");
for (Integer igr : commons) {
    System.out.println(" "+igr);
}
0
chetan rami

considérer deux listes L1 et L2

En utilisant Java8, nous pouvons facilement le découvrir

L1.stream().filter(L2::contains).collect(Collectors.toList())

0
AVN