Pourquoi l'approche Lambda de Java 8 est-elle la meilleure façon de trier des objets avec plusieurs champs ?

Utilisation des lambda de Java 8 (ajouté le 10 avril 2019)

Cette version du code tire parti des lambda de Java 8 pour obtenir le résultat de tri souhaité :

<code class="java">Collections.sort(reportList, Comparator.comparing(Report::getReportKey)
            .thenComparing(Report::getStudentNumber)
            .thenComparing(Report::getSchool));</code>

La clé ici est d'utiliser la méthode thenComparing pour créer une chaîne de comparateurs. Chaque comparateur de la chaîne compare l'un des champs de l'objet Report. Le comparateur résultant est ensuite utilisé pour trier la liste.

Cette approche est concise, facile à lire et sûre. Il présente également l'avantage d'évaluer paresseusement les getters, ce qui signifie que les getters ne sont appelés que lorsqu'ils sont nécessaires à la comparaison.

Désordonné et alambiqué : tri manuel

Le code original, qui trie à la main, est verbeux et sujet aux erreurs. Cela nécessite beaucoup de saisie et de maintenance, et il est facile de faire des erreurs lors de l'écriture de la logique de comparaison. Voici à quoi cela ressemble :

<code class="java">Collections.sort(reportList, new Comparator<Report>() {

  @Override
  public int compare(Report record1, Report record2) {
    return (record1.getReportKey() + record1.getStudentNumber() + record1.getSchool())                      
        .compareTo(record2.getReportKey() + record2.getStudentNumber() + record2.getSchool());
  }

});</code>

Cette approche n'est pas recommandée pour trier des objets avec plusieurs champs.

La méthode réflexive : Tri avec BeanComparator

L'approche BeanComparator utilise la réflexion pour comparer les champs des objets Report. Cette approche est plus concise que le tri manuel, mais elle est également plus sujette aux erreurs et plus lente. Voici à quoi cela ressemble :

<code class="java">ComparatorChain chain = new ComparatorChain(Arrays.asList(
   new BeanComparator("reportKey"),
   new BeanComparator("studentNumber"),
   new BeanComparator("school")));

Collections.sort(reportList, chain);  </code>

Cette approche n'est pas recommandée pour trier des objets comportant plusieurs champs.

Comment y arriver : trier avec ComparisonChain

L'approche Google Guava ComparisonChain est similaire à l'approche BeanComparator, mais elle est plus flexible et plus rapide. Voici à quoi cela ressemble :

<code class="java">Collections.sort(reportList, new Comparator<Report>() {  

  @Override  
  public int compare(Report p1, Report p2) {  
    return ComparisonChain.start().compare(p1.getReportKey(), p2.getReportKey()).compare(p1.getStudentNumber(), p2.getStudentNumber()).compare(p1.getSchool(), p2.getSchool()).result();  
  }  
});  </code>

Cette approche est un bon choix pour trier des objets avec plusieurs champs, mais elle n'est pas aussi concise que l'approche lambda de Java 8.

L'approche Apache Commons CompareToBuilder est similaire à l'approche Google Guava ComparisonChain, mais elle est moins flexible. Voici à quoi cela ressemble :

<code class="java">Collections.sort(reportList, new Comparator<Report>() {  

  @Override  
  public int compare(Report p1, Report p2) {  
    return new CompareToBuilder().append(p1.getReportKey(), p2.getReportKey()).append(p1.getStudentNumber(), p2.getStudentNumber()).append(p1.getSchool(), p2.getSchool()).toComparison();  
  }  
});  </code>

Cette approche est un bon choix pour trier des objets avec plusieurs champs, mais elle n'est pas aussi concise que l'approche lambda de Java 8.

En fin de compte, la meilleure approche pour trier des objets comportant plusieurs champs dépend des exigences spécifiques de l'application. L'approche Java 8 lambda est la plus concise et la plus sécurisée, mais elle nécessite Java 8 ou une version ultérieure. L'approche Google Guava ComparisonChain est un bon choix pour les applications qui ont besoin de plus de flexibilité que l'approche Java 8 lambda, mais elle n'est pas aussi concise. L'approche Apache Commons CompareToBuilder est un bon choix pour les applications qui ont besoin de moins de flexibilité que l'approche Google Guava ComparisonChain, mais elle n'est pas aussi concise.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!