Java8 - 通过实例学习数字函数接口

java8中的函数接口有哪些？

Java8引入了一个函数接口，以实现java语言的函数式编程。

java.util.function 包有许多预定义的功能接口。

这些函数接口可以作为目标分配给lambda表达式或方法/构造器引用。

在对象的迭代过程中，这些将非常有用，流API处理，以及像过滤数据那样处理数字数据的操作。

这篇文章是关于各种数字(Integer,Long,Double 相关的)功能接口的例子。

java中的ToLongBiFunction接口示例

这个接口需要两个参数作为输入，产生一个长类型的输出。

下面的代码接收两个长值，使用lambda表达式添加这个值，最后在函数上调用applyAsLong ，返回长值结果。

import java.util.function.ToLongBiFunction;

public class ToLongBiFunctionExample {
    public static void main(String[] args) {
        ToLongBiFunction addLongFunction=(value1, value2)-> value1+value2;
        System.out.println(addLongFunction.applyAsLong(50l,40l)); // 90
    }
}  

java中ToLongFunction接口示例

这个函数接受两个长值作为输入并产生一个长值。

import java.util.ArrayList;
import java.util.List;
import java.util.function.ToLongFunction;

public class MyToLongFunctionExample {

    public static void main(String[] args) {
        // program example 1  
        List list = new ArrayList();
        list.add("123");
        list.add("43");
        list.add("56");
        list.add("53");
        long[] result = list.stream().mapToLong(element -> Long.parseLong(element)).toArray();

        System.out.println(result);
        // program example 2  
        ToLongFunction longFunction = value -> Long.parseLong(value);
        System.out.println(longFunction.applyAsLong("123"));

    }
}  

在上面的代码中，呈现了两个例子:

• 第一个例子是将一个字符串列表转换为长字符串。
• 创建一个字符串的列表
• 使用streams接口，用mapToLong方法遍历每个元素
• mapToLong(ToLongFunction f) 使用lambda表达式间接使用ToLongFunction 。
• 下一个例子，使用ToLongFunction将字符串数据转换为long对象。

ToDoubleFunction接口 java例子

它的功能是从对象中产生双倍值。

import java.util.function.ToDoubleFunction;
public class MyToDoubleFunctionExample {
    public static void main(String[] args) {

        ToDoubleFunction doubleFunction = value -> Double.parseDouble(value);
        System.out.println(doubleFunction.applyAsDouble("54")); // output 54
    }
}  

ToDoubleBiFunction接口示例

这个函数需要两个参数作为输入，产生一个double 。

下面的代码获取两个integer ，使用lambda表达式添加这些值，并将它们分配给函数接口。最后，在函数上调用applyAsDouble来返回Double结果。

import java.util.function.ToDoubleBiFunction;
public class Test {
    public static void main(String[] args) {
        ToDoubleBiFunction addDoubleFunction=(value1, value2)-> value1+value2;
        System.out.println(addDoubleFunction.applyAsDouble(5,4)); //outputs 9  
    }
}  

ToIntFunction 示例

它接收一个object 数据并产生一个Integer 值。

这是一个使用ToInitFunction 接口和lambda表达式将一个字符串转换为整数的例子。

import java.util.function.ToIntFunction;

public class Test {
    public static void main(String[] args) {
        ToIntFunction intFunction= value-> Integer.parseInt(value);
        System.out.println(intFunction.applyAsInt("5")); // output 5
    }
}  

ToIntBiFunctioninterface

这个接口接收two 的参数integer ，并产生一个integer 的结果。

import java.util.fnction.DoubleToLongFunction;
import java.util.function.ToIntBiFunction;

public class Test {
    public static void main(String[] args) {
        ToIntBiFunction addIntFunction=(value1, value2)-> value1+value2;
        System.out.println(addIntFunction.applyAsInt(15,14)); //outputs 29
    }
}  

DoubleToLongFunction

这个接口接收Double 的值，并产生一个long 的结果。

import java.util.function.DoubleToLongFunction;
public class Test {
    public static void main(String[] args) {
        DoubleToLongFunction function = value-> new Double(value).longValue();
        System.out.println(function.applyAsLong(43.7)); //outputs 43
    }
}  

IntFunction示例

该接口接收Integer 值作为参数，并产生一个给定数据类型的结果。

import java.util.function.IntFunction;
public class Test {
    public static void main(String[] args) {
        IntFunction function= value-> String.valueOf(value);
        System.out.println(function.apply(43)); // outputs "43"  
        System.out.println(function.apply(43).length()); // outputs 2
    }
}  

IntToLongFunction接口

该接口以一个integer 作为输入，并产生一个Long 的值。

import java.util.function.IntToLongFunction;

public class Test {
    public static void main(String[] args) {
        IntToLongFunction fucntion= (value) -> Long.valueOf(value);
        System.out.println(fucntion.applyAsLong(21));
    }
}   

LongFunction接口

这些接口接受long 值作为参数，并产生一个给定数据类型的结果。

import java.util.function.LongFunction;

public class Test {
    public static void main(String[] args) {
        LongFunction longFunction= value-> String.valueOf(value);
        System.out.println(longFunction.apply(512l)); // outputs "512"
        System.out.println(longFunction.apply(513l).length()); // outputs 3
    }
}  

LongToDoubleFunction接口

该接口接受一个long 值作为输入，并产生一个double 值作为输出。

import java.util.function.LongToDoubleFunction;

public class Test {
    public static void main(String[] args) {
        LongToDoubleFunction longTDoubleFunction= (value) -> Double.valueOf(value);
        System.out.println(longTDoubleFunction.applyAsDouble(21l)); //outputs 21.0
    }
}  

LongToIntFunction接口

该接口接受long 作为输入，并输出int 值。

import java.util.function.LongToIntFunction;

public class Test {
    public static void main(String[] args) {
        LongToIntFunction longToIntFunction = value-> (int)(value);
        System.out.println(longToIntFunction.applyAsInt(20143)); // outputs 20143
    }
}