Schnittmenge und Vereinigung von ArrayLists in Java

Hier ist eine schlichte Umsetzung ohne Verwendung jeglicher third-party Bibliothek. Hauptvorteil gegenüber retainAllremoveAll und addAll ist, dass diese Methoden nicht ändern den ursprünglichen Listen-input, um die Methoden.

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

InformationsquelleAutor der Antwort adarshr

Dieser Beitrag ist ziemlich alt, aber dennoch war es das erste aufspringen auf google bei der Suche zum Thema.

Möchte ich ein update mit Java 8 streams zu tun (im Grunde) die gleiche Sache in einer einzigen Zeile:

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

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

Wenn jemand eine bessere/schnellere Lösung lassen Sie mich wissen, aber diese Lösung ist ein schöner one-liner können werden leicht in eine Methode ohne eine unnötige Hilfsklasse/- Methode und immer noch halten die Lesbarkeit.

InformationsquelleAutor der Antwort Fat_FS

Gewerkschaften und Kreuzungen definiert nur für Gruppen, keine Listen. Wie Sie bereits erwähnt.

Überprüfen Guave Bibliothek für Filter. Auch guava bietet Echtzeit Kreuzungen und Gewerkschaften

 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)

InformationsquelleAutor der Antwort Stan Kurilin

Die Lösung markiert, ist nicht effizient. Es hat ein O(n^2) Zeit-Komplexität. Was wir tun können, ist das Sortieren der beiden Listen, und das ausführen einer Kreuzung Algorithmus, wie der unten.

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

Dieser hat eine Komplexität von O(n log n + n) ist in O(n log n).
Die union ist in einer ähnlichen Art und Weise. Nur sicherstellen, dass Sie die geeigneten änderungen an der if-elseif-else-Anweisungen.

Können Sie auch verwenden, Iteratoren, wenn Sie wollen (ich weiß, Sie sind effizienter in C++, ich weiß nicht, ob dies wahr ist in Java auch).

InformationsquelleAutor der Antwort AJed

Hier ist ein Weg, wie Sie tun können, eine Kreuzung mit streams (denken Sie daran, dass Sie auf java 8 streams):

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());

Beispiel für Listen mit verschiedenen Typen. Wenn Sie eine realtion zwischen foo und bar und Sie können sich ein bar-Objekt von foo als können Sie ändern Ihre stream:

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());

InformationsquelleAutor der Antwort Deutro

In Java 8, ich verwende einfache Hilfsmethoden wie diese:

public static <T> Collection<T> getIntersection(Collection<T> coll1, Collection<T> coll2){
    return Stream.concat(coll1.stream(), coll2.stream())
            .filter(coll1::contains)
            .filter(coll2::contains)
            .collect(Collectors.toSet());
}

public static <T> Collection<T> getMinus(Collection<T> coll1, Collection<T> coll2){
    return coll1.stream().filter(not(coll2::contains)).collect(Collectors.toSet());
}

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

InformationsquelleAutor der Antwort Pascalius

Können Sie commons-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]

InformationsquelleAutor der Antwort xxg

Endlösung:

//all sorted items from both
public <T> List<T> getListReunion(List<T> list1, List<T> list2) {
    Set<T> set = new HashSet<T>();
    set.addAll(list1);
    set.addAll(list2);
    return new ArrayList<T>(set);
}

//common items from both
public <T> List<T> getListIntersection(List<T> list1, List<T> list2) {
    list1.retainAll(list2);
    return list1;
}

//common items from list1 not present in list2
public <T> List<T> getListDifference(List<T> list1, List<T> list2) {
    list1.removeAll(list2);
    return list1;
}

InformationsquelleAutor der Antwort Choletski

Wenn Sie Ihre Daten in Gruppen, die Sie nutzen könnten Guave ist Legt fest Klasse.

InformationsquelleAutor der Antwort Neil