Rxjava基本使用

最新推荐文章于 2021-07-16 19:19:25 发布
最新推荐文章于 2021-07-16 19:19:25 发布
阅读量432 收藏
点赞数
分类专栏： android问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011889786/article/details/53982480
版权

之前转载过一篇Rxjava的使用，现在自己写了一个demo分析下简单的使用，估计下次就该分析源码了大笑


一.基本用法

(1)用的是new  Action1

//     observable call 1 currentThreadmain
//     subscrible callxcqw  我是大雄currentThreadmain
//     observable call 2 currentThreadmain
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("xcqw observable call 1 currentThread" + Thread.currentThread().getName());
                subscriber.onNext("xcqw  我是大雄");
                System.out.println("xcqw observable call 2 currentThread" + Thread.currentThread().getName());
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String o) {
                System.out.println("xcqw subscrible call" + o + "currentThread" + Thread.currentThread().getName());
            }
        });

(2)用的是new subscriber 

//       observable call 1 currentThreadmain
//       onNext xcqw  我是大雄asdcurrentThreadmain
//       observable call 2 currentThreadmain
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("xcqw observable call 1 currentThread" + Thread.currentThread().getName());
                subscriber.onNext("xcqw  我是大雄asd");
                System.out.println("xcqw observable call 2 currentThread" + Thread.currentThread().getName());
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                System.out.println("xcqw onNext " + s + "currentThread" + Thread.currentThread().getName());
            }
        });



二.指定Observable call 和 Subscriber指定直线线程

(1)observable 指定工作线程

    /**
     * 普通的调用 create  指定 observable call的执行线程
     * 可以看出指定的observale call 执行在子线程（Schedulers.io()）
     * 而且 subscribe call 也执行在子线程（Schedulers.io()，如果想改变要用observeOn）
     */
    public void methodTwo() {
//        observable call 1 currentThreadRxIoScheduler-2
//        subscrible callxcqw  我是大雄currentThreadRxIoScheduler-2
//        observable call 2 currentThreadRxIoScheduler-2
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("xcqw observable call 1 currentThread" + Thread.currentThread().getName());
                subscriber.onNext("xcqw  我是大雄");
                System.out.println("xcqw observable call 2 currentThread" + Thread.currentThread().getName());
            }
        }).subscribeOn(Schedulers.io())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String o) {
                        System.out.println("xcqw subscrible call" + o + "currentThread" + Thread.currentThread().getName());
                    }
                });
    }

(2)observale call  和 subscribe 指定线程 

 /**
     * 普通的调用 create  指定 observable call的执行线程
     * 可以看出指定的observale call 执行在子线程（Schedulers.io()）
     * 而且 subscribe call 也执行在子线程（Schedulers.io()，如果想改变要用observeOn）
     * observeOn(AndroidSchedulers.mainThread())
     */
    public void methodThree() {
//        observable call 1 currentThreadRxIoScheduler-2
//        observable call 2 currentThreadRxIoScheduler-2
//        subscrible callxcqw  我是大雄currentThreadmain
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("xcqw observable call 1 currentThread" + Thread.currentThread().getName());
                subscriber.onNext("xcqw  我是大雄");
                System.out.println("xcqw observable call 2 currentThread" + Thread.currentThread().getName());
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String o) {
                        System.out.println("xcqw subscrible call" + o + "currentThread" + Thread.currentThread().getName());
                    }
                });
    }




三.from的用法

  /**
     * from  将其它种类的对象和数据类型转换为Observable
     * 将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
     * from默认不在任何特定的调度器上执行。然而你可以将Scheduler作为可选的第二个参数传递给Observable，
     * 它会在那个调度器上管理这个Future。
     * Javadoc: from(array))
     * Javadoc: from(Iterable))
     * Javadoc: from(Future))
     * Javadoc: from(Future,Scheduler))
     * Javadoc: from(Future,timeout, timeUnit))
     */
    public void methodFour() {
        //没有1/0
//        xcqw items1
//        xcqw items2
//        xcqw items3
//        xcqw items4
//        xcqw items5
//        xcqw items6

        //有1/0
//        xcqw onclick2
//        xcqw items1
//        xcqw throwablejava.lang.ArithmeticException: divide by zero
        Integer[] items = {1, 2, 3, 4, 5, 6};
        Observable myObservable = Observable.from(items);
        myObservable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer items) {
                System.out.println("xcqw items" + items);
                int x = 1 / 0;
            }

        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                System.out.println("xcqw throwable" + throwable.toString());
            }
        }, new Action0() {
            @Override
            public void call() {

            }
        });

    }



