blocks|key|461454|text|我相信两者是相同的，都将在上游完成时产生一个项目，如果提供了多个项目(如文档所述)，两者都会产生错误，所以使用它们的安全方法是observable.take(1).toSingle()，或者实际上是observable.take(1).single()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|461455|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I believe that both are identical, both will produce 1 item on upstream completion, both will produce error if supplied with more than one item (as the documentation states), so the safe way of using them would be observable.take(1).toSingle() or indeed observable.take(1).single()

blocks|key|2552784|text|为什么这两种方法都存在？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|2552785|single()是最初的ReactiveX操作符集的一部分。toSingle()是在Single引入RxJava之后添加的。|unstyled|offset|length|style|CODE|2552786|他们有什么不同？|2552787|它们返回一个不同的基类反应性类。single()保持Observable，toSingle()转换为Single。|2552788|他们中的任何一个应该使用另一个吗？|2552789|这取决于您想使用哪种类型，以及您是否计划很快迁移到RxJava+2.x。在RxJava+2中，没有toSingle，(大多数)操作符现在返回一个更合适的类型：single(T)、singleOrError()或singleElement()。|2552790|他们的大理石图是不同的|2552791|toSingle的大理石没有错误大小写，而Single类型的时间图在表示事件的时间上与Observable略有不同。|2552792|entityMap^0|0|0|8|U|A|16|6|0|0|G|8|Q|A|11|A|1E|6|0|0|1D|8|27|9|2H|F|2X|F|0|0|0|8|L|6|17|A|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@$E|Y|F|Z|G|H]|$E|10|F|11|G|H]|$E|12|F|13|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|15|8|@$E|16|F|17|G|H]|$E|18|F|19|G|H]|$E|1A|F|1B|G|H]|$E|1C|F|1D|G|H]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1F|8|@$E|1G|F|1H|G|H]|$E|1I|F|1J|G|H]|$E|1K|F|1L|G|H]|$E|1M|F|1N|G|H]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1O|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1P|8|@$E|1Q|F|1R|G|H]|$E|1S|F|1T|G|H]|$E|1U|F|1V|G|H]]|9|@]|A|$]]|$1|U|3|-4|5|D|7|1W|8|@]|9|@]|A|$]]]|V|$]]

<blockquote>
 why both these methods exists? 
</blockquote>

<code>single()</code> is part of the original ReactiveX set of operators. <code>toSingle()</code> has been added later when <code>Single</code> was introduced into RxJava.

<blockquote>
 What differences do they have?
</blockquote>

They return a different base reactive class. <code>single()</code> stays <code>Observable</code> and <code>toSingle()</code> converts to <code>Single</code>.

<blockquote>
 Should any of them use the other?
</blockquote>

Depends on what types you want to use and whether or not you plan to move to RxJava 2.x soon. In RxJava 2, there is no <code>toSingle</code> and (most) operators now return a more appropriate type: <code>single(T)</code>, <code>singleOrError()</code> or <code>singleElement()</code>.

<blockquote>
 their marble diagrams are different
</blockquote>

<code>toSingle</code>'s marble doesn't feature the error case and <code>Single</code> type's time diagram has slightly different convention to represent event over time than with <code>Observable</code>.

I stumbled upon these to methods and from what I get from the docs, they do the almost the exact same thing. Looking at the code they clearly do different stuff. From starters <code>single()</code> returns an <code>Observable</code> (why?) while toSingle() effectively returns a <code>Single</code>.

My limited knowledge of the reactive world leaves me wondering, why both these methods exists? What differences do they have? Should any of them use the other? 

Do any or both of them <code>immediately</code> transform the <code>Observable</code> to a <code>Single</code> and, if it hasn't emitted any items, it throws an error? Or do they wait for the events to get emitted?

Another thing that baffles me is that their marble diagrams are different
(<a href="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toSingle.png" rel="nofollow noreferrer">toSingle</a> and <a href="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/single.png" rel="nofollow noreferrer">single</a>), but what their docs say they should behave exactly the same, in particular they should behave like <code>single()</code> marble diagram.

Here are the docs:
<a href="http://reactivex.io/RxJava/javadoc/rx/Observable.html#toSingle" rel="nofollow noreferrer">Observable#toSingle</a>
<a href="http://reactivex.io/RxJava/javadoc/rx/Observable.html#single--" rel="nofollow noreferrer">Observable#single</a>

Difference between Observable#single() and Observable#toSingle()?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我无意中发现了这些方法，从我从文档中得到的信息来看，它们所做的几乎是完全一样的事情。看代码，他们显然会做不同的事情。首先，single()返回一个Observable (为什么？)而toSingle()实际上返回一个Single。我对反应性世界的认识有限，我想知道，为什么这两种方法都存在？他们有什么不同？他们中的任何一...

问Observable#single()和Observable#toSingle()之间的区别？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Observable#single()和Observable#toSingle()之间的区别？EN