CODEWITHSUNDEEP
javalistcollectionsarraylist
Gautam
Gautam

Reputation: 3386

How to remove common values from two array lists

How can we remove common values from two ArrayLists?

Let’s consider I have two Arraylist as shown below:

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

I would like to have result as:

ArrayListFinal = [1,6,7]

How can I do it?

Upvotes: 25

Views: 68933

Answers (4)

Survivor
Survivor

Reputation: 672

You can use something like this:

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

}

I just populated two ArrayLists as you described them in your post, and I checked on both of them for distinct elements; if such element/s was/were found, I add them to the finalResult ArrayList.

Upvotes: 4

OldCurmudgeon
OldCurmudgeon

Reputation: 65811

You are actually asking for the Symmetric Difference.

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

Prints:

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

Upvotes: 22

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726599

Here is an algorithm that you could follow to accomplish the task:

  • Construct a union of the two arrays
  • Construct the intersection of the two arrays
  • Subtract the intersection from the union to get your result

Java collections support addAll, removeAll, and retainAll. Use addAll to construct unions, retainAll for constructing intersections, and removeAll for subtraction, like this:

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

Upvotes: 47

Khaled.K
Khaled.K

Reputation: 5940

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 }

Upvotes: 0

Related Questions