web-dev-qa-db-fra.com

découvrir les éléments d'un arraylist qui n'est pas présent dans un autre arraylist

Je dois trouver le meilleur moyen de découvrir ces éléments qui ne sont pas présentés dans le deuxième tableau. supposer

Arraylist a,b, 

Arraylist a={1,2,3,4,5};
Arraylist b={2,3,4};

Donc, fondamentalement, ce que je veux, c'est de découvrir que les éléments de a qui ne sont pas présents dans arraylist b.

Alors, quelles sont les meilleures solutions pour y parvenir?

javaarrayslistcollectionsarraylist
45
arvin_codeHunk
List<Integer> c = new ArrayList<>(a);
c.removeAll(b);

Pensez également à utiliser des ensembles au lieu de listes.

77
Puce

Vous pouvez essayer removeAll:

List<Integer> notPresent = new ArrayList<Integer>(a);
notPresent.removeAll(b);
10
Nikita Beloglazov

Vous pouvez utiliser Apache Commons Collections , qui a une méthode explicite à cet effet:

public static void main(String[] args) {
    List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
    List<Integer> b = Arrays.asList(new Integer[] { 2, 3, 4 });
    Collection<Integer> aMinusB = CollectionUtils.subtract(a, b);
    System.out.println(aMinusB);
}

Le résultat imprimé est: [1, 5] .

Les bibliothèques Apache Commons sont bien testées et couramment utilisées pour étendre les fonctionnalités standard Java. Cette méthode particulière accepte Iterable comme paramètres, vous pouvez donc utiliser n'importe quel Collection vous Vous pouvez également mélanger différents types de collections:

public static void main(String[] args) {
    List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
    Set<Integer> b = new HashSet<Integer>(Arrays.asList(new Integer[] { 2, 3, 4 }));
    Collection<Integer> aMinusB = CollectionUtils.subtract(a, b);
    System.out.println(aMinusB);
}

Le résultat imprimé est le même, [1, 5] .

Découvrez le Javadoc ici .

Par souci d'exhaustivité, la bibliothèque Guava de Google ne dispose pas de cette fonctionnalité :

Collection *subtract*(Collection, Collection)
Pas d'équivalent - créez une ArrayList contenant a puis appelez remove dessus pour chaque élément de b.

Cependant, il implémente une méthode appelée Sets.difference() , que vous pouvez utiliser si vous préférez Guava et travaillez avec des ensembles:

public static void main(String[] args) {
    Set<Integer> a = new HashSet<Integer>(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 }));
    Set<Integer> b = new HashSet<Integer>(Arrays.asList(new Integer[] { 2, 3, 4 }));
    Set<Integer> aMinusB = Sets.difference(a, b);
    System.out.println(aMinusB);
}

Le résultat est tous les éléments dans a qui n'existent pas dans b (ie [1, 5] à nouveau ). Bien entendu, l'ordre n'est pas déterminé puisqu'il opère sur des décors.

7
Magnilex

voici une autre approche utilisant Java 8 -

a.stream().filter(b::contains).collect(Collectors.toList());
7
Rup

Utilisation org.Apache.commons.collections4.ListUtils

Étant donné

List<Integer> a = Arrays.asList(new Integer[]{  1,2,3,4,5});
List<Integer> b = Arrays.asList(new Integer[]{0,1,2,3});

Action

List<Integer> c = ListUtils.removeAll(b, a)

Résultat dans la liste c

4, 5
5
mika

Veuillez essayer comme ceci

for (Object o : a) {  
  if (!b.contains(o)) {  
    // this is not present
  }  
}
3
sunleo

Essaye ça:

 public static void main(String[] args) {
        List<Integer> a = new ArrayList<Integer>();
        List<Integer> b = new ArrayList<Integer>();
        List<Integer> exclusion = new ArrayList<Integer>();

        a.add(1);
        a.add(2);
        a.add(3);
        a.add(4);

        b.add(1);
        b.add(2);
        b.add(3);
        b.add(5);

        for (Integer x : a) {
            if (!b.contains(x)) {
                exclusion.add(x);
            }
        }

        for (Integer x : exclusion) {
            System.out.println(x);
        }

    }
1
Mawia

Parcourez une liste, puis vérifiez si chaque élément d'une autre liste à l'aide de contient .

1
NimChimpsky

Quelque chose comme ça. Si vous pensez qu'il peut y avoir des doublons dans a, vous pouvez essayer un autre type de Collection, comme un Set pour notPresent.

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

    for (Integer n : a){
     if (!b.contains(n)){
       notPresent.add(n);
     }
    }
1
Averroes

Essaye ça...

Utilisez la méthode contains() de List.

ArrayList<Integer> aList = new ArrayList<Integer>();

for (Integer i : a){

      if (!(b.contains(i))){

             aList.add(i);

       }

     else{
             continue;

      }

 }
0
Kumar Vivek Mitra