Java DoubleToLongFunction.applyAsLong方法代码示例

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjShortToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjShortToLongFunction} 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
 * long}.
 */
@Nonnull
default ObjShortToLongFunction<T> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsLong(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ToLongBiFunction2} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ToLongBiFunction2} 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
 * long}.
 */
@Nonnull
default ToLongBiFunction2<T, U> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, u) -> after.applyAsLong(applyAsDouble(t, u));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link TriIntToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code TriIntToLongFunction} 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
 * long}.
 */
@Nonnull
default TriIntToLongFunction andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2, value3) -> after.applyAsLong(applyAsDouble(value1, value2, value3));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link IntToLongFunction2} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code IntToLongFunction2} 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
 * long}.
 */
@Nonnull
default IntToLongFunction2 andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (value) -> after.applyAsLong(applyAsDouble(value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Creates a {@link BiObjDoubleToLongFunction} which uses the {@code third} parameter of this one as argument for
 * the given {@link DoubleToLongFunction}.
 *
 * @param <T> The type of the first argument to the function
 * @param <U> The type of the second argument to the function
 * @param function The function which accepts the {@code third} parameter of this one
 * @return Creates a {@code BiObjDoubleToLongFunction} which uses the {@code third} parameter of this one as
 * argument for the given {@code DoubleToLongFunction}.
 * @throws NullPointerException If given argument is {@code null}
 */
@Nonnull
static <T, U> BiObjDoubleToLongFunction<T, U> onlyThird(@Nonnull final DoubleToLongFunction function) {
    Objects.requireNonNull(function);
    return (t, u, value) -> function.applyAsLong(value);
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiObjFloatToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code BiObjFloatToLongFunction} 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
 * long}.
 */
@Nonnull
default BiObjFloatToLongFunction<T, U> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, u, value) -> after.applyAsLong(applyAsDouble(t, u, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjByteToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjByteToLongFunction} 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
 * long}.
 */
@Nonnull
default ObjByteToLongFunction<T> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsLong(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjIntToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjIntToLongFunction} 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
 * long}.
 */
@Nonnull
default ObjIntToLongFunction<T> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, value) -> after.applyAsLong(applyAsDouble(t, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiObjDoubleToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code BiObjDoubleToLongFunction} 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
 * long}.
 */
@Nonnull
default BiObjDoubleToLongFunction<T, U> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, u, value) -> after.applyAsLong(applyAsDouble(t, u, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link LongSupplier2} that first applies this supplier 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 supplier to an operation returning {@code long}.
 *
 * @param after The function to apply after this supplier is applied
 * @return A composed {@code LongSupplier2} that first applies this supplier 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
 * long}.
 */
@Nonnull
default LongSupplier2 andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return () -> after.applyAsLong(getAsDouble());
}
 

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

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link ObjBiByteToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code ObjBiByteToLongFunction} 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
 * long}.
 */
@Nonnull
default ObjBiByteToLongFunction<T> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, value1, value2) -> after.applyAsLong(applyAsDouble(t, value1, value2));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link TriBooleanToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code TriBooleanToLongFunction} 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
 * long}.
 */
@Nonnull
default TriBooleanToLongFunction andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (value1, value2, value3) -> after.applyAsLong(applyAsDouble(value1, value2, value3));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiObjShortToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code BiObjShortToLongFunction} 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
 * long}.
 */
@Nonnull
default BiObjShortToLongFunction<T, U> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, u, value) -> after.applyAsLong(applyAsDouble(t, u, value));
}
 

import java.util.function.DoubleToLongFunction; //导入方法依赖的package包/类
/**
 * Returns a composed {@link BiObjCharToLongFunction} 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 long}.
 *
 * @param after The function to apply after this function is applied
 * @return A composed {@code BiObjCharToLongFunction} 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
 * long}.
 */
@Nonnull
default BiObjCharToLongFunction<T, U> andThenToLong(@Nonnull final DoubleToLongFunction after) {
    Objects.requireNonNull(after);
    return (t, u, value) -> after.applyAsLong(applyAsDouble(t, u, value));
}