Comment faire pour supprimer des valeurs communes à partir de deux tableau liste

Comment peut-on supprimer des valeurs communes à partir de deux ArrayList.
considérons j'ai deux Arraylist comme indiqué ci-dessous

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

Je voudrais avoir le résultat que

ArrayListFinal= [1,6,7]

Quelqu'un pourrait-il svp m'aider?

Essayez-la, puis nous allons vous aider.
si vous souhaitez supprimer des éléments communs
Astuce: Si vous lisez l'api pour la Liste que vous aurez à résoudre votre problème sur votre propre.
vous pouvez facilement obtenir de réponse à cette question si vous avez googlé atleast.
double possible de d'éléments Communs aux deux listes

OriginalL'auteur Gautam | 2013-03-22

33

Ici est un algorithme que vous pourriez suivre pour accomplir la tâche:
- Construire une union des deux ensembles
- Construire l'intersection de deux tableaux
- Soustraire à l'intersection de l'union pour obtenir votre résultat
Java collections de soutien addAll, removeAll, et retainAll. Utilisation addAll de construire des syndicats, retainAll pour construire les intersections et removeAll pour la soustraction, comme ceci:
```
//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);
}
```
Merci pour la réponse...c'est ce que je cherchais :):)
remarque: vous devez @override equals() pour que cela fonctionne.

OriginalL'auteur dasblinkenlight

Vous êtes en train de demander à la Symétrique Différence.

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+"**");

Imprime:

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]**

Merci pour la réponse...c'est ce que je cherchais :):)
Ce que j'ai à faire si je veux une sortie comme [1, 2, 3, 4,6,7] ??
C'est le union de la symmetric difference et la intersection.
Je veux juste que la commande est la même. Je suis arriver [2.3,4,1,6,7] ou [1,6,7,2,3,4]. La logique que j'avais appliqué est comme folllows (accédez à la liste - intersection) + (bList - intersection). Et C'est en travaillant [1,2,3,4,6,7]. Merci 🙂

OriginalL'auteur OldCurmudgeon

Vous pouvez utiliser quelque chose comme ceci:

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

    }

Je viens peuplée deux ArrayLists comme vous l'avez décrit dans votre post, et j'ai vérifié sur deux éléments distincts; si un tel élément/s a/ont été trouvés, je les ajouter à la finalResult ArrayList.

J'espère que ça vous aidera 🙂

OriginalL'auteur 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 }

OriginalL'auteur Khaled.K

Vous devez vous connecter pour publier un commentaire.