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.
Prerequisites
The following configurations are required in order to run the application
Eclipse
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.
maven-arctype-quickstart
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.
4.0.0 com.roytuts java 0.0.1-SNAPSHOT jar java http://maven.apache.org UTF-8 1.8 4.11 junit junit $ test org.apache.maven.plugins maven-compiler-plugin $ $
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 < @Override 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; >return Integer.compare(c1.getYear(),c2.getYear()); > >
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 ListgetDuplicateCars(final List cars) < Listduplicates = new ArrayList(); Set carSet = new TreeSet(new CarComparator()); for (Car car : cars) < if (!carSet.add(car)) < duplicates.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 Listcars; @Before public void setUp() throws Exception < utils = new CarUtils(); populateCars(); >@After public void tearDown() throws Exception < cars.clear(); >@Test public void testGetDuplicateCars() < ListduplicateCars = utils.getDuplicateCars(cars); System.out.println("Duplicate cars"); for (Car car : duplicateCars) < System.out.println(car); >> private void populateCars() < if (cars != null && !cars.isEmpty()) < return; >cars = new ArrayList(); 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); cars.add(car1); cars.add(car2); cars.add(car3); cars.add(car4); cars.add(car5); cars.add(car6); cars.add(car7); cars.add(car8); cars.add(car9); cars.add(car10); > > 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]
Clone an Object in Java
- Use the Direct Method to Clone an Object in Java
- Use the clone() Function to Clone an Object in Java
- Use a Copy Constructor to Clone an Object in Java
Object cloning is a technique for making an exact duplicate of an object. It creates a new instance of the current object’s class and fills all of its fields with the exact contents of the current object’s fields.
In this tutorial, we will clone an object in Java.
Use the Direct Method to Clone an Object in Java
In this method, we will create a new object and assign some previously defined object as its value.
See the following example.
public class shallowcopy implements Cloneable int a,b; public static void main(String args[]) throws CloneNotSupportedException shallowcopy d = new shallowcopy(); d.a = 10; d.b = 12; shallowcopy dtwo = d; System.out.println("Original " + d.a); System.out.println(d.b); System.out.println("Shallow Copy " + dtwo.a); System.out.println(dtwo.b); d.a = 5; System.out.println("Copy after modifying original"); System.out.println(dtwo.a); > > Original 10 12 Shallow Copy 10 12 Copy after modifying original 5 In the above code, we altered the original and saw the changes reflected in the copy created. Such a clone is called a shallow copy.
Before returning a new instance of the same class, shallow copying produces a new instance of the same class and copies its fields. The contents of an object are transferred to a new object in this procedure. However, both the objects refer to the same values, so any modifications made to the linked objects will be reflected in others. The object class has a clone function as well as shallow copying capability. The object class has a clone function as well as shallow copying capability.
Use the clone() Function to Clone an Object in Java
To clone an object, use the Object class’s clone() method. It is the quickest way to duplicate an array.
The class whose object clone we wish to generate must implement the Cloneable interface. If the Cloneable interface is not implemented, the clone() function throws a CloneNotSupportedException .
The clone() function eliminates the need for additional processing when making an exact replica of an object. If we do it using new , it will take a long time to process, which is why we use object cloning instead. We will use it to create a deep copy.
When an item is duplicated together with the objects it references, it is called a deep copy. Any changes made in the copy do not reflect on the original.
import java.util.ArrayList; public class deepcopy implements Cloneable int a,b; public Object clone() throws CloneNotSupportedException return (deepcopy)super.clone(); > public static void main(String args[]) throws CloneNotSupportedException deepcopy d = new deepcopy(); d.a = 10; d.b = 12; System.out.println("Original " + d.a); System.out.println(d.b); deepcopy dtwo = (deepcopy)d.clone(); System.out.println("Deep Copy " + dtwo.a); System.out.println(dtwo.b); d.a = 5; System.out.println("Copy after modifying original"); System.out.println(dtwo.a); > > Original 10 12 Deep Copy 10 12 Copy after modifying original 10 In the above example, changes made to the original are not reflected in the deep copy.
Use a Copy Constructor to Clone an Object in Java
A constructor initializes an object of some class. The copy constructor can create a duplicate object of some class.
See the code below to see how to initialize such a class.
class copycon public String cc; public copycon(String s) this.cc = s; > public copycon(copycon different) this.cc = different.cc; //copy constructor > > class Main public static void main(String args[]) copycon c1 = new copycon("abc"); copycon c2 = new copycon(c1); System.out.println(c2.cc); > > This would not achieve deep cloning in Java.