Java 检查Lambda表达式中的参数

我有以下代码：

 Function<Integer, String> converter = (num) -> Integer.toString(num);

函数转换器=（num）->Integer.toString（num）；

正如我在这里看到的，“num”是函数的参数，但是，如果我的用户不小心输入了一个float，就会出现错误。 我只在函数代码中创建“num”参数？

---

如何添加异常，如

if（！（num instanceOf Integer））{//throw exception}

一旦尝试传递转换器，就会出现编译时错误

public static void main(String[] args) {
        Function<Integer, String> converter = (num) -> Integer.toString(num);
        Stream<String> stream = asList(1, 3, 4.5).stream().map(converter); //compilation error here as soon as you enter a float in asList.
        stream.forEach(System.out::println);
    }

publicstaticvoidmain（字符串[]args）{
函数转换器=（num）->Integer.toString（num）；
Stream-Stream=asList（1,3,4.5）.Stream（）.map（converter）；//在asList中输入浮点值时，此处出现编译错误。
stream.forEach（System.out:：println）；
}

您可以创建一个包装器方法，该方法返回包装在try-catch中的转换器函数

Function<Integer, String> converter = num -> num.toString();

System.out.println(wrapper(converter).apply(5));

private static Function<Integer, String> wrapper(Function<Integer, String> function) {
        return x -> {
            try {
                return function.apply(x);
            } catch (Exception e) {
                return "Error";
            }
        };
    }

Function converter=num->num.toString（）；
System.out.println（包装器（转换器）.apply（5））；
专用静态函数包装器（函数）{
返回x->{
试一试{
返回函数。应用（x）；
}捕获（例外e）{
返回“错误”；
}
};
}

要向lambda表达式添加检查，只需将其当作函数使用即可：

Function<Number , String> converter = (num) -> {
    final String result;
    if (num instanceof Integer) {
        result = Integer.toString((int)num);
    } else {
        result = "show some error";
       //Or throw an exception
    }
    return result;
};

函数转换器=（num）->{
最终字符串结果；
if（num instanceof Integer）{
结果=整数.toString（（int）num）；
}否则{
result=“显示一些错误”；
//或者抛出异常
}
返回结果；
};

更好的方法是调用一个方法，因为对于较长的方法，这可能会变得混乱

也许是这样的：

Function<Number , String> converter = e -> convertString(e);

public static String convertString(Number num) {
    final String result;
    if (num instanceof Integer) {
        result = Integer.toString((int)num);
    } else {
        result = "show some error";
    }
    return result;
}

函数转换器=e->convertString（e）；
公共静态字符串convertString（Number num）{
最终字符串结果；
if（num instanceof Integer）{
结果=整数.toString（（int）num）；
}否则{
result=“显示一些错误”；
}
返回结果；
}

您还可以使用FooClass:：convertString。

声明

Function<Integer, String> converter = num -> Integer.toString(num);

将抛出

java.lang.ClassCastException:在输入lambda表达式的代码之前，java.lang.Float不能被转换为java.lang.Integer

就像你写的一样

Function<Integer, String> converter = MyClass::myLambdaCode;
…
private static String myLambdaCode(Integer num) {
    return Integer.toString(num);
}

Function converter=MyClass:：myLambdaCode；
…
私有静态字符串myLambdaCode（整数num）{
返回整数.toString（num）；
}

---

更简洁。但从技术上讲，这是一样的。不可能使用不是

Integer

实例的对象输入代码。检查

num

是否不是一个

整数

没有意义。它始终是（除非

null

）。如果它是

null

，则

Integer.toString（num）

会抛出一个

NullPointerException

，因此事先检查一下，也就是说，抛出一个异常是过时的。

首选的方法是在调用

函数之前检查它的类型

if(input instanceof Integer){
    return converter.apply((Integer)input);
}else{
    //throw exception;
}

或者您需要使用
可选
过滤输入

Function<Integer, String> converter = (num) -> Integer.toString(num);

String result = Optional.ofNullable(input)
            .filter(Integer.class::isInstance)
            .map(Integer.class::cast)
            .map(converter).orElseThrow(IllegalArgumentException::new);

检查lambda表达式中的参数类型将导致lambda膨胀，通常是不必要的，因为如果您使用完全相同的参数类型定义FunctionInterface，则无法将不兼容的类型传递给lambda表达式，如果您喜欢@Holger，则将抛出CalsCastException
 
之后的
整数
应该是
num->num.toString（）
@Andreas:这有一个有趣的区别
num->num.toString（）
可以处理非
Integer
类型，而
Integer.toString（num）
本质上要求
num
为
整数，即使目标类型没有强制要求它也是如此。但是由于目标类型强制将
num
强制为
Integer
，因此您确实可以使用
num->num.toString（）
甚至
Object:：toString
，但仍然会得到一个不适用于非
Integer
输入的函数……那么我如何在那里添加异常呢？比如if（num isntanceOf Integer）{//throw exception}，因为我只在函数代码中创建“num”参数？当编译器阻止异常时，为什么需要抛出异常？您的实际需求是什么？在这两种变体中，
num
不可能不是
整数。在第二个示例中，这一点应该特别明显，在该示例中，您显式声明了
Integer num
。
if(input instanceof Integer){
    return converter.apply((Integer)input);
}else{
    //throw exception;
}

Function<Integer, String> converter = (num) -> Integer.toString(num);

String result = Optional.ofNullable(input)
            .filter(Integer.class::isInstance)
            .map(Integer.class::cast)
            .map(converter).orElseThrow(IllegalArgumentException::new);

Function<Object, Integer> typeChecking = (input) -> (Integer) Optional.ofNullable(input)
        .filter(Integer.class::isInstance)
        .orElseThrow(IllegalArgumentException::new);

Function<Integer, String> intToString = (num) -> Integer.toString(num);

Function<Object, String> converter = typeChecking.andThen(intToString);