Find common elements in two ArrayLists in Java
Last Updated :
05 Dec, 2022
Prerequisite: ArrayList in Java
Given two ArrayLists, the task is to print all common elements in both the ArrayLists in Java .
Examples:
Input: List1 = ["Hii", "Geeks", "for", "Geeks"],
List2 = ["Hii", "Geeks", "Gaurav"]
Output: [Hii, Geeks, Geeks]
Input: List1 = ["a", "b", "c", "d", "e", "f"],
List2 = ["b", "d", "e", "h", "g", "c"]
Output:[b, c, d, e]
- Using Collections.retainAll() method
Syntax:
Collections1.retainAll(Collections2)
This method keeps only the common elements
of both Collection in Collection1.
Approach:
- Get the two ArrayLists.
- Find the common elements in both the Lists using Collection.retainAll() method. This method keeps only the common elements of both Collection in Collection1.
- The List 1 now contains the common elements only.
Below is the implementation of the above approach:
Program: By modifying the contents of List1.
Java
// Java Program to find common elements
// in two ArrayLists
// Using retainAll() method
// import ArrayList package
import java.util.ArrayList;
public class GFG {
// main method
public static void main(String[] args)
{
// create ArrayList list1
ArrayList<String>
list1 = new ArrayList<String>();
// Add values in ArrayList
list1.add("Hii");
list1.add("Geeks");
list1.add("for");
list1.add("Geeks");
// print list 1
System.out.println("List1: "
+ list1);
// Create ArrayList list2
ArrayList<String>
list2 = new ArrayList<String>();
// Add values in ArrayList
list2.add("Hii");
list2.add("Geeks");
list2.add("Gaurav");
// print list 2
System.out.println("List2: "
+ list2);
// Find the common elements
list1.retainAll(list2);
// print list 1
System.out.println("Common elements: "
+ list1);
}
}
Output:
List1: [Hii, Geeks, for, Geeks]
List2: [Hii, Geeks, Gaurav]
Common elements: [Hii, Geeks, Geeks]
Program 2: By retaining the contents of List1.
Java
// Java Program to find common elements
// in two ArrayLists
// Using retainAll() method
// import ArrayList package
import java.util.ArrayList;
public class GFG {
// main method
public static void main(String[] args)
{
// create ArrayList list1
ArrayList<String>
list1 = new ArrayList<String>();
// Add values in ArrayList
list1.add("Hii");
list1.add("Geeks");
list1.add("for");
list1.add("Geeks");
// print list 1
System.out.println("List1: "
+ list1);
// Create ArrayList list2
ArrayList<String>
list2 = new ArrayList<String>();
// Add values in ArrayList
list2.add("Hii");
list2.add("Geeks");
list2.add("Gaurav");
// print list 2
System.out.println("List2: "
+ list2);
// Create ArrayList list3
ArrayList<String>
list3 = new ArrayList<String>(list1);
// Store the comparison output
// in ArrayList list3
list3.retainAll(list2);
// print list 3
System.out.println("Common elements: "
+ list3);
}
}
Output:
List1: [Hii, Geeks, for, Geeks]
List2: [Hii, Geeks, Gaurav]
Common elements: [Hii, Geeks, Geeks]
- Using Stream filter
Syntax:
list1.stream()
.filter(list2::contains)
.collect(Collectors
.toList()));
This method returns element if found in second list.
Approach:
- First create two ArrayList and add values of list.
- Convert the ArrayList to Stream using stream() method.
- Set the filter condition to be distinct using contains() method.
- Collect the filtered values as List using collect() method. This list will be return common element in both list.
- Print list3
Below is the implementation of the above approach:
Program:
Java
// Java Program to find common elements
// in two ArrayLists
// Using Stream filter method
// import ArrayList package
import java.util.*;
import java.util.stream.*;
public class GFG {
// main method
public static void main(String[] args)
{
// create ArrayList list1
ArrayList<String>
list1 = new ArrayList<String>();
// Add values in ArrayList
list1.add("Hii");
list1.add("Geeks");
list1.add("for");
list1.add("Geeks");
// print list 1
System.out.println("List1: "
+ list1);
// Create ArrayList list2
ArrayList<String>
list2 = new ArrayList<String>();
// Add values in ArrayList
list2.add("Hii");
list2.add("Geeks");
list2.add("Gaurav");
// print list 2
System.out.println("List2: "
+ list2);
// Find common elements
System.out.print("Common elements: ");
System.out.println(list1.stream()
.filter(list2::contains)
.collect(Collectors
.toList()));
}
}
Output:
List1: [Hii, Geeks, for, Geeks]
List2: [Hii, Geeks, Gaurav]
Common elements: [Hii, Geeks, Geeks]
- Naive approach:
- First create two ArrayList and add values of list.
- Create a temporary ArrayList to contain common elements.
- Iterate through the list1 and check if that element is present in the list2 using ArrayList.contains() method.
- If found, add it to the list3
- Print the common elements from list3
Below is the implementation of the above approach:
Java
// Java Program to find common elements
// in two ArrayLists
// Using Stream filter method
// import ArrayList package
import java.util.ArrayList;
public class GFG {
// main method
public static void main(String[] args)
{
// create ArrayList list1
ArrayList<String>
list1 = new ArrayList<String>();
// Add values in ArrayList
list1.add("Hii");
list1.add("Geeks");
list1.add("for");
list1.add("Geeks");
// print list 1
System.out.println("List1: "
+ list1);
// Create ArrayList list2
ArrayList<String>
list2 = new ArrayList<String>();
// Add values in ArrayList
list2.add("Hii");
list2.add("Geeks");
list2.add("Gaurav");
// print list 2
System.out.println("List2: "
+ list2);
// Create ArrayList list3
ArrayList<String>
list3 = new ArrayList<String>();
// Find common elements
// while iterating through list1
for (String temp : list1) {
// Check if the element is
// present in list2 or not
if (list2.contains(temp)) {
// Since present, add it to list3
list3.add(temp);
}
}
// print common elements from list 3
System.out.println("Common elements: "
+ list3);
}
}
Output:
List1: [Hii, Geeks, for, Geeks]
List2: [Hii, Geeks, Gaurav]
Common elements: [Hii, Geeks, Geeks]
Similar Reads
Java List Interface The List Interface in Java extends the Collection Interface and is a part of the java.util package. It is used to store the ordered collections of elements. In a Java List, we can organize and manage the data sequentially. Key Features:Maintained the order of elements in which they are added.Allows
15+ min read
AbstractList in Java with Examples The AbstractList class in Java is a part of the Java Collection Framework and implements the Collection interface and the AbstractCollection class. AbstractList class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a Rand
7 min read
ArrayList in Java Java ArrayList is a part of the collections framework and it is a class of java.util package. It provides us with dynamic-sized arrays in Java. The main advantage of ArrayList is that, unlike normal arrays, we don't need to mention the size when creating ArrayList. It automatically adjusts its capac
9 min read
LinkedList in Java Linked List is a part of the Collection framework present in java.util package. This class is an implementation of the LinkedList data structure, which is a linear data structure where the elements are not stored in contiguous locations, and every element is a separate object with a data part and an
12 min read
Immutable List in Java ImmutableList, as suggested by the name, is a type of List which is immutable. It means that the content of the List are fixed or constant after declaration, that is, they are read-only. If any attempt made to add, delete and update elements in the List, UnsupportedOperationException is thrown. An I
5 min read
CopyOnWriteArrayList in Java CopyOnWriteArrayList class is introduced in JDK 1.5, which implements the List interface. It is an enhanced version of ArrayList in which all modifications (add, set, remove, etc) are implemented by making a fresh copy. It is found in java.util.concurrent package. It is a data structure created to b
6 min read
Custom ArrayList in Java Before proceeding further let us quickly revise the concept of the arrays and ArrayList quickly. So in java, we have seen arrays are linear data structures providing functionality to add elements in a continuous manner in memory address space whereas ArrayList is a class belonging to the Collection
8 min read
Difference Between Synchronized ArrayList and CopyOnWriteArrayList in Java Collection As we know that the ArrayList is not synchronized, if multiple threads try to modify an ArrayList at the same time, then the final outcome will be non-deterministic. Hence synchronizing the ArrayList is a must to achieve thread safety in a multi-threaded environment. In order to make List objects we
6 min read
How to remove a SubList from a List in Java Given a list in Java, the task is to remove all the elements in the sublist whose index is between fromIndex, inclusive, and toIndex, exclusive. The range of the index is defined by the user. Example: Input list = [1, 2, 3, 4, 5, 6, 7, 8], fromIndex = 2, endIndex = 4 Output [1, 2, 5, 6, 7, 8] Input
2 min read
Randomly Select Items from a List in Java In this article, we will explore how to efficiently select an element from a list in Java. The basic approach involves generating a random index between 0 and the size of the list, and then using that index to retrieve the item. Different Ways to Select Items from a ListBelow are the different appro
3 min read