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 is not a STREAM while in RxJava everything (literally everything) is a STREAM. LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state. LiveData is synchronous, So you can't execute a chunk of code (network call, database manipulation etc.) asynchronously using just LiveData as you do with RxJava. What best you can do to exploit the most of this duo is to use RxJava for your business logic (network call, data manipulation etc, anything that happens in and beyond Repository) and use LiveData for your presentation layer. By this, you get transformation and stream capabilities for your business logic and lifecycle-aware operation for your UI. LiveData and RxJava compliment each other if used together. What I mean is, do everything with RxJava and at the end when you want to update UI, do something like the code given below to change your Observable into LiveData. So, your View (UI) observes to the LiveData in ViewModel where your LiveData is nothing but non-mutable MutableLiveData (or MutableLiveData is mutable LiveData). So the question here is, why should you even use LiveData at the first place? As you can see below in the code, you store your response from RxJava to MutableLiveData (or LiveData) and your LiveData is lifecycle-aware, so in a way, your data is lifecycle-aware. Now, just imagine the possibility when your data itself know when and when-not-to update the UI. LiveData doesn't have a history (just the current state). Hence, you shouldn't use LiveData for a chat application. When you use LiveData with RxJava you don't need stuff like MediatorLiveData, SwitchMap etc. They are stream control tools and RxJava is better at that by many times. See LiveData as a data holder thing and nothing else. We can also say LiveData is lifecycle-aware consumer.

    public class RegistrationViewModel extends ViewModel {
        Disposable disposable;

        private RegistrationRepo registrationRepo;
        private MutableLiveData<RegistrationResponse> modelMutableLiveData =
                new MutableLiveData<>();

        public RegistrationViewModel() {
        }

        public RegistrationViewModel(RegistrationRepo registrationRepo) {
            this.registrationRepo = registrationRepo;
        }

        public void init(RegistrationModel registrationModel) {
            disposable = registrationRepo.loginForUser(registrationModel)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<Response<RegistrationResponse>>() {
                        @Override
                        public void accept(Response<RegistrationResponse>
                                                   registrationModelResponse) throws Exception {

                            modelMutableLiveData.setValue(registrationModelResponse.body());
                        }
                    });
        }

        public LiveData<RegistrationResponse> getModelLiveData() {
            return modelMutableLiveData;
        }

       @Override
       protected void onCleared() {
                super.onCleared();
            disposable.dispose();
         }
    }

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

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

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

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部分等于Rx Subject或SharedRxObservable LiveData管理订阅的生命周期，但Rx主题 订阅应该手动创建和处理 LiveData没有终止状态，但Rx Subject有OnError 和oncomplete

关于最初的问题，RxJava和LiveData都能很好地互补。

LiveData在ViewModel层上表现出色，它与Android生命周期和ViewModel紧密集成。RxJava在转换方面提供了更多的功能(正如@Bob Dalgleish所提到的)。

目前，我们在数据源和存储库层使用RxJava，并在ViewModels中转换为LiveData(使用LiveDataReactiveStreams)(在将数据暴露给活动/片段之前)-非常满意这种方法。