Classificar comparador em Java

1. Use o DepartmentComparator para classificar elementos em Java
2. Modifique o programa acima usando a função lambda em Java 8

Este artigo define o que é um comparador de classificação em Java e demonstra como você pode usá-lo em processos. Incluímos programas que você pode seguir para ajudá-lo a entender melhor esse conceito.

Use o DepartmentComparator para classificar elementos em Java

Classificar é o processo de organizar as estruturas de dados como um array lista em uma ordem sequencial definida. O processo funciona comparando os elementos de dados e, portanto, definindo as novas posições. Existem vários tipos de algoritmos de classificação definidos em Java que são úteis com base na complexidade da estrutura.

Abaixo está o bloco de código que define a substituição da interface do comparador para fornecer nossa implementação para classificar os 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);
    }
  }
}

No programa acima, a classe DepartmentComparator é uma classe pública que contém o método main e atua como o código do driver. Além da classe principal, o código possui classes não públicas que foram adicionadas para mostrar a funcionalidade. A classe Departament é um POJO que contém um nome de campo e a variável establish_year e a função toString() substituída. Além da classe de bean, uma classe LexicographicComparator e uma classe YearComparator implementam a interface Comparator.

No método estático, uma Lista é inicializada com três elementos. O Array.asList é um método estático que retorna uma Lista de tamanho fixo. A função usa instâncias da classe para se transformar na lista. Portanto, a instância da department class é criada usando uma nova palavra-chave e agora é chamada de construtor parametrizado. Este construtor inicializa o nome e estabelece um ano a partir dos parâmetros passados.

Uma vez que a lista é criada, o método sort é chamado da classe Collections. Ele classifica a lista ou coleção definida com base no comparador fornecido. O método usa um comparador manual e retorna void, mas modifica a coleção passada como um argumento. O método lança uma ClassCastException quando os elementos são de um tipo diferente. O método usa uma coleção de lista como primeiro argumento e um comparador manual como segundo argumento.

As classes LexicographicComparator e YearComparator são criadas para comparação manual. As classes implementam uma interface funcional que é Comparator com um único método compare que retorna um valor int com base na comparação. O método é substituído na classe definida pelo usuário, onde a implementação especificada pelo usuário pode ser definida.

Na classe LexicographicComparator, o método especifica uma condição com base no nome, compara os argumentos passados ​​e retorna -1, 0 ou 1 com base no fato de a entrada ser menor, maior ou igual um para o outro. Da mesma forma, o método YearComparator é substituído para comparar o ano passado como um argumento.

Abaixo está a saída organizada por nomes, em ordem crescente e por ano.

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

Modifique o programa acima usando a função lambda em 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);
  }
}

A diferença neste programa é que em vez de definir as novas classes que implementam a interface Comparator, a interface funcional Java 8 ajuda a reduzir a sobrecarga de processamento em uma nova classe a cada vez. A Interface Funcional tem um único método não implementado ou método abstract. Ele reduz a sobrecarga de criação de uma classe que implementa interfaces e fornece sua própria versão de método.

Ele usa funções lambda ()-> para chamar o método diretamente. Lambdas tratam as funções como um argumento e não requerem nenhuma classe para a instanciação. A função recebe parâmetros e fornece a implementação na mesma linha, em vez de em uma classe separada.

A saída do programa acima é a mesma do primeiro código.