LiveData只是数据持有者而已。我们也可以说LiveData是具有生命周期意识的消费者。强烈建议LiveData了解生命周期的概念和相关对象LifeCycleOwner/ lifecycle，您可以获得业务逻辑的转换和流功能，以及UI的生命周期感知操作。

Rx是一个强大的工具，能够以优雅的声明式风格解决问题。它处理业务端选项或服务Api操作

Android LiveData是原始观察者模式的变体，增加了活动/非活动转换。因此，它的范围非常有限。

使用Android LiveData中描述的示例，创建了一个类来监视位置数据，并根据应用程序状态注册和注销。

RxJava提供了更通用的操作符。让我们假设这个可观察对象将提供位置数据:

Observable<LocationData> locationObservable;

可观察对象的实现可以使用observable .create()来映射回调操作。当可观察对象被订阅时，回调被注册，当它被取消订阅时，回调被取消注册。实现看起来与示例中提供的代码非常相似。

让我们也假设你有一个可观察对象，当应用程序处于活动状态时，它会发出true:

Observable<Boolean> isActive;

然后，您可以通过以下步骤提供LiveData的所有功能

Observable<LocationData> liveLocation =
  isActive
    .switchMap( active -> active ? locationObservable : Observable.never() );

switchMap()操作符将以流的形式提供当前位置，如果应用程序不是活动的，则什么也不提供。一旦你有了liveLocation可观察对象，你就可以使用RxJava操作符对它做很多事情。我最喜欢的例子是:

liveLocation.distinctUntilChanged()
  .filter( location -> isLocationInAreaOfInterest( location ) )
  .subscribe( location -> doSomethingWithNewLocation( location ) );

它只会在位置改变时执行操作，并且位置是有趣的。您可以创建类似的操作 结合时间运算符来确定速度。更重要的是，您可以使用RxJava操作符详细控制操作是发生在主线程、后台线程还是多个线程中。

RxJava的重点在于，它使用库提供的操作，甚至您提供的自定义操作，将控制和计时结合到一个单一的领域。

LiveData只处理了其中的一小部分，相当于构建了liveLocation。

比较LiveData和RxJava就像比较苹果和水果沙拉。

比较LiveData和contenttobserver，你是在比较苹果和苹果。LiveData有效地替代了contenttobserver的生命周期。

将RxJava与AsyncTask或任何其他线程工具进行比较，就像将水果沙拉与橙子进行比较一样，因为RxJava帮助的不仅仅是线程。

正如你所知，在响应式生态系统中，我们有一个发出数据的Observable和一个订阅(获得通知)这个Observable发出的Observer，所谓的Observer模式是如何工作的并没有什么奇怪的。一个可观察对象“喊”了什么，观察者会得到通知，可观察对象在给定时刻喊了什么。

把LiveData看作一个可观察对象，它允许你管理处于活动状态的观察者。换句话说，LiveData是一个简单的可观察对象，但也负责生命周期。

但是让我们看看你请求的两个代码案例:

A)实时数据

(B) RXJava

A)这是LiveData的一个基本实现

1)你通常在ViewModel中实例化LiveData来维护方向变化(你可以有只读的LiveData，或可写的mutabllivedata，所以你通常从类LiveData外部公开)

2)在Main Activity的OnCreate方法中(不是ViewModel) 你“订阅”一个观察者对象(通常是一个onChanged方法)

3)你启动方法观察建立链接

首先是ViewModel(拥有业务逻辑)

class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

这是MainActivity(尽量哑)

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)

        ViewModelProvider.observe(this, Observer {//Points 2 and 3
            //what you want to observe
        })


        }
    }
}

B)这是RXJava的基本实现

1)你声明一个可观察对象

2)您声明为观察员

3)你订阅观察者的可观察对象

Observable.just(1, 2, 3, 4, 5, 6) // Point 1

   .subscribe(new Subscriber() {    //Points 2 & 3
       @Override
       public void onCompleted() {
           System.out.println("Complete!");
       }

       @Override
       public void onError(Throwable e) {
       }

       @Override
       public void onNext(Double value) {
           System.out.println("onNext: " + value);
       }
    });

In particular LiveData is used with Lifecycle and often with ViewModel(as we have seen) architecture components. In fact when LiveData is combined with a ViewModel allows you to keep updated in real time every change in the Observer, so that the events are managed in real time where is needed. To use LiveData is strongly recommended to know the concept of lifecycle and the relative objects LifeCycleOwner/LifeCycle, also I would suggest you to have a look at Transformations, if you want to implement LiveData in real life scenarios. Here you can find some use cases from the great commonsware.

To wrap up basically LiveData is a simplified RXJava, an elegant way to observe changes across multiple components without creating explicit so called dependency rules between the components, so that you can test much easier the code and make it much more readable. RXJava, allows you to do the things of LiveData and much more. Because of the extended functionalities of RXJava, you can both use LiveData for simple cases or exploit all the power of RXJava keep using Android Architecture components as the ViewModel, of course this means that RXJava can be far more complex, just think has hundreds of operators instead of SwitchMap and Map of LiveData(at the moment).

RXJava版本2是一个革命性的面向对象范式的库，增加了一种所谓的函数式方式来管理程序流。

我的简单回答是不要使用RxJava。这是一种过于复杂和滥用的方式。对于所有使用RxJava的项目来说，它们都很难维护和调试。RxJava是异步的，使用线程来分派请求，一般来说这是完全不必要的，如果需要的话，Kotlin协程在99%的情况下做得更好。

事实上，LiveData与RxJava并不是本质上不同的工具，那么当RxJava可以通过将所有订阅的可观察对象存储在CompositeDispoable对象中，然后将它们处理在Activity的onDestroy()或Fragment的onDestroyView()中，只使用一行代码时，为什么要将它作为架构组件引入?

通过使用RxJava构建一个电影搜索应用程序，然后在这里使用LiveData，我已经完全回答了这个问题。

But in short, yes, it could, but that would need first overriding the relevant lifecycle methods besides having the basic lifecycle knowledge. This still might not make sense for some, but the fact is that according to one of the Jetpack sessions in Google I/O 2018 many developers find lifecycle management complex. The crash errors arising from not handling lifecycle dependence might be another sign that some developers, even if knowledgable of lifecycle, forget to take care of that in every Activity / Fragment they use in their app. In large apps this could become an issue, notwithstanding the negative effect it could have on productivity.

The bottom line is that by introducing LiveData , larger number of developers are expected to adopt MVVM without even having to understand the lifecycle management, memory leak and crash. Even though I have no doubt that LiveData is not comparable with RxJava in terms of capabilities and the power it gives to developers, reactive programming and RxJava is a hard-to-understand concept and tool for many. On the other side, I do not think LiveData is meant to be a replacement for RxJava–it simply cannot–but a very simple tool for handling a controversial widespread issue experienced by many developers.

**更新** 我在这里添加了一篇新文章，解释了滥用LiveData会导致意想不到的结果。RxJava可以在这些情况下发挥作用