El método nullsFirst( java.util.Comparator ) devuelve un comparador compatible con valores nulos y considera que los valores nulos son menores que no nulos. El nulo primero opera con la siguiente lógica:
- El elemento nulo se considera menor que no nulo.
- Cuando ambos elementos son nulos, entonces se consideran iguales.
- Cuando ambos elementos no son nulos, el comparador especificado determina el orden.
- Si el comparador especificado es nulo, el comparador devuelto considera iguales todos los elementos no nulos.
- El comparador devuelto es serializable si el comparador especificado es serializable.
Sintaxis:
static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator)
Parámetros: este método acepta un comparador de un solo parámetro que es un comparador para comparar valores no nulos
Valor de retorno: este método devuelve un comparador que considera que nulo es menor que no nulo y compara objetos no nulos con el comparador proporcionado.
Los siguientes programas ilustran el método nullsFirst(java.util.Comparator):
Programa 1:
// Java program to demonstrate
// Comparator.nullsFirst(java.util.Comparator) method
import java.util.Arrays;
import java.util.Comparator;
public class GFG {
public static void main(String[] args)
{
// Create a collection of an array
// of names also contain nulls
String[] strings = { "aman", "suvam",
null, "sahil",
null };
// print the array
System.out.println("Before sorting: "
+ Arrays.toString(strings));
// apply nullsFirst method
// and sort the array
Arrays.sort(strings,
Comparator.nullsFirst(
Comparator.naturalOrder()));
// print the array
System.out.println("After sorting: "
+ Arrays.toString(strings));
}
}
La salida impresa en la consola de IDE se muestra a continuación.
Producción:
Programa 2:
// Java program to demonstrate
// Comparator.nullsFirst(java.util.Comparator) method
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class GFG {
public static void main(String[] args)
{
// Create some user objects
User u1 = new User("Aaman", 25);
User u2 = new User("Joyita", 22);
User u3 = new User("Suvam", 28);
User u4 = new User("mahafuj", 25);
System.out.println("One null Objects");
List<User> list
= Arrays.asList(u1, u2, u3, null, u4);
Collections.sort(list,
Comparator.nullsFirst(
Comparator.comparing(
User::getName)));
list.forEach(user -> System.out.println(user));
System.out.println("\nMore than One null Objects");
list = Arrays.asList(u1, u4, null, u2, u3, null, null);
Collections.sort(list,
Comparator.nullsFirst(
Comparator.comparing(
User::getName)));
list.forEach(user -> System.out.println(user));
}
}
class User implements Comparable<User> {
public String name;
public int age;
public User(String name, int age)
{
this.name = name;
this.age = age;
}
public int compareTo(User u1)
{
return name.compareTo(u1.name);
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
@Override
public String toString()
{
return "User [name=" + name + ", age=" + age + "]";
}
}
El resultado impreso en la consola se muestra a continuación.
Producción:
Referencias: https://docs.oracle.com/javase/10/docs/api/java/util/Comparator.html#nullsFirst(java.util.Comparator)
Publicación traducida automáticamente
Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA