Sort an ArrayList that is based on a class?

Question

I have a ArrayList that is made up of Last Names and First Names together based on the following class:

package nameSorting;

import javax.swing.JPanel;

public class Person extends JPanel{

    private String firstName;
    private String lastName;

    public void enterLast(String string){
        lastName = string;
    }
    public void enterFirst(String string){
        firstName = string;
    }
    public String firstName(){
        return firstName;
    }
    public String lastName(){
        return lastName;
    }
    @Override
    public String toString(){
        return firstName + " , " + lastName;
    }
}

My declaration of that ArrayList is as Follows (I do this in another class):

private ArrayList<Person> savedNames = new ArrayList<Person>();

I am then trying to do Collections.sort but it says I need a comparator. I tried to look up how to use it but nothing seemed helpful to my situation because they all sorted numbers and I am trying to sort by Characters.

My goal is to sort the ArrayList based on Last Name Alphabetically. So first A-Z and then there is also another option to sort Z-A. Any ideas on how to make this work?

Answer 1

Collections.sort(savedNames, (Person p1, Person p2) -> p1.lastName().compareTo(p2.lastName());

Answer 2

You can achieve this by implementing the Comparable interface in your Person class:

public class Person extends JPanel implements Comparable {

    ...

    @Override
    public int compareTo(Person other) {
        return this.lastName.compareTo(other.lastName());
    }

}

(code untested) In this case I just delegated the comparing to the last names, so the Persons would get ordered by last name. You can write anything you write into the compareTo. It just needs to return an int <0, ==0 or >0 to determine which object is considered "smaller".

However, Collections.sort() can be used on a list of objects that do not implement the Comparable interface. In this case, you would need to implement a Comparator for the function call. The most elegant way of doing this is with a lambda (Java 8+, copied from Jean-François Savard's answer):

Collections.sort(savedNames, (Person p1, Person p2) ->
    p1.lastName().compareTo(p2.lastName())
);

Without the lambda:

Collections.sort(savedNames, new Comparator<Person>() {
    public int compare(Person p1, Person p2) {
        return p1.lastName().compareTo(p2.lastName());
    }
});

(also untested)

Answer 3

You just need to create an order on your type Person by implementing the Comparable interface or an external Comparator.

class Person implements Comparable<Person> {
    @Override
    public compareTo(Person that) {
        // this is a reasonible implementation, but you can have your own
        return String.CASE_INSENSITIVE_ORDER.compare(this.lastName(),that.lastName());
    }
}

Doing this is defining a natural order on Person. This way, you won't have to provide a Comparator when sorting your data. However, you can only have one natural order, and you might need at some point to use a different implementation of the comparison between instances of Person.

In this case, define a new Comparator :

Collections.sort(persons, new Comparator<Person> () {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
});

This is in Java x <= 7 fashion, in Java 8 you can go for :

persons.stream().sorted((p1,p2) -> p1.getAge() - p2.getAge()).collect(Collectors.toList());