Intersection et l'union de ArrayLists en Java

Voici une plaine de mise en œuvre sans l'aide d'une tierce-partie de la bibliothèque. Principal avantage sur les retainAll, removeAll et addAll est que ces méthodes ne pas modifier l'original listes d'entrée pour les méthodes.

public class Test {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<String>(Arrays.asList("B", "C", "D", "E", "F"));

        System.out.println(new Test().intersection(list1, list2));
        System.out.println(new Test().union(list1, list2));
    }

    public <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<T>();

        set.addAll(list1);
        set.addAll(list2);

        return new ArrayList<T>(set);
    }

    public <T> List<T> intersection(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if(list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

Ce post est assez vieux, mais néanmoins, il a été le premier popping up sur google lors de la recherche pour ce sujet.

Je veux donner une mise à jour à l'aide de Java 8 flux de travail (essentiellement) la même chose en une seule ligne:

List<T> intersect = list1.stream()
    .filter(list2::contains)
    .collect(Collectors.toList());

List<T> union = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

Si quelqu'un a une meilleure, plus rapide solution faites le moi savoir, mais cette solution est une belle chemise qui peuvent être facilement inclus dans une méthode sans ajout inutile helper de classe, de méthode et de toujours garder la lisibilité.

Unions et intersections défini que pour les jeux, et non pas des listes. Comme vous l'avez mentionné.

Vérifier goyave bibliothèque pour les filtres. Aussi goyave offre de réelles les intersections et les syndicats

 static <E> Sets.SetView<E >union(Set<? extends E> set1, Set<? extends E> set2)
 static <E> Sets.SetView<E> intersection(Set<E> set1, Set<?> set2)

La solution marqué n'est pas efficace. Il a un O(n^2) le temps de la complexité. Ce que nous pouvons faire est de trier les deux listes, et l'exécution d'un algorithme d'intersection comme celui ci-dessous.

private  static ArrayList<Integer> interesect(ArrayList<Integer> f, ArrayList<Integer> s) { 
    ArrayList<Integer> res = new ArrayList<Integer>();

    int i = 0, j = 0; 
    while (i != f.size() && j != s.size()) { 

        if (f.get(i) < s.get(j)) {
            i ++;
        } else if (f.get(i) > s.get(j)) { 
            j ++;
        } else { 
            res.add(f.get(i)); 
            i ++;  j ++;
        }
    }


    return res; 
}

Celui-ci a une complexité de O(n log n + n), qui est en O(n log n).
L'union se fait de la même manière. Assurez-vous de faire les modifications appropriées sur l'if-elseif-else.

Vous pouvez également utiliser des itérateurs si vous voulez (je sais qu'ils sont plus efficaces en C++, je ne sais pas si c'est le cas en Java ainsi).

Ici est une façon de comment vous pouvez faire une intersection avec le cours d'eau (n'oubliez pas que vous devez utiliser java 8 pour les cours d'eau):

List<foo> fooList1 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<foo> fooList2 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
fooList1.stream().filter(f -> fooList2.contains(f)).collect(Collectors.toList());

Un exemple pour les listes de types différents. Si vous avez une relation entre les foo et bar, et vous pouvez obtenir un bar-objet de foo que vous pouvez modifier vos flux:

List<foo> fooList = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<bar> barList = new ArrayList<>(Arrays.asList(new bar(), new bar()));

fooList.stream().filter(f -> barList.contains(f.getBar()).collect(Collectors.toList());

Vous pouvez utiliser des communes-collections4 CollectionUtils

Collection<Integer> collection1 = Arrays.asList(1, 2, 4, 5, 7, 8);
Collection<Integer> collection2 = Arrays.asList(2, 3, 4, 6, 8);

Collection<Integer> intersection = CollectionUtils.intersection(collection1, collection2);
System.out.println(intersection); //[2, 4, 8]

Collection<Integer> union = CollectionUtils.union(collection1, collection2);
System.out.println(union); //[1, 2, 3, 4, 5, 6, 7, 8]

Collection<Integer> subtract = CollectionUtils.subtract(collection1, collection2);
System.out.println(subtract); //[1, 5, 7]

Si les objets de la liste sont hashable (c'est à dire avoir une vie décente hashCode et equals fonction), de la manière la plus rapide de l'approche entre les tables env. taille > 20 est de construire un HashSet pour la plus grande des deux listes.

public static <T> ArrayList<T> intersection(Collection<T> a, Collection<T> b) {
    if (b.size() > a.size()) {
        return intersection(b, a);
    } else {
        if (b.size() > 20 && !(a instanceof HashSet)) {
            a = new HashSet(a);
        }
        ArrayList<T> result = new ArrayList();
        for (T objb : b) {
            if (a.contains(objb)) {
                result.add(objb);
            }
        }
        return result;
    }
}

Intersection de deux de la liste d'objet différent fondé sur la common key - Java 8

 private List<User> intersection(List<User> users, List<OtherUser> list) {

        return list.stream()
                .flatMap(OtherUser -> users.stream()
                        .filter(user -> user.getId()
                                .equalsIgnoreCase(OtherUser.getId())))
                .collect(Collectors.toList());
    }

D'abord, je suis de copier toutes les valeurs de tableaux dans un seul tableau, puis je suis en supprimant les doublons valeurs dans le tableau. La ligne 12, en expliquant si même nombre se produisent plus que temps puis mettre de poubelles supplémentaires valeur en "j" de la position. À la fin, à traverser de début et de fin et de vérifier si même la valeur d'ordures se produire, puis jetez-le.

public class Union {
public static void main(String[] args){

    int arr1[]={1,3,3,2,4,2,3,3,5,2,1,99};
    int arr2[]={1,3,2,1,3,2,4,6,3,4};
    int arr3[]=new int[arr1.length+arr2.length];

    for(int i=0;i<arr1.length;i++)
        arr3[i]=arr1[i];

    for(int i=0;i<arr2.length;i++)
        arr3[arr1.length+i]=arr2[i];
    System.out.println(Arrays.toString(arr3));

    for(int i=0;i<arr3.length;i++)
    {
        for(int j=i+1;j<arr3.length;j++)
        {
            if(arr3[i]==arr3[j])
                arr3[j]=99999999;          //line  12
        }
    }
    for(int i=0;i<arr3.length;i++)
    {
        if(arr3[i]!=99999999)
            System.out.print(arr3[i]+" ");
    }
}   
}

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
Set<T> set1, set2;
if (col1 instanceof Set) {
set1 = (Set) col1;
} else {
set1 = new HashSet<>(col1);
}
if (col2 instanceof Set) {
set2 = (Set) col2;
} else {
set2 = new HashSet<>(col2);
}
Set<T> intersection = new HashSet<>(Math.min(set1.size(), set2.size()));
for (T t : set1) {
if (set2.contains(t)) {
intersection.add(t);
}
}
return intersection;
}

Si le nombre de matches que je vérifie c'est tout d'abord le temps ou pas avec l'aide de "indexOf()" si le numéro correspond première fois, puis l'imprimer et l'enregistrer dans une chaîne de sorte que la prochaine fois même nombre de matches alors c'est de ne pas imprimer en raison en raison de "indexOf()" condition sera fausse.

class Intersection
{
public static void main(String[] args)
{
String s="";
int[] array1 = {1, 2, 5, 5, 8, 9, 7,2,3512451,4,4,5 ,10};
int[] array2 = {1, 0, 6, 15, 6, 5,4, 1,7, 0,5,4,5,2,3,8,5,3512451};
for (int i = 0; i < array1.length; i++)
{
for (int j = 0; j < array2.length; j++)
{
char c=(char)(array1[i]);
if(array1[i] == (array2[j])&&s.indexOf(c)==-1)
{    
System.out.println("Common element is : "+(array1[i]));
s+=c;
}
}
}    
}

}