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 * Apply a function to the input argument, yielding an appropriate result. A
31 * function may variously provide a mapping between types, object instances or
32 * keys and values or any other form of transformation upon the input.
33 *
34 * @param <T> the type of the input to the {@code apply} operation
35 * @param <R> the type of the result of the {@code apply} operation
36 *
37 * @since 1.8
38 */
39 @FunctionalInterface
40 public interface Function<T, R> {
41
42 /**
43 * Compute the result of applying the function to the input argument
44 *
45 * @param t the input object
46 * @return the function result
47 */
48 R apply(T t);
49
50 /**
51 * Returns a new function which applies the provided function followed by
52 * this function. If either function throws an exception, it is relayed
53 * to the caller.
54 *
55 * @param <V> type of input objects to the combined function. May be the
56 * same type as {@code <T>} or {@code <R>}
57 * @param before an additional function to be applied before this function
58 * is applied
59 * @return a function which performs the provided function followed by this
60 * function
61 * @throws NullPointerException if before is null
62 */
63 default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
64 Objects.requireNonNull(before);
65 return (V v) -> apply(before.apply(v));
66 }
67
68 /**
69 * Returns a new function which applies this function followed by the
70 * provided function. If either function throws an exception, it is relayed
71 * to the caller.
72 *
73 * @param <V> type of output objects to the combined function. May be the
74 * same type as {@code <T>} or {@code <R>}
75 * @param after an additional function to be applied after this function is
76 * applied
77 * @return a function which performs this function followed by the provided
78 * function
79 * @throws NullPointerException if after is null
80 */
81 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
82 Objects.requireNonNull(after);
83 return (T t) -> after.apply(apply(t));
84 }
85
86 /**
87 * Returns a {@code Function} whose {@code apply} method returns its input.
88 *
89 * @param <T> the type of the input and output objects to the function
90 * @return a {@code Function} whose {@code apply} method returns its input
91 */
92 static <T> Function<T, T> identity() {
93 return t -> t;
94 }
95 }
|
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 function that accepts one argument and produces a result.
31 *
32 * <p>This is a <a href="package-summary.html">functional interface</a>
33 * whose functional method is {@link #apply(Object)}.
34 *
35 * @param <T> the type of the input to the function
36 * @param <R> the type of the result of the function
37 *
38 * @since 1.8
39 */
40 @FunctionalInterface
41 public interface Function<T, R> {
42
43 /**
44 * Applies this function to the given argument.
45 *
46 * @param t the function argument
47 * @return the function result
48 */
49 R apply(T t);
50
51 /**
52 * Returns a composed function that first applies the {@code before}
53 * function to its input, and then applies this function to the result.
54 * If evaluation of either function throws an exception, it is relayed to
55 * the caller of the composed function.
56 *
57 * @param <V> the type of input to the {@code before} function, and to the
58 * composed function
59 * @param before the function to apply before this function is applied
60 * @return a composed function that first applies the {@code before}
61 * function and then applies this function
62 * @throws NullPointerException if before is null
63 *
64 * @see #andThen(Function)
65 */
66 default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
67 Objects.requireNonNull(before);
68 return (V v) -> apply(before.apply(v));
69 }
70
71 /**
72 * Returns a composed function that first applies this function to
73 * its input, and then applies the {@code after} function to the result.
74 * If evaluation of either function throws an exception, it is relayed to
75 * the caller of the composed function.
76 *
77 * @param <V> the type of output of the {@code after} function, and of the
78 * composed function
79 * @param after the function to apply after this function is applied
80 * @return a composed function that first applies this function and then
81 * applies the {@code after} function
82 * @throws NullPointerException if after is null
83 *
84 * @see #compose(Function)
85 */
86 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
87 Objects.requireNonNull(after);
88 return (T t) -> after.apply(apply(t));
89 }
90
91 /**
92 * Returns a function that always returns its input argument.
93 *
94 * @param <T> the type of the input and output objects to the function
95 * @return a function that always returns its input argument
96 */
97 static <T> Function<T, T> identity() {
98 return t -> t;
99 }
100 }
|