Intersection entre deux tableaux entiers

1. Vue d'ensemble

Dans ce rapide didacticiel, nous verrons commentcompute the intersection between two Integer arrays ‘a' et‘b'.

Nous allons également nous concentrer sur la manière de gérer les entrées en double.

Pour la mise en œuvre, nous utiliseronsStreams.

2. Prédicat d'adhésion pour un tableau

L'intersection de deux ensembles est par définition un ensemble avec toutes les valeurs d'un, qui font également partie du deuxième ensemble.

Par conséquent, nous avons besoin d'unFunction ou plutôt d'unPredicate pour décider de l'appartenance au second tableau. PuisqueList fournit une telle méthode prête à l'emploi, nous allons la transformer enList:

Predicate isContainedInB = Arrays.asList(b)::contains;

3. Construire l'intersection

Pour construire le tableau résultant, nous allons considérer les éléments du premier ensemble séquentiellement et vérifier s'ils sont également contenus dans le second tableau. Puis nous allons créer un nouveau tableau basé sur cela.

LeStream API nous fournit les méthodes nécessaires. First, we’ll create a Stream, then filter with the membership-Predicate and finally we’ll create a new array:

public static Integer[] intersectionSimple(Integer[] a, Integer[] b){
    return Stream.of(a)
      .filter(Arrays.asList(b)::contains)
      .toArray(Integer[]::new);
}

4. Entrées en double

Puisque les tableaux en Java ne sont pas une implémentation deSet, nous sommes confrontés au problème des entrées en double dans l'entrée puis dans le résultat. Notez que le nombre d'occurrences dans le résultat dépend des occurrences dans le premier paramètre.

Mais pour les ensembles, les éléments ne doivent pas se produire plusieurs fois. We can archive this by using the distinct() method:

public static Integer[] intersectionSet(Integer[] a, Integer[] b){
    return Stream.of(a)
      .filter(Arrays.asList(b)::contain)
      .distinct()
      .toArray(Integer[]::new);
}

La longueur de l'intersection ne dépend donc plus de l'ordre des paramètres.

Cependant, l'intersection d'un tableau avec lui-même peut ne plus être le tableau puisque nous supprimons les entrées doubles.

5. Intersection multiset

Une notion plus générale, qui permet plusieurs entrées égales, est multisets. Pour eux, l'intersection est alors définie par le nombre minimal d'occurrences en entrée. Ainsi, nos membres -Predicate doivent garder le score à quelle fréquence nous ajoutons un élément au résultat.

La méthoderemove() peut être utilisée pour cela, qui retourne l'appartenance et consomme les éléments. Ainsi, une fois que tous les éléments égaux en‘b' sont consommés, aucun élément égal n'est ajouté au résultat:

public static Integer[] intersectionSet(Integer[] a, Integer[] b){
    return Stream.of(a)
      .filter(new LinkedList<>(Arrays.asList(b))::remove)
      .toArray(Integer[]::new);
}

Puisque le sAPIArrays ne renvoie qu'unList, immuable, nous devons en générer un dédié mutable.

6. Conclusion

Dans cet article, nous avons vu comment utiliser les méthodescontains etremove pour implémenter une intersection pour deux tableaux en Java.

Toutes les implémentations, extraits de code et tests peuvent être trouvés dans notreGithub repository - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

TOC

Intersection entre deux tableaux entiers