Comparatore di ordinamento in Java

1. Usa il DepartmentCompator per ordinare gli elementi in Java
2. Modifica il programma sopra utilizzando la funzione lambda in Java 8

Questo articolo definisce cos’è un comparatore di ordinamento in Java e dimostra come utilizzarlo nei processi. Abbiamo incluso programmi che puoi seguire per aiutarti a capire meglio questo concetto.

Usa il DepartmentCompator per ordinare gli elementi in Java

Ordinamento è il processo di disposizione delle strutture dati come un array “elenco” in un ordine sequenziale definito. Il processo funziona confrontando gli elementi dei dati, definendo quindi le nuove posizioni. Esistono vari tipi di algoritmi di ordinamento definiti in Java che risultano utili in base alla complessità della struttura.

Di seguito è riportato il blocco di codice che definisce l’override dell’interfaccia del comparatore per fornire la nostra implementazione per l’ordinamento degli elementi.

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);
    }
  }
}

Nel programma sopra, la classe DepartmentComparator è una classe pubblica che contiene il metodo principale e funge da codice del driver. Oltre alla classe principale, il codice ha classi non pubbliche che sono state aggiunte per mostrare la funzionalità. La classe Department è un POJO che contiene un nome di campo e la variabile establish_year e la funzione toString() sovrascritta. Oltre alla classe bean, una classe LexicographicComparator e una classe YearComparator implementano l’interfaccia Comparator.

Nel metodo statico, un List viene inizializzato con tre elementi. L’Array.asList è un metodo statico che restituisce un List di dimensione fissa. La funzione accetta istanze della classe da trasformare nella lista. Quindi l’istanza classe reparto viene creata utilizzando una nuova parola chiave e viene ora chiamata costruttore parametrizzato. Questo costruttore inizializza il nome e stabilisce un anno dai parametri passati.

Una volta creata la lista, viene invocato il metodo sort della classe Collections. Ordina la lista o la raccolta definiti in base al comparatore fornito. Il metodo accetta un comparatore manuale e restituisce void ma modifica la raccolta passata come argomento. Il metodo genera una ClassCastException quando gli elementi sono di tipo diverso. Il metodo accetta una raccolta di elenchi come primo argomento e un comparatore manuale come secondo argomento.

Le classi LexicographicComparator e YearComparator vengono create per il confronto manuale. Le classi implementano un’interfaccia funzionale che è Comparator con un unico metodo compare che restituisce un valore int basato sul confronto. Il metodo viene sovrascritto nella classe definita dall’utente in cui l’implementazione specificata dall’utente può essere definita.

Nella classe LexicographicComparator, il metodo specifica una condizione basata sul nome, confronta gli argomenti passati e restituisce -1, 0 o 1 a seconda che l’input sia minore, maggiore o uguale l’uno all’altro. Allo stesso modo, il metodo YearCompator viene sovrascritto per confrontare l’anno passato come argomento.

Di seguito è riportato l’output ordinato per nome, in ordine crescente e per anno.

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}]

Modifica il programma sopra utilizzando la funzione lambda in 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 differenza in questo programma è che invece di definire le nuove classi che implementano l’interfaccia Comparator, Java 8 functional interface aiuta a ridurre ogni volta il sovraccarico di elaborazione in una nuova classe. Functional Interface ha un unico metodo non implementato o metodo abstract. Riduce il sovraccarico della creazione di una classe che implementa le interfacce e fornisce la propria versione del metodo.

Utilizza le funzioni lambda ()-> per chiamare direttamente il metodo. I Lambda trattano le funzioni come un argomento e non richiedono alcuna classe per l’istanza. La funzione accetta parametri e fornisce l’implementazione nella stessa riga anziché in una classe separata.

L’output del programma sopra è lo stesso di quello nel primo codice.