LeetCampus
Interview Question

What is a Comparator in java?

Short Answer

A Comparator in Java is a functional interface used to define a custom ordering between two objects. It provides the `compare(Object o1, Object o2)` method, which returns a negative integer, zero, or a positive integer based on the comparison. This allows for flexible sorting strategies beyond an object's natural ordering.

What a Strong Answer Covers

  • It is a functional interface.
  • Defines a custom order for objects.
  • Provides the `compare` method.
  • Used for sorting collections.
  • Can be implemented with lambda expressions.

Sample Answers

Example 1: Basic Usage of Comparator

In Java, the Comparator interface is implemented to define a custom order for objects. For instance, consider a scenario where we have a List<Person> and we want to sort it by age. Here's how we can implement a Comparator:

import java.util.*;

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class AgeComparator implements Comparator<Person> {
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.age, p2.age);
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25));
        Collections.sort(people, new AgeComparator());
        for (Person p : people) {
            System.out.println(p.name + " is " + p.age + " years old.");
        }
    }
}

In this example, we created a Person class and an AgeComparator to sort the list by age. The compare method returns a negative integer, zero, or a positive integer based on the comparison. This approach allows us to have complete control over the sorting process.

Example 2: Using Lambda Expressions

Java 8 introduced lambda expressions, which simplify the implementation of the Comparator interface. Instead of creating a separate class for comparison, we can use a lambda directly in our sorting method. For example:

import java.util.*;

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25));
        Collections.sort(people, (p1, p2) -> Integer.compare(p1.age, p2.age));
        for (Person p : people) {
            System.out.println(p.name + " is " + p.age + " years old.");
        }
    }
}

Using a lambda expression in the sort method makes the code more concise and readable. This modern approach is widely adopted in Java programming, emphasizing functional programming principles.

Example 3: Chaining Comparators

Another powerful feature of the Comparator interface is the ability to chain comparators. This allows for multi-level sorting. For instance, if we want to sort by age and then by name, we can do the following:

import java.util.*;

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25), new Person("Charlie", 25));
        Comparator<Person> comparator = Comparator.comparingInt((Person p) -> p.age)
                                                  .thenComparing(p -> p.name);
        Collections.sort(people, comparator);
        for (Person p : people) {
            System.out.println(p.name + " is " + p.age + " years old.");
        }
    }
}

In this code, we first sort by age and then by name if ages are equal. Chaining comparators is particularly useful in real-world applications where complex sorting criteria are needed, enhancing the flexibility of data handling in Java.

Why Interviewers Ask This Question

A Comparator in Java is a functional interface that defines a method for comparing two objects. Interviewers ask this question to assess a candidate's understanding of sorting and ordering collections in Java. This knowledge is crucial for effective data manipulation and algorithm implementation in real-world applications.

Understanding how to implement and use a Comparator can significantly enhance code readability and efficiency, especially when dealing with complex data structures. The evolution of sorting algorithms has made the Comparator interface a vital part of Java since it allows for custom sorting strategies beyond the natural ordering of objects. Common misconceptions include confusing a Comparator with a Comparable, which is another interface used for defining natural ordering.

It's also important to note that Comparators can be used with various data types, making them versatile tools in a Java developer's toolkit. This question helps interviewers gauge a candidate's grasp of object-oriented programming principles, functional interfaces, and the Java Collections Framework, which are fundamental in software engineering.

Keywords

JavaComparatorCollections Frameworksortingfunctional interface
July 24, 2025
0 views
Difficulty: Medium
Popularity: Common
Share on

Ready to practice more questions?

Explore our collection of technical interview questions from top companies.

View All Questions