Java：如何使用Lamda重写——在Lamda中可以抛出异常

我如何通过Java Lambda重写它

这个问题不同于“Lambda表达式和泛型方法”问题。该问题是因为引发了异常。

public Observable<String> getUserInfo() {
    return Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            try {
                emitter.onNext( getPlayerInfo());
                emitter.onComplete();
            } catch (Exception e) {
                emitter.onError(e);
            }
        }
    }).subscribeOn(Schedulers.io())
      .observeOn(AndroidSchedulers.mainThread());
}

public Observable getUserInfo（）{
返回Observable.create（newobservableOnSubscribe（）{
@凌驾
public void subscribe（observeItemer发射器）引发异常{
试一试{
onNext（getPlayerInfo（））；
emitter.onComplete（）；
}捕获（例外e）{
发射体。onError（e）；
}
}
}).subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
}

当我通过一个普通的Lambda重写它时，我会得到以下错误：

不兼容类型：必需：可观察。发现： 可见的

这就是我所尝试的：

public Observable<String> getUserInfo() {
    return Observable.create( emitter -> {
            try {
                emitter.onNext(getPlayerInfo();
                emitter.onComplete();
            } catch (Exception e) {
                emitter.onError(e);
            }
        }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread());
}

public Observable getUserInfo（）{
返回可见。创建（发射器->{
试一试{
onNext（getPlayerInfo（）；
emitter.onComplete（）；
}捕获（例外e）{
发射体。onError（e）；
}
}).subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
}

编译器的推理机无法确定可观察的

的类型参数，因此需要明确指定它：

return Observable.<String>create( emitter -> {

返回可见。创建（发射器->{
编译器的推理机无法确定可观察的
的类型参数，因此需要明确指定它：

return Observable.<String>create( emitter -> {

返回可见。创建（发射器->{
类型推断失败的具体原因是对subscribeOn和observeOn的后续调用。另一种解决方案是引入中间方法或变量，例如：

private Observable<String> getUserInfo() {
    Observable<String> userInfo = Observable.create( emitter -> {
            try {
                emitter.onNext(getPlayerInfo();
                emitter.onComplete();
            } catch (Exception e) {
                emitter.onError(e);
            }
        });

    return userInfo
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread());
}

private Observable getUserInfo（）{
Observable userInfo=Observable.create（发射器->{
试一试{
onNext（getPlayerInfo（）；
emitter.onComplete（）；
}捕获（例外e）{
发射体。onError（e）；
}
});
返回用户信息
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
}
类型推断失败的具体原因是对subscribeOn和observeOn的后续调用。另一种解决方案是引入中间方法或变量，例如：

private Observable<String> getUserInfo() {
    Observable<String> userInfo = Observable.create( emitter -> {
            try {
                emitter.onNext(getPlayerInfo();
                emitter.onComplete();
            } catch (Exception e) {
                emitter.onError(e);
            }
        });

    return userInfo
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread());
}

private Observable getUserInfo（）{
Observable userInfo=Observable.create（发射器->{
试一试{
onNext（getPlayerInfo（）；
emitter.onComplete（）；
}捕获（例外e）{
发射体。onError（e）；
}
});
返回用户信息
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
}
可能重复您为什么要这样做？我看不出这两种形式在可读性或仪式上有什么不同。Lambda并不总是提高代码的可读性。我同意。在这种情况下，它更简洁。只显示业务逻辑，没有仪式内容。但是，可能重复您为什么要这样做？我看到no两种形式的可读性或仪式感不同。Lambda并不总是提高代码的可读性。我同意。在这种情况下，它更简洁。只显示业务逻辑，没有仪式内容。太好了！非常感谢！太好了！非常感谢！