Java DoubleToIntFunction.applyAsInt方法代码示例

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ToIntFunction2} that first applies this function to its input, and then applies the
 * {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to the
 * caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ToIntFunction2} that first applies this function to its input, and then applies the
 * {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ToIntFunction2<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t) -> after.applyAsInt(applyAsDouble(t));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjByteToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjByteToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjByteToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsInt(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiObjBooleanToIntFunction} that first applies this function to its input, and then
 * applies the {@code after} function to the result. If evaluation of either operation throws an exception, it is
 * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to
 * transform this primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code BiObjBooleanToIntFunction} that first applies this function to its input, and then
 * applies the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default BiObjBooleanToIntFunction<T, U> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, u, value) -> after.applyAsInt(applyAsDouble(t, u, value));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjBiFloatToIntFunction} that first applies this function to its input, and then
 * applies the {@code after} function to the result. If evaluation of either operation throws an exception, it is
 * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to
 * transform this primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjBiFloatToIntFunction} that first applies this function to its input, and then
 * applies the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjBiFloatToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.applyAsInt(applyAsDouble(t, value1, value2));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Calls the given {@link DoubleToIntFunction} with the given argument and returns its result.
 *
 * @param function The function to be called
 * @param value The argument to the function
 * @return The result from the given {@code DoubleToIntFunction2}.
 * @throws NullPointerException If given argument is {@code null}
 */
static int call(@Nonnull final DoubleToIntFunction function, double value) {
    Objects.requireNonNull(function);
    return function.applyAsInt(value);
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjBiCharToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjBiCharToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjBiCharToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.applyAsInt(applyAsDouble(t, value1, value2));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link TriLongToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code TriLongToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default TriLongToIntFunction andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2, value3) -> after.applyAsInt(applyAsDouble(value1, value2, value3));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjDoubleToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjDoubleToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjDoubleToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsInt(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link IntBinaryOperator2} that first applies this function to its input, and then applies the
 * {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to the
 * caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code IntBinaryOperator2} that first applies this function to its input, and then applies the
 * {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default IntBinaryOperator2 andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsInt(applyAsDouble(value1, value2));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjLongToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjLongToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjLongToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsInt(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiDoubleToIntFunction} that first applies this operator to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive operator to an operation returning {@code int}.
 *
 * @param after The function to apply after this operator is applied
 * @return A composed {@code BiDoubleToIntFunction} that first applies this operator to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default BiDoubleToIntFunction andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsInt(applyAsDouble(value1, value2));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Creates a {@link TriDoubleToIntFunction} which uses the {@code second} parameter of this one as argument for the
 * given {@link DoubleToIntFunction}.
 *
 * @param function The function which accepts the {@code second} parameter of this one
 * @return Creates a {@code TriDoubleToIntFunction} which uses the {@code second} parameter of this one as argument
 * for the given {@code DoubleToIntFunction}.
 * @throws NullPointerException If given argument is {@code null}
 */
@Nonnull
static TriDoubleToIntFunction onlySecond(@Nonnull final DoubleToIntFunction function) {
    Objects.requireNonNull(function);
    return (value1, value2, value3) -> function.applyAsInt(value2);
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link TriShortToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code TriShortToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default TriShortToIntFunction andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2, value3) -> after.applyAsInt(applyAsDouble(value1, value2, value3));
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Creates a {@link BiDoubleToIntFunction} which uses the {@code second} parameter of this one as argument for the
 * given {@link DoubleToIntFunction}.
 *
 * @param function The function which accepts the {@code second} parameter of this one
 * @return Creates a {@code BiDoubleToIntFunction} which uses the {@code second} parameter of this one as argument
 * for the given {@code DoubleToIntFunction}.
 * @throws NullPointerException If given argument is {@code null}
 */
@Nonnull
static BiDoubleToIntFunction onlySecond(@Nonnull final DoubleToIntFunction function) {
    Objects.requireNonNull(function);
    return (value1, value2) -> function.applyAsInt(value2);
}
 

import java.util.function.DoubleToIntFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjIntToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code int}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjIntToIntFunction} that first applies this function to its input, and then applies
 * the {@code after} function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * int}.
 */
@Nonnull
default ObjIntToIntFunction<T> andThenToInt(@Nonnull final DoubleToIntFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsInt(applyAsDouble(t, value));
}