四.just的用法

(1).

  /**
     * just
     * 将一个或多个对象转换成发射这个或这些对象的一个Observable
     * Just将单个数据转换为发射那个数据的Observable。
     * Just类似于From，但是From会将数组或Iterable的数据取出然后逐个发射，
     * 而Just只是简单的原样发射，
     * 将数组或Iterable当做单个数据。
     */
//    注意：如果你传递null给Just，它会返回一个发射null值的Observable。
//    不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），
//    如果需要空Observable你应该使用Empty操作符。
//    RxJava将这个操作符实现为just函数，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。
    public void methodFive() {
//        Observable.just(1, 2, 3)
//        xcqw Next: 1
//        xcqw Next: 2
//        xcqw Next: 3
//        xcqw Sequence complete

//        Observable.just(null)
//          onclick2
//          onNext null
//          onCompleted
        Observable.just(null)
//                .subscribe(new Subscriber<Integer>() {
//                    @Override
//                    public void onNext(Integer item) {
//                        System.out.println("xcqw Next: " + item);
//                    }
//
//                    @Override
//                    public void onError(Throwable error) {
//                        System.err.println("xcqw Error: " + error.getMessage());
//                    }
//
//                    @Override
//                    public void onCompleted() {
//                        System.out.println("xcqw Sequence complete.");
//                    }
//                });
                .subscribe(new Subscriber<Object>() {
                    @Override
                    public void onCompleted() {
                        System.out.println("xcqw onCompleted ");
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("xcqw onError " + e.toString());
                    }

                    @Override
                    public void onNext(Object o) {
                        System.out.println("xcqw onNext " + o);
                    }
                });
    }


(2)just执行线程

/**
     * just执行方法   不指定线程默认就是main
     */
    public void methodFive_one() {
//        xcqw onclick2
//        xcqw justMethod Threadmain
//        xcqw onNextUser{name='daxiong', age=25, address='NC'}
//        xcqw onComplete
        Observable.just(justMethod())
//                .subscribeOn(Schedulers.io()) //如果设置这个  just  依然是main  但是 onNext 就是在子线程
                .subscribe(new Subscriber<User>() {
                    @Override
                    public void onCompleted() {
                        System.out.println("xcqw onComplete");
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("xcqw onError" + e.toString());
                    }

                    @Override
                    public void onNext(User user) {
                        System.out.println("xcqw onNext" + user.toString() + "thread" + Thread.currentThread().getName());
                    }
                });
    }



五.flatmap用法

 /**
     * flatmap  执行在主线程  无论observableOn什么线程
     * 扁平映射，将Observable发射的数据变换为Observables集合，
     * 然后将这些Observable发射的数据平坦化的放进一个单独的Observable，
     * 可以认为是一个将嵌套的数据结构展开的过程
     * <p/>
     * 将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable
     */
    public void method_five() {

        Observable.from(userList)
                .flatMap(new Func1<User, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(User user) {
                        System.out.println("xcqw Observale thread" + Thread.currentThread().getName());
                        return Observable.from(user.courseList);
                    }
                })

//        xcqw Observale threadmain
//        xcqw call course数学0threadmain
//        xcqw call course语文0threadmain
//        xcqw call course英语0threadmain
//        xcqw Observale threadmain
//        xcqw call course数学1threadmain
//        xcqw call course语文1threadmain
//        xcqw call course英语1threadmain
//        xcqw Observale threadmain
//        xcqw call course数学2threadmain
//        xcqw call course语文2threadmain
//        xcqw call course英语2threadmain
//                .subscribe(new Action1<Course>() {
//            @Override
//            public void call(Course course) {
//                System.out.println("xcqw call course"+course.courseName+"thread"+Thread.currentThread().getName());
//            }
//        });


