jdk/src/share/classes/java/util/function/BiPredicate.java
changeset 17695 032254f2467b
parent 16011 890a7ed97f6c
child 19040 7b25fde2a4ed
equal deleted inserted replaced
17694:31d23e077ab3 17695:032254f2467b
    28 
    28 
    29 /**
    29 /**
    30  * Determines if the input objects match some criteria. This is the two-arity
    30  * Determines if the input objects match some criteria. This is the two-arity
    31  * specialization of {@link Predicate}.
    31  * specialization of {@link Predicate}.
    32  *
    32  *
    33  * @param <T> the type of the first argument to {@code test}.
    33  * @param <T> the type of the first argument to {@code test}
    34  * @param <U> the type of the second argument to {@code test}.
    34  * @param <U> the type of the second argument to {@code test}
    35  *
    35  *
    36  * @see Predicate
    36  * @see Predicate
    37  * @since 1.8
    37  * @since 1.8
    38  */
    38  */
    39 @FunctionalInterface
    39 @FunctionalInterface
    40 public interface BiPredicate<T, U> {
    40 public interface BiPredicate<T, U> {
    41 
    41 
    42     /**
    42     /**
    43      * Return {@code true} if the inputs match some criteria.
    43      * Return {@code true} if the inputs match some criteria.
    44      *
    44      *
    45      * @param t an input object.
    45      * @param t an input object
    46      * @param u an input object.
    46      * @param u an input object
    47      * @return {@code true} if the inputs match some criteria.
    47      * @return {@code true} if the inputs match some criteria
    48      */
    48      */
    49     boolean test(T t, U u);
    49     boolean test(T t, U u);
    50 
    50 
    51     /**
    51     /**
    52      * Returns a predicate which evaluates to {@code true} only if this
    52      * Returns a predicate which evaluates to {@code true} only if this
    53      * predicate and the provided predicate both evaluate to {@code true}. If
    53      * predicate and the provided predicate both evaluate to {@code true}. If
    54      * this predicate returns {@code false} then the remaining predicate is not
    54      * this predicate returns {@code false} then the remaining predicate is not
    55      * evaluated.
    55      * evaluated.
    56      *
    56      *
    57      * @param p a predicate which will be logically-ANDed with this predicate.
    57      * @param p a predicate which will be logically-ANDed with this predicate
    58      * @return a new predicate which returns {@code true} only if both
    58      * @return a new predicate which returns {@code true} only if both
    59      * predicates return {@code true}.
    59      * predicates return {@code true}
       
    60      * @throws NullPointerException if p is null
    60      */
    61      */
    61     public default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> p) {
    62     default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> p) {
    62         Objects.requireNonNull(p);
    63         Objects.requireNonNull(p);
    63         return (T t, U u) -> test(t, u) && p.test(t, u);
    64         return (T t, U u) -> test(t, u) && p.test(t, u);
    64     }
    65     }
    65 
    66 
    66     /**
    67     /**
    67      * Returns a predicate which negates the result of this predicate.
    68      * Returns a predicate which negates the result of this predicate.
    68      *
    69      *
    69      * @return a new predicate who's result is always the opposite of this
    70      * @return a new predicate who's result is always the opposite of this
    70      * predicate.
    71      * predicate
    71      */
    72      */
    72     public default BiPredicate<T, U> negate() {
    73     default BiPredicate<T, U> negate() {
    73         return (T t, U u) -> !test(t, u);
    74         return (T t, U u) -> !test(t, u);
    74     }
    75     }
    75 
    76 
    76     /**
    77     /**
    77      * Returns a predicate which evaluates to {@code true} if either this
    78      * Returns a predicate which evaluates to {@code true} if either this
    78      * predicate or the provided predicate evaluates to {@code true}. If this
    79      * predicate or the provided predicate evaluates to {@code true}. If this
    79      * predicate returns {@code true} then the remaining predicate is not
    80      * predicate returns {@code true} then the remaining predicate is not
    80      * evaluated.
    81      * evaluated.
    81      *
    82      *
    82      * @param p a predicate which will be logically-ORed with this predicate.
    83      * @param p a predicate which will be logically-ORed with this predicate
    83      * @return a new predicate which returns {@code true} if either predicate
    84      * @return a new predicate which returns {@code true} if either predicate
    84      * returns {@code true}.
    85      * returns {@code true}
       
    86      * @throws NullPointerException if p is null
    85      */
    87      */
    86     public default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> p) {
    88     default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> p) {
    87         Objects.requireNonNull(p);
    89         Objects.requireNonNull(p);
    88         return (T t, U u) -> test(t, u) || p.test(t, u);
    90         return (T t, U u) -> test(t, u) || p.test(t, u);
    89     }
    91     }
    90 
       
    91     /**
       
    92      * Returns a predicate that evaluates to {@code true} if both or neither of
       
    93      * the component predicates evaluate to {@code true}.
       
    94      *
       
    95      * @param p a predicate which will be logically-XORed with this predicate.
       
    96      * @return a predicate that evaluates to {@code true} if both or neither of
       
    97      * the component predicates evaluate to {@code true}.
       
    98      */
       
    99     public default BiPredicate<T, U> xor(BiPredicate<? super T, ? super U> p) {
       
   100         Objects.requireNonNull(p);
       
   101         return (T t, U u) -> test(t, u) ^ p.test(t, u);
       
   102     }
       
   103 }
    92 }