So the other day one of my friends was trying to solve a problem and he decided to share his problem with me. So based on my understanding of what he was trying to do was, that he had 2 disparate groups of data stored in Lists, the two lists were likely to have duplicates. His objective was to consolidate the two lists such that the consolidated list would only have unique entries. The lists had custom data structures, so straightforward methods of adding elements to a Set by itself wasn’t enough, nor was it the situation where you add all the elements to one big list and somehow use the removeAll method.

My first reaction to this problem was, hmm why not exploit the consistent with equals concept with a Comparator. Now this may or may not be a good solution, it was a fun one for me to knock up and it builds on my last post about Sorting in Java.

### The problem

Say we are getting two streams of data, which may or may not contain duplicates and our goal is to get data that is unique across those two streams. Building on the concepts of Sorting discussed in this post,

Say we have a class called Person, which looks like this

``````public static class Person {
public String name;
public Integer age;
}``````

And we have two lists of persons, which is

``````List<Person> listA = getRandomPersonsList();
List<Person> listB = getRandomPersonsList();``````

Now what we want from lists listA and listB, are Persons whose name and age are unique. So lets create a Set which will contain unique persons from listA and listB. The set we will use is a special type of set called a TreeSet. A TreeSet can take a Comparator as a constructor argument and we can write a special type of comparator that will make sure that it only allows unique values in the Set. So that Comparator will look something like

#### Like the blog? Subscribe for updates

``````Comparator<Person> nameAgeComparator = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
if (p1.name.compareTo(p2.name) == 0) {
return p1.age.compareTo(p2.age);
} else {
return p1.name.compareTo(p2.name);
}
}
};``````

Ok, so now we have a Comparator, we have a List of persons, so all we need is to add them to a Set.

``````Set<Person> uniquePersons = new TreeSet<Person>(nameAgeComparator);

So now if you think about it, a Set by definition will only allow unique values to be stored within it, right? so by passing a Comparator we are dictating what constitutes a unique value. So in case case if we try to add a person with the same and age, it will be considered a duplicate value and hence not added to the Set. In Java, the add method will simply return false.

Now did i solve my friends problem? probably not, partly because i don’t exactly know what the problem was, but i am pretty happy that it gave me another idea for a blog post.

A working version of the above example can be found here

Developer: Bhuman Soni
Price: Free
Developer: Bhuman Soni
Price: \$4.99
Developer: Bhuman Soni
Price: Free
Developer: Bhuman Soni
Price: \$2.99

Categories: HashSetJavasorting