Common items in two lists

Question

I have two ArrayList objects with three integers each. I want to find a way to return the common elements of two lists. Does anyone know how to achieve this?

Answer 1

Use Collection#retainAll() .

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

If you want to avoid changes to listA , then you need to create a new one.

 List<Integer> common = new ArrayList<Integer>(listA); common.retainAll(listB); // common now contains only the elements which are contained in listA and listB. 

Answer 2

You can use intersection operations with ArrayList objects.

Something like that:

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

Now l3 should only have common elements between l1 and l2 .

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

Answer 3

Why reinvent the wheel? Use Commons Collections :

 CollectionUtils.intersection(java.util.Collection a, java.util.Collection b) 

Answer 4

Using Java 8 Stream.filter() in combination with 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()); 

Answer 5

 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 

Output [1, 5]

Answer 6

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

Answer 7

You can get common items between two lists using the "retainAll" method. This method will remove all unmatched items from the list to which it applies.

 Ex.: list.retainAll(list1); 

In this case, all elements that are not in list1 will be removed from the list and only those elements that are common to list and list1 will remain.

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

Exit:

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

NOTE. After applying retainAll to the list, the list contains a common element between list and list1.

Answer 8

 public <T> List<T> getIntersectOfCollections(Collection<T> first, Collection<T> second) { return first.stream() .filter(second::contains) .collect(Collectors.toList()); } 

Answer 9

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

Answer 10

If you want to do it yourself ..

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

Answer 11

Some of the answers above are similar but not the same, so we publish them as a new answer.

Decision:
1. Use a HashSet to store items that need to be removed
2. Add all list1 elements to the HashSet
3. Go through list2 and remove the elements from the HashSet that are present in list2 ==>, which are present in both list1 and list2.
4. Now loop through the HashSet and remove the elements from list1 (since we added all the elements of list1 for installation), finally, list1 has all the common elements
Note. We can add all the elements of list2, and in the third iteration we must remove the elements from list2.

Time complexity: O (n)
Cosmic complexity: O (n)

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

exit:

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

Answer 12

consider two lists L1 and L2

Using Java8, we can easily find out.

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