Kotlin 将一种类型的可观察对象转换为另一种类型

我有以下代码

class CurrencyRepository @Inject constructor(val apiInterface: ApiInterface,
                                             val ratesDao: RatesDao) {
    fun getRates(): Observable<List<Rates>> {
        val observableFromApi = getCurrencyFromApi()
        val observableFromDb = getRatesFromDb()
        return Observable.concatArrayEager(observableFromApi , observableFromDb)
    }

    private fun getCurrencyFromApi(): Observable<Currency> {
        return apiInterface.getRates()
                .doOnNext {
                    Timber.i(it.toString())
                    val map = it.rates
                    val keys = map.keys
                    for (key in keys) {
                        ratesDao.insertRate(Rates(key , map.get(key)))
                    }
                }
    }

    private fun getRatesFromDb(): Observable<List<Rates>> {
        return ratesDao.getAllRates()
                .toObservable()
                .doOnNext {
                    for (rate in it) {
                        Timber.i("Repository DB ${it.size}")
                    }
                }
    }
}

class CurrencyRepository@Inject构造函数（val-apiInterface:apiInterface，
val ratesDao:ratesDao）{
fun getRates（）：可观察{
val observeFromAPI=getCurrencyFromApi（）
val observeFromDB=getRatesFromDb（）
返回可观察的。concatArrayEager（observableFromApi，observableFromDb）
}
private fun getCurrencyFromApi（）：可观察{
返回apinterface.getRates（）
doOnNext先生{
Timber.i（it.toString（））
val map=it.rates
val keys=map.keys
用于（输入键）{
ratesDao.insertRate（Rates（key，map.get（key）））
}
}
}
private fun getRatesFromDb（）：可观察{
返回率dao.getAllRates（）
.TooObservable（）文件
doOnNext先生{
对于（it中的费率）{
Timber.i（“存储库数据库${it.size}”）
}
}
}
}

在

getCurrencyFromApi（）

中，

getRates（）

返回一个

可观察的
。我希望此特定函数返回
Observable
，以便在
CurrencyRepository
的
Observable.concatarayager
内部
getRates（）
中使用它

货币包含可以转换为列表对象的地图对象。我不清楚如何在
getCurrencyFromApi（）中实现这一点
可能的解决方案之一是

fun getRatesFromApi(): Observable<List<Rates>> {
    return apiInterface.getRates()
        .flatMapIterable { it.rates.entries }
        .map { Rates(it.key ,it.value) }
        .doOnNext { ratesDao.insertRate(it) }
        .toList()
        .toObservable()
}

fun getRatesFromApi（）：可观察{
返回apinterface.getRates（）
.flatMapIterable{it.rates.entries}
.map{Rates（it.key，it.value）}
.doOnNext{ratesDao.insertRate（it）}
托利斯先生（）
.TooObservable（）文件
}

我建议您在数据库中一次性插入项目，因为这样会更有效率
 可能的解决方案之一是

fun getRatesFromApi(): Observable<List<Rates>> {
    return apiInterface.getRates()
        .flatMapIterable { it.rates.entries }
        .map { Rates(it.key ,it.value) }
        .doOnNext { ratesDao.insertRate(it) }
        .toList()
        .toObservable()
}

fun getRatesFromApi（）：可观察{
返回apinterface.getRates（）
.flatMapIterable{it.rates.entries}
.map{Rates（it.key，it.value）}
.doOnNext{ratesDao.insertRate（it）}
托利斯先生（）
.TooObservable（）文件
}

我建议您在数据库中一次性插入项目，因为这样会更有效率