//        xcqw Observale threadmain
//        xcqw onNext course数学0threadmain
//        xcqw onNext course语文0threadmain
//        xcqw onNext course英语0threadmain
//        xcqw Observale threadmain
//        xcqw onNext course数学1threadmain
//        xcqw onNext course语文1threadmain
//        xcqw onNext course英语1threadmain
//        xcqw Observale threadmain
//        xcqw onNext course数学2threadmain
//        xcqw onNext course语文2threadmain
//        xcqw onNext course英语2threadmain
//                .subscribe(new Subscriber<Course>() {
//            @Override
//            public void onCompleted() {
//
//            }
//
//            @Override
//            public void onError(Throwable e) {
//
//            }
//
//            @Override
//            public void onNext(Course course) {
//                System.out.println("xcqw onNext course"+course.courseName+"thread"+Thread.currentThread().getName());
//            }
//        });


//            xcqw Observale threadRxIoScheduler-2
//            xcqw Observale threadRxIoScheduler-2
//            xcqw Observale threadRxIoScheduler-2
//            xcqw onNext course数学0threadmain
//            xcqw onNext course语文0threadmain
//            xcqw onNext course英语0threadmain
//            xcqw onNext course数学1threadmain
//            xcqw onNext course语文1threadmain
//            xcqw onNext course英语1threadmain
//            xcqw onNext course数学2threadmain
//            xcqw onNext course语文2threadmain
//            xcqw onNext course英语2threadmain
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Course>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Course course) {
                        System.out.println("xcqw onNext course" + course.courseName + "thread" + Thread.currentThread().getName());
                    }
                });

    }



六.map的用法（把一个对象转换成另外一个）

    public void methond_six_map() {
        Observable.from(userList)
                .map(new Func1<User, String>() {
                    @Override
                    public String call(User user) {
                        System.out.println("xcqw map call thread" + Thread.currentThread().getName());
                        return user.name;
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        System.out.println("xcqw action call " + s + "thread" + Thread.currentThread().getName());
                    }
                });


//        xcqw map call threadRxIoScheduler-2
//        xcqw map call threadRxIoScheduler-2
//        xcqw map call threadRxIoScheduler-2
//        xcqw action call 大熊0threadmain
//        xcqw action call 大熊1threadmain
//        xcqw action call 大熊2threadmain
//                .subscribeOn(Schedulers.io())
//                .observeOn(AndroidSchedulers.mainThread())
//                .subscribe(new Action1<String>() {
//                    @Override
//                    public void call(String s) {
//                        System.out.println("xcqw action call "+s+ "thread"+Thread.currentThread().getName());
//                    }
//                });


//        xcqw map call threadRxIoScheduler-2
//        xcqw action call 大熊0threadRxIoScheduler-2
//        xcqw map call threadRxIoScheduler-2
//        xcqw action call 大熊1threadRxIoScheduler-2
//        xcqw map call threadRxIoScheduler-2
//        xcqw action call 大熊2threadRxIoScheduler-2
//            .subscribeOn(Schedulers.io())
//                    .subscribe(new Action1<String>() {
//                @Override
//                public void call(String s) {
//                    System.out.println("xcqw action call "+s+ "thread"+Thread.currentThread().getName());
//                }
//            });


//            xcqw map call threadmain
//            xcqw action call 大熊0threadmain
//            xcqw map call threadmain
//            xcqw action call 大熊1threadmain
//            xcqw map call threadmain
//            xcqw action call 大熊2threadmain
//                .subscribe(new Action1<String>() {
//            @Override
//            public void call(String s) {
//                System.out.println("xcqw action call "+s+ "thread"+Thread.currentThread().getName());
//            }
//        });
    }



