Este post discutirá como classificar uma array de objetos usando o Comparable e Comparator interface em Java.
1. Usando Comparável
Para classificar uma array de objetos usando o Arrays.sort método em Java, podemos fazer com que a classe implemente o Comparable interface, que então impõe uma ordenação natural em seus objetos.
Se um objeto implementa o Comparable interface, ele precisa substituir seu método abstrato compareTo(), que compara um objeto com o objeto especificado. O valor devolvido pelo compareTo() O método decide a posição do objeto em relação ao objeto especificado.
Se compareTo() retorna um
- valor negativo, o objeto é menor que o objeto especificado.
- zero, o objeto é igual ao objeto especificado.
- valor positivo, o objeto é maior que o objeto especificado.
Veja como ordenamos a array do Student objeto usando o Comparable interface, onde o array é primeiro ordenado por age e depois por name.
class Student implements Comparable<Student> public Student(String name, int age) return "{" + "name='" + name + '\'' + public String getName() { public int compareTo(Student o) if (this.age != o.getAge()) { return this.age - o.getAge(); return this.name.compareTo(o.getName()); public static void main(String[] args) Student[] students = { new Student("John", 15), new Student("Sam", 20), System.out.println(Arrays.toString(students)); |
Download Executar código
Resultado:
[{name='Joe', age=10}, {name='John', age=15}, {name='Dan', age=20}, {name='Sam', age=20}]
2. Usando o Comparador
UMA Comparator é uma função de comparação que impõe uma ordenação total em alguma coleção de objetos e permite um controle preciso sobre a ordem de classificação quando passada para o Arrays.sort método.
Se um objeto implementa o Comparator interface, ele precisa substituir o método abstrato compare(), que compara seus dois argumentos para ordem. O valor devolvido pelo compare() O método decide a posição do primeiro objeto em relação ao segundo objeto.
Se compare() retorna um
- valor negativo, o primeiro argumento é menor que o segundo.
- zero, o primeiro argumento é igual ao segundo.
- valor positivo, o primeiro argumento é maior que o segundo.
No exemplo a seguir, obtemos um Comparator que compara Student objetos primeiro pela idade e depois pelo nome.
public Student(String name, int age) return "{" + "name='" + name + '\'' + public String getName() { public static void main(String[] args) Student[] students = { new Student("John", 15), new Student("Sam", 20), new Student("Dan", 20), new Student("Joe", 10) }; Arrays.sort(students, new Comparator<Student>() { public int compare(Student first, Student second) if (first.getAge() != second.getAge()) { return first.getAge() - second.getAge(); return first.getName().compareTo(second.getName()); System.out.println(Arrays.toString(students)); |
Download Executar código
Resultado:
[{name='Joe', age=10}, {name='John', age=15}, {name='Dan', age=20}, {name='Sam', age=20}]
O código acima pode ser facilmente encurtado usando expressões lambda:
Arrays.sort(students, (first, second) -> { if (first.getAge() != second.getAge()) { return first.getAge() - second.getAge(); return first.getName().compareTo(second.getName()); |
Ou ainda mais curto:
Arrays.sort(students, (first, second) -> (first.getAge() != second.getAge()) ? (first.getAge() - second.getAge()) : (first.getName().compareTo(second.getName()))); |
Também podemos usar o Comparator.thenComparing() método, que efetivamente combina duas comparações em uma: