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 import java.util.Comparator;
29
30 /**
31 * An operation upon two operands yielding a result. This is a specialization of
32 * {@code BiFunction} where the operands and the result are all of the same type.
33 *
34 * @param <T> the type of operands to {@code apply} and of the result
35 *
36 * @see BiFunction
37 * @since 1.8
38 */
39 @FunctionalInterface
40 public interface BinaryOperator<T> extends BiFunction<T,T,T> {
41 /**
42 * Returns a {@link BinaryOperator} which returns the lesser of two elements
43 * according to the specified {@code Comparator}
44 *
45 * @param <T> the type of values to be compared and returned
46 * @param comparator a {@code Comparator} for comparing the two values
47 * @return a {@code BinaryOperator} which returns the lesser of its operands,
48 * according to the supplied {@code Comparator}
49 * @throws NullPointerException if the argument is null
50 */
51 public static<T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
52 Objects.requireNonNull(comparator);
53 return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
54 }
55
56 /**
57 * Returns a {@link BinaryOperator} which returns the greater of two elements
58 * according to the specified {@code Comparator}
59 *
60 * @param <T> the type of values to be compared and returned
61 * @param comparator a {@code Comparator} for comparing the two values
62 * @return a {@code BinaryOperator} which returns the greater of its operands,
63 * according to the supplied {@code Comparator}
64 * @throws NullPointerException if the argument is null
65 */
66 public static<T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
67 Objects.requireNonNull(comparator);
68 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
69 }
70 }
|
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 import java.util.Comparator;
29
30 /**
31 * Represents an operation upon two operands of the same type, producing a result
32 * of the same type as the operands. This is a specialization of
33 * {@link BiFunction} for the case where the operands and the result are all of
34 * the same type.
35 *
36 * <p>This is a <a href="package-summary.html">functional interface</a>
37 * whose functional method is {@link #apply(Object, Object)}.
38 *
39 * @param <T> the type of the operands and result of the operator
40 *
41 * @see BiFunction
42 * @see UnaryOperator
43 * @since 1.8
44 */
45 @FunctionalInterface
46 public interface BinaryOperator<T> extends BiFunction<T,T,T> {
47 /**
48 * Returns a {@link BinaryOperator} which returns the lesser of two elements
49 * according to the specified {@code Comparator}.
50 *
51 * @param <T> the type of the input arguments of the comparator
52 * @param comparator a {@code Comparator} for comparing the two values
53 * @return a {@code BinaryOperator} which returns the lesser of its operands,
54 * according to the supplied {@code Comparator}
55 * @throws NullPointerException if the argument is null
56 */
57 public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
58 Objects.requireNonNull(comparator);
59 return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
60 }
61
62 /**
63 * Returns a {@link BinaryOperator} which returns the greater of two elements
64 * according to the specified {@code Comparator}.
65 *
66 * @param <T> the type of the input arguments of the comparator
67 * @param comparator a {@code Comparator} for comparing the two values
68 * @return a {@code BinaryOperator} which returns the greater of its operands,
69 * according to the supplied {@code Comparator}
70 * @throws NullPointerException if the argument is null
71 */
72 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
73 Objects.requireNonNull(comparator);
74 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
75 }
76 }
|