Find Duplicate Objects in a List using Java

In this post, I will show you how to find duplicate objects in a List using Java’s Comparator interface implementation based on multiple fields in a POJO.

The following configurations are required in order to run the application
JDK 1.8
Have maven installed and configured
Junit, Mockito, PowerMockito dependency in pom.xml

Now we will see the below steps how to create a maven based Java project in Eclipse
Step 1. Create a standalone maven project in Eclipse

Go to File -> New -> Other. On popup window under Maven select Maven Project. Then click on Next. Select the workspace location – either default or browse the location. Click on Next. Now in next window select the row as highlighted from the below list of archtypes and click on Next button.

Now enter the required fields (Group Id, Artifact Id) as shown below
Group Id : com.roytuts
Artifact Id : junit
Step 2. Modify the pom.xml file as shown below.

<project xmlns="" xmlns:xsi=""

Step 3. If you see JRE System Library[J2SE-1.5] then change the version by below process

Do right-click on the project and go to Build -> Configure build path, under Libraries tab click on JRE System Library[J2SE-1.5], click on Edit button and select the appropriate jdk 1.8 from the next window. Click on Finish then Ok.

Step 4. Create a Model class called Car. So we will determine duplicate car is found based on make, model and year fields.

package com.roytuts.model;
public class Car {
    private String make;
    private String model;
    private int year;
    private boolean turnSignal;
    public Car() {
    public Car(String make, String model, int year, boolean turnSignal) {
        this.make = make;
        this.model = model;
        this.year = year;
        this.turnSignal = turnSignal;
    public String getMake() {
        return make;
    public void setMake(String make) {
        this.make = make;
    public String getModel() {
        return model;
    public void setModel(String model) {
        this.model = model;
    public int getYear() {
        return year;
    public void setYear(int year) {
        this.year = year;
    public boolean isTurnSignal() {
        return turnSignal;
    public void setTurnSignal(boolean turnSignal) {
        this.turnSignal = turnSignal;
    public String toString() {
        return "Car [make=" + make + ", model=" + model + ", year=" + year
                + ", turnSignal=" + turnSignal + "]";

Step 5. Create CarComparator class to compare each fields of the Car model class

package com.roytuts.comparator;
import java.util.Comparator;
import com.roytuts.model.Car;
public class CarComparator implements Comparator<Car> {
    public int compare(Car c1, Car c2) {
        int m = c1.getMake().compareToIgnoreCase(c2.getMake());
        if (m != 0) {
            return m;
        int md = c1.getModel().compareToIgnoreCase(c2.getModel());
        if (md != 0) {
            return md;

Step 6. Create CarUtils class to create utility method for finding duplicates

package com.roytuts.utils;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import com.roytuts.comparator.CarComparator;
import com.roytuts.model.Car;
public class CarUtils {
    public List<Car> getDuplicateCars(final List<Car> cars) {
        List<Car> duplicates = new ArrayList<Car>();
        Set<Car> carSet = new TreeSet<Car>(new CarComparator());
        for (Car car : cars) {
            if (!carSet.add(car)) {
        return duplicates;

Step 7. Create Junit class called CarTest which will test for duplicate Cars in a List of Cars

package com.roytuts.test;
import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.roytuts.model.Car;
import com.roytuts.utils.CarUtils;
public class CarTest {
    private CarUtils utils;
    private List<Car> cars;
    public void setUp() throws Exception {
        utils = new CarUtils();
    public void tearDown() throws Exception {
    public void testGetDuplicateCars() {
        List<Car> duplicateCars = utils.getDuplicateCars(cars);
        System.out.println("Duplicate cars");
        for (Car car : duplicateCars) {
    private void populateCars() {
        if (cars != null && !cars.isEmpty()) {
        cars = new ArrayList<Car>();
        Car car1 = new Car("Tata Motors", "Indica", 1990, true);
        Car car2 = new Car("Tata Motors", "Sumo", 1992, true);
        Car car3 = new Car("Maruti Suzuki", "WagonR", 1990, true);
        Car car4 = new Car("Tata Motors", "Sumo", 1994, true);
        Car car5 = new Car("Tata Motors", "Indica", 1990, true);
        Car car6 = new Car("Maruti Suzuki", "Swift", 2006, true);
        Car car7 = new Car("Hundai", "SX4", 1990, true);
        Car car8 = new Car("Tata Motors", "Zica", 2015, true);
        Car car9 = new Car("Maruti Suzuki", "Dzire", 2008, true);
        Car car10 = new Car("Maruti Suzuki", "Swift", 2006, true);

Step 8. Now run the above Junit test class, you will see the below output

Duplicate cars
Car [make=Tata Motors, model=Indica, year=1990, turnSignal=true]
Car [make=Maruti Suzuki, model=Swift, year=2006, turnSignal=true]

Thanks for reading.

Leave a Reply

Your email address will not be published. Required fields are marked *