Interface Predicate được sử dụng với mục đích chính là để filter một đối tượng Stream. Sử dụng phương thức filter() với tham số là interface Predicate sẽ giúp chúng ta filter những item trong đối tượng Stream thoả mãn điều kiện nào đó.
Nội dung của interface này như sau:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
package java.util.function; import java.util.Objects; /** * Represents a predicate (boolean-valued function) of one argument. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is {@link #test(Object)}. * * @param <T> the type of the input to the predicate * * @since 1.8 */ @FunctionalInterface public interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); /** * Returns a composed predicate that represents a short-circuiting logical * AND of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code false}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ANDed with this * predicate * @return a composed predicate that represents the short-circuiting logical * AND of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } /** * Returns a predicate that represents the logical negation of this * predicate. * * @return a predicate that represents the logical negation of this * predicate */ default Predicate<T> negate() { return (t) -> !test(t); } /** * Returns a composed predicate that represents a short-circuiting logical * OR of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code true}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ORed with this * predicate * @return a composed predicate that represents the short-circuiting logical * OR of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } /** * Returns a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)}. * * @param <T> the type of arguments to the predicate * @param targetRef the object reference with which to compare for equality, * which may be {@code null} * @return a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)} */ static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } /** * Returns a predicate that is the negation of the supplied predicate. * This is accomplished by returning result of the calling * {@code target.negate()}. * * @param <T> the type of arguments to the specified predicate * @param target predicate to negate * * @return a predicate that negates the results of the supplied * predicate * * @throws NullPointerException if target is null * * @since 11 */ @SuppressWarnings("unchecked") static <T> Predicate<T> not(Predicate<? super T> target) { Objects.requireNonNull(target); return (Predicate<T>)target.negate(); } } |
Là một Functional Interface nên Predicate cũng chỉ có 1 phương thức abstract test() thôi các bạn. Phương thức này có tham số với kiểu dữ liệu generic, sau khi xử lý xong sẽ trả về true hoặc false để thông báo là item có thoã mãn điều kiện filter hay không.
Ví dụ như:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.huongdanjava.javaexample; import java.util.Arrays; import java.util.List; public class Example { public static void main(String[] args) { List<String> name = Arrays.asList("Khanh", "Quan"); name.stream() .filter(s -> s.startsWith("K")) .forEach(System.out::println); } } |
Ở ví dụ trên, các bạn có thể thấy, Java sẽ kiểm tra tất cả các item trong đối tượng Stream xem những item nào start với ký tự K, sau đó sẽ in ra những item đó.
Kết quả:
Trong interface Predicate chúng ta còn có một số phương thức default như and(), or(), negate() với chức năng giống như and-and, or, negative.
Với phương thức and() chúng ta có thể tổng hợp nhiều điều kiện để filter dữ liệu. Ví dụ như:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.huongdanjava.javaexample; import java.util.Arrays; import java.util.List; import java.util.function.Predicate; public class Example { public static void main(String[] args) { List<String> name = Arrays.asList("Khanh", "Quan", "Khang"); Predicate<String> p1 = s -> s.startsWith("K"); Predicate<String> p2 = s -> s.endsWith("g"); name.stream() .filter(p1.and(p2)) .forEach(System.out::println); } } |
Kết quả:
Phương thức or() thì chỉ cần thoả điều kiện một trong các điều kiện là được. Ví dụ như:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.huongdanjava.javaexample; import java.util.Arrays; import java.util.List; import java.util.function.Predicate; public class Example { public static void main(String[] args) { List<String> name = Arrays.asList("Khanh", "Quan", "Khang"); Predicate<String> p1 = s -> s.startsWith("K"); Predicate<String> p2 = s -> s.endsWith("g"); name.stream() .filter(p1.or(p2)) .forEach(System.out::println); } } |
Kết quả:
Phương thức negate() thì phủ định của điều kiện. Ví dụ như:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package com.huongdanjava.javaexample; import java.util.Arrays; import java.util.List; import java.util.function.Predicate; public class Example { public static void main(String[] args) { List<String> name = Arrays.asList("Khanh", "Quan", "Khang"); Predicate<String> p1 = s -> s.startsWith("K"); name.stream() .filter(p1.negate()) .forEach(System.out::println); } } |
Kết quả:
