JAVA 8 LAMBDA: EJEMPLO INTERFAZ COMPARATOR

En esta entrada veremos como hacer ordenaciones con lambdas en la interfaz COMPARATOR, a partir de JAVA8.


Supongamos las siguientes clases:

La clase entidad.Persona cumple el patrón JavaBeans al que le hemos añadido un constructor con parámetros y hemos sobreescrito el método toString.

package entidad;

public class Persona{

 private String nombre;
 private int altura;
 private int edad;
 
 public Persona(){
  
 }
 
 public Persona(String nombre, int edad, int altura){
  setNombre(nombre);
  setEdad(edad);
  setAltura(altura);
 }
 
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public int getAltura() {
  return altura;
 }
 public void setAltura(int altura) {
  this.altura = altura;
 }
 public int getEdad() {
  return edad;
 }
 public void setEdad(int edad) {
  this.edad = edad;
 }

 @Override
 public String toString() {
  return "Nombre= " + getNombre() + 
    ", Altura= " + getAltura() + 
    ", Edad= " + getEdad() +
    "\n";
 }

}//fin class entidad.Persona      
 

Y ahora la clase consola.App que es donde tenemos el método main, creamos un ArrayList de la clase Persona, le damos unos valores con  el método "add":

package consola;

import java.util.ArrayList;
import java.util.List;

import entidad.Persona;

public class App {

 public static void main(String[] args) {
  List <Persona> arrayListPersona = new ArrayList<>();
  
  arrayListPersona.add(new Persona("Mario", 22, 187));
  arrayListPersona.add(new Persona("Pepe", 52, 173));
  arrayListPersona.add(new Persona("Manuel", 27, 158));
  arrayListPersona.add(new Persona("David", 25, 164));
  arrayListPersona.add(new Persona("Alberto", 80, 184));
     
  System.out.println("Array sin ordenar: ");
  System.out.println(arrayListPersona);
 }
}//fin class consola.App

       

Y mostramos por pantalla el contenido del ArrayList:


Hasta la versión JAVA8 las ordenaciones se hacían sin lambdas por ejemplo, ordenamos por la altura sobreescribiendo el método abstracto compare de la interfaz Comparator:

             System.out.println("Array ordenado por altura (menor a mayor): ");
  Collections.sort(arrayListPersona, new Comparator() {
   @Override
   public int compare(Persona o1, Persona o2) {
    return o1.getAltura() - o2.getAltura(); 
   }
  });
  System.out.println(arrayListPersona);
  
  System.out.println("Array ordenado por altura (mayor a menor): ");
  Collections.sort(arrayListPersona, new Comparator() {
   @Override
   public int compare(Persona o1, Persona o2) {
    return o2.getAltura() - o1.getAltura(); 
   }
  });
  System.out.println(arrayListPersona);
 }
}//fin class consola.App

       
 

Si imprimimos por pantalla vemos que efectivamente nos ordena el ArrayList por altura:


Con Java8 empleando lambdas nos ahorramos mucho código y es más legible:

           System.out.println("Array ordenado por altura(menor a mayor lambda): ");
    Comparator highComparator = 
  (high1,high2) -> high1.getAltura() - high2.getAltura();
    arrayListPersona.sort(highComparator);
    System.out.println(arrayListPersona);
  
    System.out.println("Array ordenado por altura(mayor a menor lambda): ");
           arrayListPersona.sort(highComparator.reversed());
    System.out.println(arrayListPersona);
  
 }
}//fin class consola.App

       
 

No haré la ordenación por la edad, pues es un int como la altura y no aportamos nada nuevo, en cambio la ordenación por nombre si, debido a que es un String empleamos el método "compareTo", primero de la manera tradicional o antes de Java8:

                System.out.println("Array ordenado por nombre A a Z: ");
  Collections.sort(arrayListPersona, new Comparator() {
   
   @Override
   public int compare(Persona o1, Persona o2) {
    return o1.getNombre().compareTo(o2.getNombre());  
   }
  });
  System.out.println(arrayListPersona);
  
  System.out.println("Array ordenado por nombre de Z a A: ");
  Collections.sort(arrayListPersona, new Comparator() {
   
   @Override
   public int compare(Persona o1, Persona o2) {
    return o2.getNombre().compareTo(o1.getNombre());  
   }
  });
  System.out.println(arrayListPersona);
  
 }
}//fin class consola.App
       
 

Y eso mismo pero utilizando lambdas en un Comparator que luego será reutilizado para hacer la función a la inversa o reverse:

                System.out.println("Array ordenado por nombre de A a Z(con lambdas): ");
  Comparator nameComparator = 
    (n1,n2) -> n1.getNombre().compareTo(n2.getNombre());
  arrayListPersona.sort(nameComparator); 
  System.out.println(arrayListPersona);
  
  System.out.println("Array ordenado por nombre de Z a A(con lambdas): ");
  arrayListPersona.sort(nameComparator.reversed());
  System.out.println(arrayListPersona);
  
 }
}//fin class consola.App

       
 

Normalmente pasaríamos la lambda después de una tubería (stream) de una List o ArrayList de algo, las lambdas se pueden entender como el código que pondriamos en una interfaz funcional. De hecho las lambda se emplean en interfaces funcionales.

             System.out.println("Array ordenado por nombre de A a Z(con lambdas): ");
  arrayListPersona.stream()
   .sorted((n1,n2) -> n1.getNombre().compareTo(n2.getNombre()));
   
  System.out.println(arrayListPersona);
 
 }
}//fin class consola.App
       
 

Las 3 maneras de la comparación por nombre nos daría esta salida:


Bueno con esto hemos terminado esta entrada. Que tengáis un buen día,

Un saludo.