Komparator in Java sortieren

1. Verwendung von den DepartmentComparator zum Sortieren von Elementen in Java
2. Modifizieren Sie das obige Programm mit der Funktion lambda in Java 8

Dieser Artikel definiert, was ein Sortierkomparator in Java ist, und zeigt, wie Sie ihn in Prozessen verwenden können. Wir haben Programme beigefügt, die Sie befolgen können, um Ihnen zu helfen, dieses Konzept besser zu verstehen.

Verwendung von den DepartmentComparator zum Sortieren von Elementen in Java

Sortieren ist der Vorgang, die Datenstrukturen wie ein Liste-Array in einer bestimmten sequentiellen Reihenfolge anzuordnen. Der Prozess funktioniert durch den Vergleich der Datenelemente, wodurch die neuen Positionen definiert werden. In Java sind verschiedene Arten von Sortieralgorithmen definiert, die aufgrund der Komplexität der Struktur nützlich sind.

Unten ist der Codeblock, der das Überschreiben der Komparatorschnittstelle definiert, um unsere Implementierung zum Sortieren der Elemente bereitzustellen.

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

Im obigen Programm ist die Klasse DepartmentComparator eine öffentliche Klasse, die die Hauptmethode enthält und als Treibercode fungiert. Abgesehen von der Hauptklasse hat der Code nicht öffentliche Klassen, die hinzugefügt wurden, um die Funktionalität zu zeigen. Die Klasse Department ist ein POJO, das einen Feldnamen und die Variable establish_year enthält und die Funktion toString() überschrieben hat. Neben der Bean-Klasse implementieren eine LexicographicComparator-Klasse und eine YearComparator-Klasse das Comparator-Interface.

Bei der statischen Methode wird eine List mit drei Elementen initialisiert. Das Array.asList ist eine statische Methode, die eine List fester Grösse zurückliefert. Die Funktion nimmt Instanzen der Klasse an, um sie in die Liste umzuwandeln. Die Instanz department class wird also mit einem neuen Schlüsselwort erstellt und heisst nun parametrisierter Konstruktor. Dieser Konstruktor initialisiert den Namen und erstellt ein Jahr aus den übergebenen Parametern.

Sobald die Liste erstellt wurde, wird die Methode sort der Klasse Collections aufgerufen. Es sortiert die definierte Liste oder Sammlung basierend auf dem angegebenen Vergleicher. Die Methode verwendet einen manuellen Komparator und gibt void zurück, ändert jedoch die als Argument übergebene Sammlung. Die Methode wirft eine ClassCastException, wenn die Elemente von einem anderen Typ sind. Die Methode verwendet eine Listensammlung als erstes Argument und einen manuellen Komparator als zweites Argument.

Für den manuellen Vergleich werden die Klassen LexicographicComparator und YearComparator erstellt. Die Klassen implementieren eine functional interface, die Comparator ist, mit einer einzigen Methode compare, die basierend auf dem Vergleich einen int-Wert zurückgibt. Die Methode wird in der benutzerdefinierten Klasse überschrieben, in der die benutzerdefinierte Implementierung definiert werden kann.

In der Klasse LexicographicComparator spezifiziert die Methode eine Bedingung basierend auf dem Namen, vergleicht die übergebenen Argumente und gibt -1, 0 oder 1 zurück, je nachdem, ob die Eingabe kleiner, größer oder gleich ist zueinander. Ebenso wird die Methode YearComparator überschrieben, um das als Argument übergebene Jahr zu vergleichen.

Unten ist die Ausgabe nach Namen, in aufsteigender Reihenfolge und nach Jahr geordnet.

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

Modifizieren Sie das obige Programm mit der Funktion 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);
  }
}

Der Unterschied in diesem Programm besteht darin, dass anstelle der Definition der neuen Klassen, die die Comparator-Schnittstelle implementieren, die Java 8 functional interface dazu beiträgt, den Verarbeitungsaufwand in einer neuen Klasse jedes Mal zu reduzieren. Die Functional Interface hat eine einzelne nicht implementierte Methode oder abstrakte Methode. Es reduziert den Aufwand für das Erstellen einer Klasse, die Schnittstellen implementiert und eine eigene Methodenversion bereitstellt.

Es verwendet Lambda-()->-Funktionen, um die Methode direkt aufzurufen. Lambdas behandeln die Funktionen als Argument und benötigen keine Klasse für die Instanziierung. Die Funktion nimmt Parameter und gibt die Implementierung in derselben Zeile statt in einer separaten Klasse an.

Die Ausgabe des obigen Programms ist die gleiche wie die im ersten Code.