4.2. Advanced List and Set Manipulations

Collections.sort(list, new Comparator<Student>() {
    public int compare(Student s1, Student s2) {
        return s1.getMarks() - s2.getMarks();
    }
});

Use Comparable when natural ordering is needed. Use Comparator for custom multi-field sorting.

In Java, when you want to sort a collection of objects, you can use two main interfaces: Comparable and Comparator. The Comparable interface is used when you want to define a natural ordering for objects. This means that the class implementing Comparable will have its own method (compareTo) that defines how to compare one object to another. For example, if you have a Student class and want to sort students by their names, you would implement Comparable in the Student class.

On the other hand, if you want to sort objects according to multiple fields or in a different way (other than their natural order), you use Comparator. This is done by creating separate classes or anonymous classes that implement the Comparator interface, defining the compare method to compare two objects according to specified criteria. In our example, we've used an anonymous class to compare Student objects by their marks, allowing us to sort by different criteria dynamically.

Think of Comparable as a first name ordering for students in a class—everyone has their own name (natural ordering), making it easy to line them up alphabetically. Now imagine you want to arrange students not only by first name but also by last name and then by grades if there’s a tie—this is where Comparator comes in. It’s like using a set of rules that can change depending on how you want to arrange the students for different occasions (like preparing for a competition or for a fun class picture).

List<String> readOnlyList = Collections.unmodifiableList(myList);
List<String> threadSafeList = Collections.synchronizedList(new ArrayList<>());

Useful for concurrency and immutability in multi-threaded environments.

In multi-threaded programming, you often need to ensure that the data structures you use are safe from concurrent modifications that could lead to inconsistencies or unpredictable behavior. Java provides tools to help with this. For instance, you can create an unmodifiable list using Collections.unmodifiableList(), which prevents any changes to the original list after it’s created. This is useful when you want to share a list with other parts of your program but ensure no one can alter it.

On the other hand, you might need a list that can be accessed and modified by multiple threads simultaneously. In such cases, you can use Collections.synchronizedList() to get a thread-safe version of a list. This means the operations on the list are synchronized, ensuring that only one thread can change the list at a time, preventing race conditions.

Imagine you have a recipe book where you have written down your favorite recipes—a physical book that you never want anyone to edit. This is like an unmodifiable list; once it’s written, it shouldn’t change! Now, think about preparing a meal with family: everyone is trying to throw ingredients into the pot at the same time. If you don’t have a good way to manage who adds what, it could lead to chaos—this is similar to needing a synchronized collection where everyone gets to contribute, but only one person can add at a time to ensure the recipe comes out just right.

--