七.Filter的用法

 /**
     * 过滤，过滤掉没有通过谓词测试的数据项，只发射通过测试的
     */
    public void methodEightFilter() {

//        xcqw filter callthreadmain
//        xcqw subscribe call age0threadmain
//        xcqw filter callthreadmain
//        xcqw filter callthreadmain
//        Observable.from(userList)
//                .filter(new Func1<User, Boolean>() {
//                    @Override
//                    public Boolean call(User user) {
//                        System.out.println("xcqw filter call"+"thread"+Thread.currentThread().getName());
//                        return user.name.equals("大熊0");
//                    }
//                }).subscribe(new Action1<User>() {
//            @Override
//            public void call(User user) {
//                System.out.println("xcqw subscribe call age"+user.age+"thread"+Thread.currentThread().getName());
//            }
//        });


//        xcqw filter callthreadRxIoScheduler-2
//        xcqw subscribe call age0threadRxIoScheduler-2
//        xcqw filter callthreadRxIoScheduler-2
//        xcqw filter callthreadRxIoScheduler-2
//        Observable.from(userList)
//                .filter(new Func1<User, Boolean>() {
//                    @Override
//                    public Boolean call(User user) {
//                        System.out.println("xcqw filter call"+"thread"+Thread.currentThread().getName());
//                        return user.name.equals("大熊0");
//                    }
//                }).subscribeOn(Schedulers.io())
//                .subscribe(new Action1<User>() {
//            @Override
//            public void call(User user) {
//                System.out.println("xcqw subscribe call age"+user.age+"thread"+Thread.currentThread().getName());
//            }
//        });


//        xcqw filter callthreadRxIoScheduler-2
//        xcqw filter callthreadRxIoScheduler-2
//        xcqw filter callthreadRxIoScheduler-2
//        xcqw subscribe call age0threadmain
        Observable.from(userList)
                .filter(new Func1<User, Boolean>() {
                    @Override
                    public Boolean call(User user) {
                        System.out.println("xcqw filter call" + "thread" + Thread.currentThread().getName());
                        return user.name.equals("大熊0");
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<User>() {
                    @Override
                    public void call(User user) {
                        System.out.println("xcqw subscribe call age" + user.age + "thread" + Thread.currentThread().getName());
                    }
                });
    }




八.compose的用法

/**
     * compose都是在主线程执行 无论subscibeon 或者 observableon设置成子线程或者主线程执行
     */
    public void methodNineCompose() {
        initData();
//        xcqw onclick2
//        xcqw compose onNext threadname   RxIoScheduler-2
//        xcqw compose onNext threadname   RxIoScheduler-2
//        xcqw compose onNext threadname   RxIoScheduler-2
//        xcqw compose onCompleted threadname   RxIoScheduler-2
        Observable.from(userList).compose(new Observable.Transformer<User, User>() {
            @Override
            public Observable<User> call(Observable<User> userObservable) {
                System.out.println("xcqw compose Observable threadname " + Thread.currentThread().getName());
                return userObservable.subscribeOn(Schedulers.io())
                        .observeOn(Schedulers.io());
            }
        }).subscribe(new Subscriber<User>() {
            @Override
            public void onCompleted() {
                System.out.println("xcqw compose onCompleted threadname   " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("xcqw compose onError threadname   " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(User user) {
                System.out.println("xcqw compose onNext threadname   " + Thread.currentThread().getName());
            }
        });



注意：

Compose 和 flatmap的区别(个人理解就是Compose作用的是整个流，而flatmap作用的是转换的单个对象)

下面是网上的一些详细解释

这一段从这篇博客拷过来，此处谢谢大神大笑http://blog.csdn.net/jdsjlzx/article/details/51508678

compose()和flatMap()有啥区别呢。他们都是发射出Observable，是不是就是说他们都可以复用一系列操作符呢？

The difference is that compose() is a higher level abstraction: it operates on the entire stream, not individually emitted items. In more specific terms:

中文翻译：

区别在于compose()是高等级的抽象，他操作的是整个流，而不是单一发射出的项目，这里有更多的解释： 
VS 
不同点在于compose()操作符拥有更高层次的抽象概念：它操作于整个数据流中，不仅仅是某一个被发送的事件。具体如下：

原文：

1 compose() is the only way to get the original Observable from the stream. Therefore, operators that affect the whole stream (like subscribeOn() and observeOn()) need to use compose().

In contrast, if you put subscribeOn()/observeOn() in flatMap(), it would only affect the Observable you create in flatMap() but not the rest of the stream.

2 compose() executes immediately when you create the Observable stream, as if you had written the operators inline. flatMap() executes when its onNext() is called, each time it is called. In other words, flatMap() transforms each item, whereas compose() transforms the whole stream.

3 flatMap() is necessarily less efficient because it has to create a new Observable every time onNext() is called. compose() operates on the stream as it is.

中文翻译1：

  1. compose()是唯一一个能从流中获取原生Observable 的方法，因此，影响整个流的操作符（像subscribeOn()和observeOn()）需要使用compose()，相对的，如果你在flatMap()中使用subscribeOn()/observeOn()，它只影响你创建的flatMap()中的Observable,而不是整个流。

  2. 当你创建一个Observable流并且内联了一堆操作符以后，compose()会立即执行，flatMap()则是在onNext()被调用以后才会执行，换句话说，flatMap()转换的是每个项目，而compose()转换的是整个流。

  3. flatMap()一定是低效率的，因为他每次调用onNext()之后都需要创建一个新的Observable，compose()是操作在整个流上的。

dx我是大雄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【翻译】忘了RxJava吧——你需要的是拥抱Kotlin协程（Part 1/2）
SpkingR的博客
09-02 1691
一、前言 我非常喜欢 Kotlin ，也非常喜欢 Kotlin Coroutines 协程，在看到了这篇文章后心里真是激动啊！于是乎——就有了这篇谷歌自动人工翻译，以飨观众！希望大家喜欢。哈哈。 :sunglasses: 作者：Vladimir Ivanov 阅读时间： 4 分钟 原文链接：https://proandroiddev.com/forget-rxjava-kotli...
Java中实现异步转同步的几种方式
最新发布
qq_44691484的博客
02-28 2616
实现异步转同步
java.lang.ArithmeticException: divide by zero
shanshan_1117的博客
06-03 1289
错误原因: 除数不能为0 检查看看除数是否为0了,集合等长度是否为0
理解RxJava的线程模型
程序猿开发日志【学习永无止境】
07-30 3132
ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几年越来越流行了，现在已经支持几乎全部的流行编程语言了，Rx的大部分语言库由Re
Rxjava解决android的请求接口的回调地狱
王攀
06-28 2961
Consumer consumer1 = new Consumer&lt;HttpResult&lt;List&lt;User&gt;&gt;&gt;() { @Override public void accept(HttpResult&lt;List&lt;User&gt;&gt; listHttpResult) throws Exception { ...
RxJava的使用
10-27
为了更好地理解RxJava，你需要了解它的基本概念，掌握如何创建和订阅Observable，以及如何使用各种Operator来处理数据流。此外，对于Android开发，了解如何与Android组件配合以及处理线程和异常也至关重要。通过深入...
RxJava使用
12-05
**一、RxJava基本概念** 1. **Observable（可观察者）**：这是RxJava的核心元素，它是一个可以发送数据或完成/错误信号的对象。开发者可以通过`Observable.create()`方法创建一个Observable。 2. **Observer（观察...
RxJava基本流程
06-30
下面我们将详细探讨标题和描述中提到的 RxJava 基本流程，以及 `flatMap` 的使用。 ### RxJava 基本流程 1. **创建 Observable**: 在示例代码中，通过 `Observable.create()` 方法创建了一个 Observable。这个 ...
RxJava2使用简介Demo
12-27
**RxJava2使用简介** RxJava是一个在Java虚拟机上运行的反应式编程库，它将观察者模式和函数响应式编程的概念结合在一起，为异步编程和事件处理提供了强大的工具。RxJava2是其第二代版本，相较于第一代，它在性能、...
RxJava使用测试
12-26
在Android中，使用`RxAndroidPlugins`和`RxLifecycle`库可以很好地处理RxJava的生命周期问题，确保在Activity或Fragment销毁时自动取消订阅。 **实践案例** 在`MyRxDemo`项目中，你可以看到如何实际运用RxJava进行...
基于RxJava封装的异步聚合计算结果的工具类
tinysakura的博客
02-25 580
实习时被大佬问了一个问题，如何将一个foreach操作分别在不同线程中执行后同步聚集异步操作的结果执行后面的操作以提升响应速度，当时上线问题还有一个没解决所以忙乱中只想出一个通过CountDownLatch(闭锁)的方法，之后仔细想了想至少有三种方法可以解决这个问题。 闭锁 第一种方式闭锁，不用多说，下面给出伪代码 public static void main(String[] args...
rxjava 并行_使用RxJava和Completable并行执行阻塞任务
最佳 Java 编程
06-26 2059
rxjava 并行 通过RxJava 1.1.1中引入的Completable抽象，如何并行执行阻止“仅副作用”（也称为void）任务的并行执行变得更加容易。 “ 正如您可能已经注意到，阅读我的博客时，我主要专注于软件Craft.io和自动代码测试。 但是，此外，我还是持续交付和广义并发的狂热者。 最后一点从C中的纯线程和信号量到更高级别的解决方案（例如ReactiveX和actor模型...
容易被忽略的知识点：RxJava操作符的线程安全
黎程雨的博客
05-09 350
好文推荐： 作者：fundroid 随着RxJava的深入使用，渐渐发现了一个令人不安的真相： "RxJava的大部分操作符并非线程安全的。" 在一些多线程场景下对RxJava的滥用会发生不符合预期的现象。 Rx操作符并非线程安全 很多人对RxJava的定义是一个异步响应式框架，既然是为异步处理而生的框架线程不安全？ 是的，支持异步并不意味着支持并发 线程不安全会发生什么问题呢？RxJava中的大部分操作符都是线程不安全的， 当多线程同时像一个stream发射数据时，操作符的结果可能不符合预期。 以.
RxJava 并发 之测试
Dream It Possible
07-09 3226
在开发软件的时候，我们需要确保代码正确执行。为了快速的获取每次修改后的反馈，通常开发人员使用自定义测试。在同步的 Rx 中测试和普通 Java 中的单元测试没有太大的区别。如果要测试异步代码，可能会有点需要注意的地方，比如要测试下面的代码：Observable.interval(1, TimeUnit.SECONDS) .take(5)上面的 Observable 发射一个数据流，需要 5秒
rxjava2 的blockingAwait和blockingGet区别
lerous的专栏
07-16 1309
blockingAwait Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted. blockingGet Subscribes to this Completable instance and blocks until it terminates, then returns null o..
简单理解RemoteView
热门推荐
u011889786的专栏
05-25 2万+
一．介绍 RemoteView表示的是一个View结构，他可以在其他进程中显示，由于它在其他进程中显示，为了能够更新他的界面，RemoteViews提供了一组基础的操作应用与跨进程更新它的界面。   二．应用场景 1.通知栏 2.桌面小部件   三．RemoteViews的应用 桌面小部件则是通过AppWidgetProvider来实现的，AppWidget本质是一个广播. 通知
android去掉 radio 或 checkBox 的默认图标,用自己的图标
u011889786的专栏
10-17 1万+
1.第一步（checkbox和RadioButton一样） android:button="@null" 2.第二步（同上，两个一样） android:background="@drawable/textselector" 3.注意 a.在模拟器上跑每个radiobutton需要设置id,否则多个radiobutton可以多选 b.真机上不用设置id,不会出现上面的情况
画虚线需要设置android:layerType="software"，否则无效
u011889786的专栏
10-17 1万+
一.布局 //Activity_main.xml xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_he
EditText自动弹出软键盘的原因及解决方法
u011889786的专栏
07-26 1万+
部分内容来源于http://blog.csdn.net/cshichao/article/details/8536961   一.产生原因 EditText自动获取到了焦点，所以弹出软键盘，so...解决问题的方法也就是不让他获取到焦点就行。 二.解决方法 (1)在父容器中添加这两段代码（亲测有效） android:focusable="true"
RxJava全套使用完整版.docx
04-09
首先，文档对RxJava的基本概念进行了解释，包括Observable(可观察者)、Observer(观察者)、Subscription(订阅)等。然后，文档介绍了如何创建Observable以及如何对Observable进行操作和变换，包括Map、Filter、Reduce...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值