Java v->；v>；5.

我有一个给定的函数调用，java给了我一个错误，因为对象与int不可比（当然…）。有人能给我解释一下我需要改变什么吗

我尝试以不同的方式支撑lambda表达式，但没有得到有用的结果。我认为，lambda表达式是正确的，而filter函数有点错误，但我无法找出我的错误

// function call
filter(v -> v > 5)

// function
public Optional<T> filter(Predicate<T> tester) {
    if(isPresent() && tester.test(get())) {
        return this;
    } else {
    return Optional.empty();
    }
}

//函数调用
过滤器（v->v>5）
//作用
公共可选筛选器（谓词测试仪）{
if（isPresent（）&&tester.test（get（））{
归还这个；
}否则{
返回可选的.empty（）；
}
}

我希望有一个可选的.empty-Object，但我得到了一个java错误，因为

v>5

Object v在java原语类型（例如

int

）和对象（例如

Object

）中与int不可比，在类型层次结构中没有共同的祖先。由于谓词和其他流构造有两种风格，例如，在使用

int

时必须使用的谓词和在使用

对象时必须使用的
谓词

编写过滤函数的方法是使用和
IntPredicate
：

public OptionalInt filter(IntPredicate tester) {
    if (isPresent() && tester.test(get())) {
        return ...
    } else {
        return OptionalInt.empty();
    }
}

您必须使
T
成为一个与int相当的包装类

IntStream.range(0, 10)
         .filter(v -> v > 5)
         .forEach(System.out::println);

可以，因为
v
是
int

当
t
未知时，不能使用此表达式

您可以做的是假设
T
必须是一个数字，例如

filter( v -> ((Number) v).doubleValue() > 5)

但是，这将产生一个ClassCastExpection is
T
是另一种类型

真正的解决办法是把
T
a
Number

e、 g

我认为，lambda表达式是正确的
过滤函数有点错误，但我无法找到我的
错误

// function call
filter(v -> v > 5)

// function
public Optional<T> filter(Predicate<T> tester) {
    if(isPresent() && tester.test(get())) {
        return this;
    } else {
    return Optional.empty();
    }
}

你说得对。

您的方法似乎无法满足为类声明的泛型类型，因为首先您的方法是在泛型类中定义的

假设您的类名为
Foo
，这里的
filter（）
方法依赖于泛型
T
类型作为返回/参数类型：

public class Foo<T>{
     // ...
    public Optional<T> filter(Predicate<T> tester) { 
      // ...
    }
}

它将编译得很好，因为将从
Foo
推断出
Integer

所以我认为要解决您的问题，您应该声明Number或Integer作为泛型类型的基类：

public class Foo<T extends Integer>{
     // ...
    public Optional<T> filter(Predicate<T> tester) { 
      // ...
    }
}

公共类Foo{
// ...
公共可选筛选器（谓词测试仪）{
// ...
}
}

或者像前面的例子一样依赖于客户的推断
 
v->v>5
可以表示不同的含义。这取决于上下文

它可能是
（对象v）->v>5
导致编译错误，因为
无法应用于
对象
：

Stream.<Object>of("123", 123).filter(v -> v > 5);


它可能是一个
（int v）->v>5
，这意味着它是的一个实例，在这里一切都会顺利进行：

IntStream.of(123, 123).filter(v -> v > 5);


注意：
Predicate
where
T extends Number
就可以了。@PeterLawrey您完全正确，装箱是另一个选项。有没有办法在不更改函数头中的可选and谓词的情况下实现这一点？因为我真的不想使用
公共可选过滤器（谓词测试仪）更改函数头..@PeterLawrey{
不幸的是，没有work@Hugugagegi您只能在声明它为第一个时间段时定义
，可能在
类Xxxx
行上。查看完整的代码块也会很好。您在哪里使用
过滤器
以及您试图推断的结果是什么？这是不可能的。您返回
此
我这意味着你的类应该扩展
Optional
，这是
final
。你有自己的
Optional
？这个类是泛型类。将
v
转换为
Number
并使用
doubleValue（）
使其与
谓词兼容
看起来像是一种黑客行为。问题的根源在于：类中的T声明。
Stream.<Object>of("123", 123).filter(v -> v > 5);

Stream.<Integer>of(123, 123).filter(v -> v > 5);

IntStream.of(123, 123).filter(v -> v > 5);