Sort ArrayList of custom Objects by property

stackoverflow.com › questions › 2784514 › sort-arraylist-of-custom-objects-by-property

Since Date implements Comparable, it has a compareTo method just like String does.

So your custom Comparator could look like this:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

The compare() method must return an int, so you couldn't directly return a boolean like you were planning to anyway.

Your sorting code would be just about like you wrote:

Collections.sort(Database.arrayList, new CustomComparator());

A slightly shorter way to write all this, if you don't need to reuse your comparator, is to write it as an inline anonymous class:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Since java-8

You can now write the last example in a shorter form by using a lambda expression for the Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

And List has a sort(Comparator) method, so you can shorten this even further:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

This is such a common idiom that there's a built-in method to generate a Comparator for a class with a Comparable key:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

All of these are equivalent forms.

Answer from Michael Myers on Stack Overflow

Stack Overflow

stackoverflow.com › questions › 2784514 › sort-arraylist-of-custom-objects-by-property

java - Sort ArrayList of custom Objects by property - Stack Overflow

Since java-8

You can now write the last example in a shorter form by using a lambda expression for the Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

And List has a sort(Comparator) method, so you can shorten this even further:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

This is such a common idiom that there's a built-in method to generate a Comparator for a class with a Comparable key:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

All of these are equivalent forms.

2 of 16

202

Classes that has a natural sort order (a class Number, as an example) should implement the Comparable interface, whilst classes that has no natural sort order (a class Chair, as an example) should be provided with a Comparator (or an anonymous Comparator class).

Two examples:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Usage:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

java - How to sort ArrayList<myobject> on the basis of myobject's properties

java - Sorting of ArrayList

java - Sorting objects inside arraylist

java - How does the sorting of ArrayList of custom object works?

java - How to sort a List/ArrayList?

More results from stackoverflow.com

BeginnersBook

beginnersbook.com › 2013 › 12 › java-arraylist-of-object-sort-example-comparable-and-comparator

Java ArrayList of Object Sort Example (Comparable And Comparator)

Let’s say we need to sort the ArrayList<Student> based on the student Age property. This is how it can be done – First implement Comparable interface and then Override the compareTo method.

Discussions

Please help me understand how is this custom comparator sorting the array

Technically, you'll create a new Class like: public class ArrayComparator implements Comparator { @Override public int compare(int[] obj1, int[] obj2) { if(obj1[0] < obj2[0]) return -1; //Whichever returns a negative number will be on top else if(obj1[0] == obj2[0]) return 0; //In your example, they're checking the second number as well else return 1; } } And then use it like: Arrays.sort(people, new ArrayComparator()); What they're doing is instead of creating a new class and then using it's object, they're using an Anonymous class (class with no name) that implements Comparator on the spot. Also Comparator is an interface. Look into how interfaces work. They can also be used as types. More on reddit.com

r/learnjava

March 26, 2020

java - Sorting ArrayList by LocalDate with custom Comparator - Stack Overflow

I deserialize some Json and put it into a model with the following structure: Model: import java.time.LocalDate; public class MyClass implements Serializable { String name; LocalDate da... More on stackoverflow.com

stackoverflow.com

Sorting 2D arrays by rows in Java using comparators

This is lambda expression in Java. Basically what it does is just sort two arrays by their first element More on reddit.com

r/leetcode

July 24, 2021

6 Advanced Comparator and Comparable Examples in Java 8 for Sorting ArrayList Objects By Fields

That page has way too much breaking up the flow of the page, at least on mobile. It's somewhat ironic that the thumbnail doesn't use Comparator. Array.sort(testStrings, comparing(String::length)); More on reddit.com

r/java

September 15, 2021

Videos

youtube.com

Sorting List of Objects using Comparator Interface in Java