10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.util.function;
26
27 import java.util.Objects;
28
29 /**
30 * Determines if the input objects match some criteria. This is the two-arity
31 * specialization of {@link Predicate}.
32 *
33 * @param <T> the type of the first argument to {@code test}
34 * @param <U> the type of the second argument to {@code test}
35 *
36 * @see Predicate
37 * @since 1.8
38 */
39 @FunctionalInterface
40 public interface BiPredicate<T, U> {
41
42 /**
43 * Return {@code true} if the inputs match some criteria.
44 *
45 * @param t an input object
46 * @param u an input object
47 * @return {@code true} if the inputs match some criteria
48 */
49 boolean test(T t, U u);
50
51 /**
52 * Returns a predicate which evaluates to {@code true} only if this
53 * predicate and the provided predicate both evaluate to {@code true}. If
54 * this predicate returns {@code false} then the remaining predicate is not
55 * evaluated.
56 *
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
59 * predicates return {@code true}
60 * @throws NullPointerException if p is null
61 */
62 default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> p) {
63 Objects.requireNonNull(p);
64 return (T t, U u) -> test(t, u) && p.test(t, u);
65 }
66
67 /**
68 * Returns a predicate which negates the result of this predicate.
69 *
70 * @return a new predicate who's result is always the opposite of this
71 * predicate
72 */
73 default BiPredicate<T, U> negate() {
74 return (T t, U u) -> !test(t, u);
75 }
76
77 /**
78 * Returns a predicate which evaluates to {@code true} if either this
79 * predicate or the provided predicate evaluates to {@code true}. If this
80 * predicate returns {@code true} then the remaining predicate is not
81 * evaluated.
82 *
83 * @param p a predicate which will be logically-ORed with this predicate
84 * @return a new predicate which returns {@code true} if either predicate
85 * returns {@code true}
86 * @throws NullPointerException if p is null
87 */
88 default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> p) {
89 Objects.requireNonNull(p);
90 return (T t, U u) -> test(t, u) || p.test(t, u);
91 }
92 }
|
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.util.function;
26
27 import java.util.Objects;
28
29 /**
30 * Represents a predicate (boolean-valued function) of two arguments. This is
31 * the two-arity specialization of {@link Predicate}.
32 *
33 * <p>This is a <a href="package-summary.html">functional interface</a>
34 * whose functional method is {@link #test(Object, Object)}.
35 *
36 * @param <T> the type of the first argument to the predicate
37 * @param <U> the type of the second argument the predicate
38 *
39 * @see Predicate
40 * @since 1.8
41 */
42 @FunctionalInterface
43 public interface BiPredicate<T, U> {
44
45 /**
46 * Evaluates this predicate on the given arguments.
47 *
48 * @param t the first input argument
49 * @param u the second input argument
50 * @return {@code true} if the input arguments match the predicate,
51 * otherwise {@code false}
52 */
53 boolean test(T t, U u);
54
55 /**
56 * Returns a composed predicate that represents a short-circuiting logical
57 * AND of this predicate and another. When evaluating the composed
58 * predicate, if this predicate is {@code false}, then the {@code other}
59 * predicate is not evaluated.
60 *
61 * <p>Any exceptions thrown during evaluation of either predicate are relayed
62 * to the caller; if evaluation of this predicate throws an exception, the
63 * {@code other} predicate will not be evaluated.
64 *
65 * @param other a predicate that will be logically-ANDed with this
66 * predicate
67 * @return a composed predicate that represents the short-circuiting logical
68 * AND of this predicate and the {@code other} predicate
69 * @throws NullPointerException if other is null
70 */
71 default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
72 Objects.requireNonNull(other);
73 return (T t, U u) -> test(t, u) && other.test(t, u);
74 }
75
76 /**
77 * Returns a predicate that represents the logical negation of this
78 * predicate.
79 *
80 * @return a predicate that represents the logical negation of this
81 * predicate
82 */
83 default BiPredicate<T, U> negate() {
84 return (T t, U u) -> !test(t, u);
85 }
86
87 /**
88 * Returns a composed predicate that represents a short-circuiting logical
89 * OR of this predicate and another. When evaluating the composed
90 * predicate, if this predicate is {@code true}, then the {@code other}
91 * predicate is not evaluated.
92 *
93 * <p>Any exceptions thrown during evaluation of either predicate are relayed
94 * to the caller; if evaluation of this predicate throws an exception, the
95 * {@code other} predicate will not be evaluated.
96 *
97 * @param other a predicate that will be logically-ORed with this
98 * predicate
99 * @return a composed predicate that represents the short-circuiting logical
100 * OR of this predicate and the {@code other} predicate
101 * @throws NullPointerException if other is null
102 */
103 default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
104 Objects.requireNonNull(other);
105 return (T t, U u) -> test(t, u) || other.test(t, u);
106 }
107 }
|