Trier une liste ayant des valeurs nulles avec nullsFirst de Comparator
Bonjour les amis,
Dans ce didacticiel, nous verrons comment trier une liste d'éléments lorsque peu d'éléments sont nuls dans la liste à l'aide de Java 8 Comparator.nullsFirst, de sorte que les valeurs nulles soient traitées comme les plus petits éléments de la liste.
- Qu'est-ce que le comparateur
- Que fait la méthode nullsFirst dans Comparator
– Tri d'une liste de Strings ayant des noms non nuls
– Tri d'une liste de Strings ayant des noms et des Nulls sans utiliser nullsFirst
- Résoudre le problème ci-dessus en triant la liste à l'aide de la méthode nullsFirst
– Tri d'une liste d'objets personnalisés sans valeurs nulles
- Trier une liste d'objets personnalisés avec des valeurs nulles sans utiliser nullsFirst
- Résoudre le problème ci-dessus en triant la liste à l'aide de la méthode nullsFirst
– Trier la liste ayant un employé avec le nom comme nul
Qu'est-ce qu'un comparateur ?
Comparator est une FunctionalInterface qui a la méthode abstraite suivante
entier comparer(T
o1, T
o2);
Donc, si vous voulez trier, dites votre liste. Vous pouvez créer une classe implémentant la méthode de comparaison de l'interface Comparator, dans laquelle vous pouvez définir la logique de tri et passer ce comparateur à la méthode list.sort() et il triera ensuite selon votre logique définie.
Alternativement, plutôt que de créer une classe distincte implémentant l'interface Comparator, vous pouvez passer la fonction lambda (implémentant la méthode de comparaison de Comparator) à la méthode list.sort().
Que fait la méthode nullsFirst dans Comparator ?
Dans Java 8, de nombreuses méthodes par défaut et statiques ont été ajoutées dans l'interface Comparator.
nullsFirst est l'une des méthodes statiques définies dans l'interface Comparator ayant la signature suivante :
publique
statique
super T>
comparateur)
Alors qu'est-ce que ça fait ?
– Renvoie un comparateur compatible null qui considère que null est inférieur à non null.
– Lorsque les deux objets sont nuls, ils sont considérés comme égaux.
– Lorsque les deux sont non nuls, le comparateur spécifié, qui est passé à la méthode nullsFirst en tant que paramètre, est utilisé pour déterminer l'ordre de tri
– Lorsque le comparateur spécifié est nul, le comparateur renvoyé considère que toutes les valeurs non nulles sont égales.
Pour comprendre l'utilisation de nullsFirst , essayons de trier une liste de Strings ayant le nom des employés ,
– Premier sans valeurs nulles
– Puis avec des valeurs nulles mais sans nullsFirst
– Puis avec des valeurs nulles et avec nullsFirst
– Ensuite, nous ferons les mêmes étapes ci-dessus pour un objet employé personnalisé
– Et puis nous verrons ce qui se passe si l'une des propriétés sur la base desquelles le tri doit être fait, est nulle dans un objet personnalisé
Trier une liste de chaînes ayant des noms non nuls
| 01020304050607080910111213141516171819 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.List; import java.util.Comparator; public class ComparatorTestWithListOfNamesWithoutNulls { public static void main(String[] args) { List<String> names = Arrays.asList( "Gaurav" , "Tendulkar" , "Suresh" , "Rohit" , "Bumrah" ); System.out.println( "Before Sorting:" ); names.forEach(System.out ::println); names.sort(Comparator.naturalOrder()); System.out.println( "After Sorting:" ); names.forEach(System.out ::println); } |
| 1 | } |
Voici la sortie :
Avant de trier :
Gaurav
Tendulkar
Suresh
Rohit
Boumra
Après le tri :
Boumra
Gaurav
Rohit
Suresh
Tendulkar
Trier une liste de chaînes ayant des noms et des valeurs nulles sans utiliser nullsFirst
| 01020304050607080910111213141516 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.Comparator; import java.util.List; public class ComparatorTestWithListOfNamesAndNulls { public static void main(String[] args) { List<String> names = Arrays.asList( "Gaurav" , null , "Sachin" , "Suresh" , null , "Rohit" , "Jasprit" , null ); System.out.println( "Before Sorting:" ); names.forEach(System.out ::println); names.sort(Comparator.naturalOrder()); System.out.println( "After Sorting:" ); names.forEach(System.out ::println); } |
| 1 | } |
Voici la sortie :
Avant de trier :
Gaurav
nul
Sachine
Suresh
nul
Rohit
Jasprit
nul
Exception dans le fil "main"
java.lang.NullPointerException
à java.base/java.util.Comparators$NaturalOrderComparator.compare(
comparateurs.java:52)
à java.base/java.util.Comparators$NaturalOrderComparator.compare(
comparateurs.java:47)
à java.base/java.util.TimSort.countRunAndMakeAscending(
TimSort.java:355)
à java.base/java.util.TimSort.sort(
TimSort.java:220)
à java.base/java.util.Arrays.sort(
tableaux.java:1442)
à java.base/java.util.Arrays$ArrayList.sort(
tableaux.java:4426)
sur com.blogspot.javasolutionsguide.ComparatorTestWithListOfNamesAndNulls.main(ComparatorTestWithListOfNamesAndNulls.java:12)
Comme nous pouvons le voir parce que la méthode de comparaison de NaturalOrderComparator essaie de comparer deux objets o en appelant compareTo sur l'un des objets, nous obtenons NullPointerException.
Résoudre le problème ci-dessus en triant la liste à l'aide de la méthode nullsFirst
| 010203040506070809101112131415161718192021 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.List; import java.util.Comparator; /** * @author javasolutionsguide * */ public class ComparatorTestWithNullsFirstForListOfNames { public static void main(String[] args) { List<String> names = Arrays.asList( "Gaurav" , null , "Tendulkar" , "Suresh" , null , "Rohit" , "Jasprit" , null ); System.out.println( "Before Sorting:" ); names.forEach(System.out ::println); names.sort(Comparator.nullsFirst(Comparator.naturalOrder())); System.out.println( "After Sorting:" ); names.forEach(System.out ::println); } |
| 1 | } |
Voici le résultat :
Avant de trier :
Gaurav
nul
Tendulkar
Suresh
nul
Rohit
Jasprit
nul
Après le tri :
nul
nul
nul
Gaurav
Jasprit
Rohit
Suresh
Tendulkar
Trier une liste d'objets personnalisés sans valeurs nulles
Nous allons créer une classe Employee, qui sera un simple POJO comme ci-dessous :
| 010203040506070809101112131415161718 | package com.blogspot.javasolutionsguide; public class Employee { private int id; private String name; private String department; public Employee( int id, String name, String department) { super (); this .id = id; this .name = name; this .department = department; } public int getId() { return id; |
| 010203040506070809101112131415 | } public String getName() { return name; } public String getDepartment() { return department; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", department=" + department + "]" ; } } |
Et voici notre classe de test :
| 01020304050607080910111213141516171819 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.Comparator; import java.util.List; public class ComparatorTestWithListOfEmployeesWithoutNulls { public static void main(String[] args) { List<Employee> employees = Arrays.asList( new Employee( 1 , "Gaurav" , "IT" ), new Employee( 1 , "Tendulkar" , "Admin" ), new Employee( 1 , "Suresh" , "IT" ), new Employee( 1 , "Rohit" , "Admin" ), new Employee( 1 , "Bumrah" , "Admin" )); System.out.println( "Before Sorting:" ); employees.forEach(System.out ::println); System.out.println( "After Sorting:" ); employees.sort(Comparator.comparing(Employee :: getName)); employees.forEach(System.out::println); |
| 1 | } |
Voici le résultat :
Avant de trier :
Employé [id=1, nom=Gaurav, département=IT]
Employé [id=1, nom=Tendulkar, département=Admin]
Employé [id=1, nom=Suresh, département=IT]
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Bumrah, département=Admin]
Après le tri :
Employé [id=1, nom=Bumrah, département=Admin]
Employé [id=1, nom=Gaurav, département=IT]
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Suresh, département=IT]
Employé [id=1, nom=Tendulkar, département=Admin]
Trier une liste d'objets personnalisés avec des valeurs nulles sans utiliser nullsFirst
| 01020304050607080910111213141516 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.Comparator; import java.util.List; public class ComparatorTestWithListOfEmployeesWithNulls { public static void main(String[] args) { List<Employee> employees = Arrays.asList( new Employee( 1 , "Gaurav" , "IT" ), null , new Employee( 1 , "Tendulkar" , "Admin" ), new Employee( 1 , "Suresh" , "IT" ), |
| 1234567 | null , new Employee( 1 , "Rohit" , "Admin" ), new Employee( 1 , "Bumrah" , "Admin" ), null ); employees.sort(Comparator.comparing(Employee::getName)); employees.forEach(System.out::println); |
| 1 | } |
| 1 | } |
Voici le résultat :
Avant de trier :
Employé [id=1, nom=Gaurav, département=IT]
nul
Employé [id=1, nom=Tendulkar, département=Admin]
Employé [id=1, nom=Suresh, département=IT]
nul
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Bumrah, département=Admin]
nul
Exception dans le fil "main"
java.lang.NullPointerException
sur java.base/java.util.Comparator.lambda$comparing$77a9974f$1(
comparateur.java:469)
à java.base/java.util.TimSort.countRunAndMakeAscending(
TimSort.java:355)
à java.base/java.util.TimSort.sort(
TimSort.java:220)
à java.base/java.util.Arrays.sort(
tableaux.java:1442)
à java.base/java.util.Arrays$ArrayList.sort(
tableaux.java:4426)
sur com.blogspot.javasolutionsguide.ComparatorTestWithListOfEmployeesWithNulls.main(ComparatorTestWithListOfEmployeesWithNulls.java:19)
Résoudre le problème ci-dessus en triant la liste à l'aide de la méthode nullsFirst
| 01020304050607080910111213141516 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; public class ComparatorTestWithListOfEmployeesWithNullsAndNullsFirst { public static void main(String[] args) { List<Employee> employees = Arrays.asList( new Employee( 1 , "Gaurav" , "IT" ), null , new Employee( 1 , "Tendulkar" , "Admin" ), new Employee( 1 , "Suresh" , "IT" ), |
| 12345678 | null , new Employee( 1 , "Rohit" , "Admin" ), new Employee( 1 , "Bumrah" , "Admin" ), null ); Collections.sort(employees ,Comparator.nullsFirst((emp1 ,emp2) -> emp1.getName().compareToIgnoreCase(emp2.getName()))); employees.forEach(System.out::println); } } |
Voici la sortie :
nul
nul
nul
Employé [id=1, nom=Bumrah, département=Admin]
Employé [id=1, nom=Gaurav, département=IT]
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Suresh, département=IT]
Employé [id=1, nom=Tendulkar, département=Admin]
Trier la liste ayant un employé dont le nom est nul
| 0102030405060708091011121314151617181920212223 | package com.blogspot.javasolutionsguide; import java.util.Arrays; import java.util.Comparator; import java.util.List; public class ComparatorTestWithListOfEmployeesWithNullNamesAndNullsFirst { public static void main(String[] args) { List<Employee> employees = Arrays.asList( new Employee( 1 , "Gaurav" , "IT" ), new Employee( 1 , "Tendulkar" , "Admin" ), new Employee( 1 , null , "IT" ), new Employee( 1 , "Rohit" , "Admin" ), new Employee( 1 , "Bumrah" , "Admin" )); System.out.println( "Before Sorting:" ); employees.forEach(System.out ::println); employees.sort(Comparator.comparing(Employee::getName,Comparator.nullsFirst(Comparator.naturalOrder()))); System.out.println( "After Sorting:" ); employees.forEach(System.out::println); } } |
Voici le résultat :
Avant de trier :
Employé [id=1, nom=Gaurav, département=IT]
Employé [id=1, nom=Tendulkar, département=Admin]
Employé [id=1, nom=null, département=IT]
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Bumrah, département=Admin]
Après le tri :
Employé [id=1, nom=null, département=IT]
Employé [id=1, nom=Bumrah, département=Admin]
Employé [id=1, nom=Gaurav, département=IT]
Employé [id=1, nom=Rohit, département=Admin]
Employé [id=1, nom=Tendulkar, département=Admin]
Résumé
Lorsque nous avons une liste d'éléments où peu d'éléments sont nuls et que nous voulons que ces éléments nuls soient traités comme les plus petits éléments de la liste, nous pouvons utiliser la méthode nullsFirst de l'interface Comparator, qui fait ce qui suit :
Retourne un comparateur acceptant les valeurs null qui considère que null est inférieur à non null.
– Lorsque les deux objets sont nuls, ils sont considérés comme égaux.
– Lorsque les deux sont non nuls, le comparateur spécifié, qui est passé à la méthode nullsFirst en tant que paramètre, est utilisé pour déterminer l'ordre de tri
– Lorsque le comparateur spécifié est nul, le comparateur renvoyé considère que toutes les valeurs non nulles sont égales.
Merci d'avoir lu. Si vous avez aimé le message, vous pouvez le partager et vous abonner à ce blog pour plus de messages de ce type.
