Ya hemos visto cómo ordenar una matriz de objetos personalizados sin usar la expresión lambda. En este tutorial veremos cómo ordenar una lista de objetos personalizados usando la expresión lambda en Java.

Antes de ver el ejemplo completo, veamos cuál es la diferencia entre usar lambda y sin usar lambda:

Sin usar la expresión Lambda: Antes de Java 8 ordenamos así:

Si no está familiarizado con el comparador, consulte esta guía: Comparador de Java con ejemplo.

Aquí estamos ordenando una lista de objetos de clase Student por nombre.

Comparator sortingByName = new Comparator() {
   @Override
   public int compare(Student s1, Student s2) {
	return s1.getName().compareTo(s2.getName());
   }
};

Usando la expresión Lambda: El código equivalente de Java 8 que usa la expresión Lambda se vería así:

Comparator sortingByName =
(Student s1, Student s2)->s1.getName().compareTo(s2.getName());

Nota: En Java 8, la interfaz List admite el método sort (), por lo que no es necesario utilizar Comparator.sort (), pero puede utilizar el método List.sort (). El código anterior se puede volver a escribir como:
En este caso, studentlist es la instancia de la lista que contiene los objetos Student (consulte el ejemplo completo a continuación).

studentlist.sort((Student s1, Student s2)->s1.getName().compareTo(s2.getName()));

Java 8: clasificación con expresión Lambda

import java.util.ArrayList;
import java.util.List;
class Student {
   String name; 
   int age; 
   int id; 
   public String getName() {
      return name; 
   } 
   public int getAge() { 
      return age; 
   } 
   public int getId() { 
      return id; 
   } 
   Student(String n, int a, int i){ 
      name = n; 
      age = a; 
      id = i; 
   } 
   @Override public String toString() {     
      return ("Student[ "+"Name:"+this.getName()+             
              " Age: "+ this.getAge() +                     
              " Id: "+ this.getId()+"]"); 
   }
}
public class Example {
   public static void main(String[] args) {
      List<Student> studentlist = new ArrayList<Student>();
      studentlist.add(new Student("Jon", 22, 1001)); 
      studentlist.add(new Student("Steve", 19, 1003)); 
      studentlist.add(new Student("Kevin", 23, 1005)); 
      studentlist.add(new Student("Ron", 20, 1010)); 
      studentlist.add(new Student("Lucy", 18, 1111));
      System.out.println("Before Sorting the student data:"); 
 
      //java 8 forEach for printing the list 
      studentlist.forEach((s)->System.out.println(s));

      System.out.println("After Sorting the student data by Age:"); 

      //Lambda expression for sorting by age 
      studentlist.sort((Student s1, Student s2)->s1.getAge()-s2.getAge()); 

      //java 8 forEach for printing the list
      studentlist.forEach((s)->System.out.println(s));         

      System.out.println("After Sorting the student data by Name:"); 
      //Lambda expression for sorting the list by student name       
      studentlist.sort((Student s1, Student s2)->s1.getName().compareTo(s2.getName())); 
      studentlist.forEach((s)->System.out.println(s));        
      System.out.println("After Sorting the student data by Id:");        
      //Lambda expression for sorting the list by student id 
      studentlist.sort((Student s1, Student s2)->s1.getId()-s2.getId()); 
      studentlist.forEach((s)->System.out.println(s)); 
   }
}

Producción:

Before Sorting the student data:
Student[ Name:Jon Age: 22 Id: 1001]
Student[ Name:Steve Age: 19 Id: 1003]
Student[ Name:Kevin Age: 23 Id: 1005]
Student[ Name:Ron Age: 20 Id: 1010]
Student[ Name:Lucy Age: 18 Id: 1111]

After Sorting the student data by Age:
Student[ Name:Lucy Age: 18 Id: 1111]
Student[ Name:Steve Age: 19 Id: 1003]
Student[ Name:Ron Age: 20 Id: 1010]
Student[ Name:Jon Age: 22 Id: 1001]
Student[ Name:Kevin Age: 23 Id: 1005]

After Sorting the student data by Name:
Student[ Name:Jon Age: 22 Id: 1001]
Student[ Name:Kevin Age: 23 Id: 1005]
Student[ Name:Lucy Age: 18 Id: 1111]
Student[ Name:Ron Age: 20 Id: 1010]
Student[ Name:Steve Age: 19 Id: 1003]

After Sorting the student data by Id:
Student[ Name:Jon Age: 22 Id: 1001]
Student[ Name:Steve Age: 19 Id: 1003]
Student[ Name:Kevin Age: 23 Id: 1005]
Student[ Name:Ron Age: 20 Id: 1010]
Student[ Name:Lucy Age: 18 Id: 1111]

Java 8: clasificación en orden inverso

Para ordenar la lista en orden inverso (descendente), simplemente cambie el orden de los argumentos de esta manera:

leer  Referencias de métodos en Java 8

Ordenar la lista de objetos de la clase del estudiante por nombre en orden inverso:

studentlist.sort((Student s1, Student s2)->s2.getName().compareTo(s1.getName()));

Del mismo modo, la lista se puede ordenar en orden inverso según la edad y la identificación del estudiante de la siguiente manera:

//Lambda expression for sorting the list by student age in reverse order 
studentlist.sort((Student s1, Student s2)->s2.getAge()-s1.getAge());
//Lambda expression for sorting the list by student id in reverse order 
studentlist.sort((Student s1, Student s2)->s2.getId()-s1.getId());

Tutoriales relacionados:

  1. Java 8: ejemplo de ordenación paralela de matrices
  2. Java: ordena ArrayList en orden descendente
  3. Java: ordena HashMap por claves y valores
  4. Java: clasificación de burbujas en orden ascendente y descendente

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *