So entfernen Sie die gemeinsamen Werte von zwei array-Liste

Wie können wir entfernen Sie gemeinsame Werte von zwei ArrayList.
wir betrachten habe ich zwei Arraylist-wie unten gezeigt

ArrayList1= [1,2,3,4]
ArrayList1= [2,3,4,6,7]

Hätte ich gern ein Ergebnis wie

ArrayListFinal= [1,6,7]

Könnte jemand bitte mir helfen?

Versuchen Sie es, dann werden wir Ihnen helfen.
so, das Sie entfernen möchten gemeinsame Elemente
Hinweis: Wenn Sie Lesen, die api für die Liste, die Sie werden lösen Ihr problem auf Ihre eigene.
Sie können leicht Antwort für diese Frage hättest du gegoogelt atleast.
mögliche Duplikate von Gemeinsame Elemente in zwei Listen
Der link, den Sie ist genau das Gegenteil von dem, was der OP will.
Ich lese zu schnell, in der Tat -, dass man besser ist: stackoverflow.com/questions/11646913/... - Strich, mit einer 10-Sekunden-Suche liefert das Ergebnis.

InformationsquelleAutor Gautam | 2013-03-22

38

Hier ist ein Algorithmus, der Sie Folgen konnte, die Aufgabe zu erfüllen:
- Konstrukt einer Vereinigung der beiden arrays
- Konstruieren Sie den Schnittpunkt der beiden arrays
- Subtrahieren Sie die Kreuzung, von der union um dein Ergebnis zu bekommen
Java collections Unterstützung addAll, removeAll, und retainAll. Verwenden addAll zu konstruieren, die Gewerkschaften, die retainAll für die Konstruktion von Kreuzungen und removeAll für die Subtraktion, wie diese:
```
//Make the two lists
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(2, 3, 4, 6, 7);
//Prepare a union
List<Integer> union = new ArrayList<Integer>(list1);
union.addAll(list2);
//Prepare an intersection
List<Integer> intersection = new ArrayList<Integer>(list1);
intersection.retainAll(list2);
//Subtract the intersection from the union
union.removeAll(intersection);
//Print the result
for (Integer n : union) {
    System.out.println(n);
}
```
- Vielen Dank für die Antwort...das, was ich suchte :):)
- Hinweis: Sie müssen den @override equals() für diese zu arbeiten.
InformationsquelleAutor dasblinkenlight

Sind Sie eigentlich Fragen, für die Symmetrische Differenz.

List<Integer> aList = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
List<Integer> bList = new ArrayList<>(Arrays.asList(2, 3, 4, 6, 7));
//Union is all from both lists.
List<Integer> union = new ArrayList(aList);
union.addAll(bList);
//Intersection is only those in both.
List<Integer> intersection = new ArrayList(aList);
intersection.retainAll(bList);
//Symmetric difference is all except those in both.    
List<Integer> symmetricDifference = new ArrayList(union);
symmetricDifference.removeAll(intersection);

System.out.println("aList: " + aList);
System.out.println("bList: " + bList);
System.out.println("union: " + union);
System.out.println("intersection: " + intersection);
System.out.println("**symmetricDifference: " + symmetricDifference+"**");

Drucke:

aList: [1, 2, 3, 4]
bList: [2, 3, 4, 6, 7]
union: [1, 2, 3, 4, 2, 3, 4, 6, 7]
intersection: [2, 3, 4]
**symmetricDifference: [1, 6, 7]**

Vielen Dank für die Antwort...das, was ich suchte :):)
Was muss ich tun, wenn ich will eine Ausgabe wie [1, 2, 3, 4,6,7] ??
Das ist die union des symmetric difference und die intersection.
Ich möchte nur, dass die Reihenfolge gleich sein. Ich bin immer [2.3,4,1,6,7] oder [1,6,7,2,3,4]. Die Logik, die ich angewandt hatte, ist als folllows (aList - Kreuzung) + (bList - Kreuzung). Und Es war arbeiten [1,2,3,4,6,7]. Vielen Dank 🙂

InformationsquelleAutor OldCurmudgeon

Können Sie so etwas wie dieses:

    ArrayList <Integer> first = new ArrayList <Integer> ();
    ArrayList <Integer> second = new ArrayList <Integer> ();
    ArrayList <Integer> finalResult = new ArrayList <Integer> ();

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

    second.add(2);
    second.add(3);
    second.add(4);
    second.add(6);
    second.add(7);

    for (int i = 0; i < first.size(); i++){

        if (!second.contains(first.get(i))){

            finalResult.add(first.get(i));
        }
    }


    for (int j = 0; j < second.size(); j++){

        if (!first.contains(second.get(j))){

            finalResult.add(second.get(j));
        }

    }

Ich habe gerade aufgefüllt, zwei ArrayLists, wie Sie beschrieben Sie in Ihrem post, und ich habe Sie beide für unterschiedliche Elemente; wenn ein solches element/s wurde/gefunden wurden, füge ich Ihnen die finalResult ArrayList.

Ich hoffe, es wird Ihnen helfen 🙂

InformationsquelleAutor Survivor

SetList<Integer> A = new SetList<Integer>();
A.addAll({1,2,3,4});

SetList<Integer> B = new SetList<Integer>();
B.addAll({2,3,4,6,7});

Integer a = null;

for (int i=0; i<A.size(); i++)
{
    a = A.get(i);

    if (B.contains(a)
    {
        B.remove(a);
        A.remove(a);
        i--;
    }
}

SetList<Integer> final = new SetList<Integer>();
final.addAll(A);
final.addAll(B);

//final = { 1, 6, 7 }

InformationsquelleAutor Khaled.K

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.