Qué es Predicate en Java
Este tutorial presenta la interfaz de Predicate con ejemplos en Java.
El Predicate es una interfaz en Java que se utiliza como asignación de destino para una expresión lambda o una referencia de método. Se agregó a Java 8 y proporcionó un enfoque más funcional para escribir código en Java.
Está presente en el paquete java.util.function. Un Predicate se usa más comúnmente para filtrar una secuencia de objetos. En este tutorial, discutiremos qué es un Predicate y cómo podemos usarlo.
¿Qué es Predicate en Java?
Como se mencionó anteriormente, un Predicate es una interfaz funcional que se utiliza como destino de asignación para una expresión lambda o una referencia de método. La interfaz de sintaxis de Predicate tiene el siguiente aspecto.
@FunctionalInterface public interface Predicate<T>
La T es el tipo de entrada a la interfaz de predicado. Tomemos un ejemplo de lo que es un predicado. En el mundo matemático, un Predicate puede tomar la siguiente forma:
x -> x > 90
La afirmación anterior representa que x implica que x es mayor que 90.
Veamos un ejemplo de cómo podemos crear un objeto predicado.
Predicate<Integer> noGreaterThan5 = x -> x > 5;
En el código anterior, creamos un Predicate llamado noGreaterThan5. Este Predicate toma la entrada Integer; por lo tanto, T es Entero aquí. Este Predicate verificará si los argumentos de entrada son mayores que cinco o no.
Predicate en la Operación Filter() de Java Stream
La operación filter() de la API de flujo de Java 8 toma un Predicate como argumento. En el siguiente código, usaremos la operación filter() para ver la implementación de la interfaz de predicado. Mira el código a continuación:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameGreaterThan4 = x -> x.length() > 4;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameGreaterThan4).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Producción :
[Karan, Aarya, Rahul, Pranav]
Hemos escrito el código anterior para filtrar nombres cuya longitud es mayor que 4. Primero creamos un Predicate y una Lista para almacenar los nombres.
Luego creamos un flujo de nombres usando el método List.toStream() y aplicamos la operación filter(). La operación de filtro toma el Predicate nameGreaterThan4 como argumento.
La operación de filtro que usaba este Predicate permitía solo las cadenas cuya longitud era mayor que 4. Las cadenas que coincidían con el Predicate finalmente fueron recopiladas por la operación de recopilación y almacenadas en una Lista.
En lugar de crear objetos de Predicate por separado, podemos pasar directamente el Predicate a la función de filtro. Mira el código a continuación:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(x -> x.length() > 4).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Producción :
[Karan, Aarya, Rahul, Pranav]
Método Predicate.and() en Java
Podemos usar el método Predicate.and() para aplicar dos predicados a la operación de filtro. Devuelve un Predicate compuesto que refleja un Y lógico de este y cortocircuitando otro predicado.
Si este Predicate es false al evaluar el Predicate compuesto, el otro Predicate no se evalúa. La firma del método de este método es:
default Predicate<T> and(Predicate<? super T> other)
Otro en el argumento se refiere al segundo predicado, que podemos querer aplicar. Veamos ahora algunos ejemplos para aprender sobre este método. Mira el código a continuación:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameGreaterThan3 = x -> x.length() > 3;
Predicate<String> nameLesserThan5 = x -> x.length() < 5;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameGreaterThan3.and(nameLesserThan5)).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Producción :
[Alok]
En el código anterior, el primer Predicate verifica si la longitud de la cadena es mayor que 3, y el segundo verifica si la longitud de la cadena es menor que 5. Cuando ambos predicados se pasan a la operación de filtro con la operación AND, esto filtra nombres cuya longitud es igual a 4.
El código anterior se puede escribir de manera más concisa de la siguiente manera:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(x -> x.length() > 3 && x.length() < 5).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Producción :
[Alok]
Método Predicate.or() en Java
Al igual que en la discusión anterior, aplicamos la operación AND usando el método and(). También podemos aplicar la operación OR utilizando el método or().
Devuelve un Predicate compuesto que refleja un OR lógico de este y otro Predicate que está en cortocircuito. Si este Predicate es true, el otro Predicate no se considera al evaluar el Predicate compuesto.
La firma del método de este método es:
default Predicate<T> or(Predicate<? super T> other)
Otro en el argumento se refiere al segundo predicado, que podemos querer aplicar. Veamos ahora algunos ejemplos para aprender sobre este método. Mira el código a continuación:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// predicate
Predicate<String> nameEqualTo3 = x -> x.length() == 3;
Predicate<String> nameEqualTo2 = x -> x.length() == 2;
// Create a list
List<String> name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> name_filtered =
name.stream().filter(nameEqualTo3.or(nameEqualTo2)).collect(Collectors.toList());
// print the resulting list
System.out.println(name_filtered);
}
}
Producción :
[Ram, Om]
En el código anterior, el primer Predicate verifica si la longitud de la cadena es igual a 3, y el segundo Predicate verifica si la longitud de la cadena es igual a 5. Cuando ambos predicados se pasan a la operación de filtro con la operación OR, esto filtra nombres cuya longitud es igual a 3 o 2.
El código anterior se puede escribir de manera más concisa de la siguiente manera:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String args[]) {
// Create a list
List<String> je_name = Arrays.asList("Ram", "Karan", "Aarya", "Rahul", "Om", "Pranav", "Alok");
// create a stream
// apply filter operation
// pass the predicate
List<String> je_name_filtered = je_name.stream()
.filter(x -> x.length() == 3 || x.length() == 2)
.collect(Collectors.toList());
// print the resulting list
System.out.println(je_name_filtered);
}
}
Producción :
[Ram, Om]