wake-up-neo.com

Gemeinsame Elemente in zwei Listen

Ich habe zwei ArrayList-Objekte mit jeweils drei ganzen Zahlen. Ich möchte einen Weg finden, um die gemeinsamen Elemente der beiden Listen zurückzugeben. Hat jemand eine Idee, wie ich das erreichen kann? 

78
zenitis

Verwenden Sie Collection#retainAll() .

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

Wenn Sie verhindern möchten, dass Änderungen in listA betroffen sind, müssen Sie eine neue erstellen.

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

Sie können Schnittoperationen mit Ihren ArrayList-Objekten festlegen.

Etwas wie das:

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

Jetzt sollte l3 nur gemeinsame Elemente zwischen l1 und l2 haben.

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

Warum das Rad neu erfinden? Verwenden Sie Commons Collections :

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

Verwendung der Stream.filter() -Methode von Java 8 in Kombination mit 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

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

Ausgabe [1, 5]

3
Rajeev Ranjan

Sie können die gemeinsamen Elemente zwischen zwei Listen mit der Methode "KeepAll" abrufen. Diese Methode entfernt alle nicht übereinstimmenden Elemente aus der Liste in Und wendet sie an.

Ex.: list.retainAll(list1);

In diesem Fall werden aus der Liste alle Elemente entfernt, die nicht in Liste1 enthalten sind, und es werden nur noch die Elemente übrig, die zwischen Liste und Liste1 üblich sind.

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

Ausgabe: 

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

ANMERKUNG: Nachdem "sich alle" auf die Liste angewendet hat, enthält die Liste ein gemeinsames Element zwischen List und list1.

3
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

Einige der obigen Antworten sind ähnlich, jedoch nicht identisch, so dass sie als neue Antwort veröffentlicht werden.

Lösung:
1. Verwenden Sie HashSet, um Elemente zu enthalten, die entfernt werden müssen
2. Fügen Sie alle Elemente von list1 zu HashSet hinzu
3. Liste2 durchlaufen und Elemente aus einem HashSet entfernen, die in list2 ==> vorhanden sind und in list1 und list2 vorhanden sind
4. Jetzt über HashSet iterieren und Elemente aus list1 entfernen (da wir alle Elemente von list1 zum Setzen hinzugefügt haben), schließlich hat list1 alle gemeinsamen Elemente
Hinweis: Wir können alle Elemente von Liste2 hinzufügen. In einer dritten Iteration sollten wir Elemente aus Liste2 entfernen. 

Zeitkomplexität: O (n)
Raumkomplexität: 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));

ausgabe:

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

Wenn Sie es selbst machen wollen ..

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

betrachte zwei Listen L1 und L2

Mit Java8 können wir es leicht herausfinden

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

0
AVN