Ordenar comparador en Java

1. Utilice el DepartmentComparator para ordenar elementos en Java
2. Modificar el programa anterior usando la función lambda en Java 8

Este artículo define qué es un comparador de clasificación en Java y demuestra cómo se puede utilizar en los procesos. Hemos incluido programas que puede seguir para ayudarlo a comprender mejor este concepto.

Utilice el DepartmentComparator para ordenar elementos en Java

Ordenar es el proceso de organizar las estructuras de datos como un array de lista en un orden secuencial definido. El proceso funciona comparando los elementos de datos, por lo tanto, definiendo las nuevas posiciones. Hay varios tipos de algoritmos de ordenación definidos en Java que son útiles en función de la complejidad de la estructura.

A continuación se muestra el bloque de código que define la sustitución de la interfaz del comparador para dar nuestra implementación para ordenar los elementos.

import java.util.*;

public class DepartmentComparator {
  public static void main(String[] args) {
    List<Department> departments = Arrays.asList(new Department("dept1", 2001),
        new Department("dept2", 1998), new Department("dept3", 2021));
    Collections.sort(departments, new LexicographicComparator());
    System.out.println("Sorting on the basis of name: " + departments);
    Collections.sort(departments, new YearComparator());
    System.out.println("Sorting on the basis of year: " + departments);
  }

  static class LexicographicComparator implements Comparator<Department> {
    @Override
    public int compare(Department a, Department b) {
      return a.name.compareToIgnoreCase(b.name);
    }
  }

  static class YearComparator implements Comparator<Department> {
    @Override
    public int compare(Department a, Department b) {
      return a.establish_year < b.establish_year ? -1
          : a.establish_year == b.establish_year ? 0
                                                 : 1;
    }
  }

  static class Department {
    String name;
    int establish_year;

    Department(String n, int a) {
      name = n;
      establish_year = a;
    }

    @Override
    public String toString() {
      return String.format("{name=%s, Establish Year=%d}", name, establish_year);
    }
  }
}

En el programa anterior, la clase DepartmentComparator es una clase pública que contiene el método main y actúa como el código del controlador. Aparte de la clase principal, el código tiene clases no públicas que se agregaron para mostrar la funcionalidad. La clase Departament es un POJO que contiene un nombre de campo y la variable establish_year y la función toString() anulada. Aparte de la clase bean, una clase LexicographicComparator y una clase YearComparator implementan la interfaz Comparator.

En el método estático, una List se inicializa con tres elementos. El Array.asList es un método estático que devuelve una Lista de tamaño fijo. La función toma instancias de la clase para transformarlas en la lista. Por tanto, la instancia de clase de departamento se crea utilizando una nueva palabra clave y ahora se denomina constructor parameterized. Este constructor inicializa el nombre y establece un año a partir de los parámetros pasados.

Una vez que se crea la lista, se invoca el método sort de la clase Collections. Ordena la lista o colección definida según el comparador proporcionado. El método toma un comparador manual y devuelve void pero modifica la colección pasada como argumento. El método arroja una ClassCastException cuando los elementos son de un tipo diferente. El método toma una colección de listas como primer argumento y un comparador manual como segundo argumento.

Las clases LexicographicComparator y YearComparator se crean para la comparación manual. Las clases implementan una functional interface que es Comparator con un único método compare que devuelve un valor int basado en la comparación. El método se reemplaza en la clase definida por el usuario donde se puede definir la implementación especificada por el usuario.

En la clase LexicographicComparator, el método especifica una condición basada en el nombre, compara los argumentos pasados ​​y devuelve -1, 0 o 1 en función de si la entrada es menor, mayor o igual que el uno al otro. De forma similar, el método YearComparator se anula para comparar el año pasado como argumento.

A continuación se muestra la salida ordenada por nombres, en orden ascendente y por año.

Sorting on the basis of name: [{name=dept1, Establish Year=2001}, {name=dept2, Establish Year=1998}, {name=dept3, Establish Year=2021}]
Sorting on the basis of year: [{name=dept2, Establish Year=1998}, {name=dept1, Establish Year=2001}, {name=dept3, Establish Year=2021}]

Modificar el programa anterior usando la función lambda en Java 8

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class DepartmentCompareUsingJava8 {
  public static void main(String[] args) {
    List<DepartmentComparator.Department> departments =
        Arrays.asList(new DepartmentComparator.Department("dept1", 2001),
            new DepartmentComparator.Department("dept2", 1998),
            new DepartmentComparator.Department("dept3", 2021));
    Collections.sort(departments, (a, b) -> a.name.compareToIgnoreCase(b.name));
    System.out.println(departments);
    Collections.sort(departments,
        (a, b)
            -> a.establish_year < b.establish_year ? -1
            : a.establish_year == b.establish_year ? 0
                                                   : 1);
    System.out.println(departments);
  }
}

La diferencia en este programa es que en lugar de definir las nuevas clases que implementan la interfaz Comparator, la Java 8 functional interface ayuda a reducir la sobrecarga de procesamiento en una nueva Clase cada vez. La Interface funcional tiene un único método no implementado o método abstract. Reduce la sobrecarga de crear una clase que implementa interfaces y proporciona su propia versión de método.

Utiliza funciones lambda ()-> para llamar al método directamente. Las lambdas tratan las funciones como un argumento y no requieren ninguna clase para la instanciación. La función toma parámetros y da la implementación en la misma línea en lugar de en una clase separada.

La salida del programa anterior es la misma que la del primer código.