Anancncn
Anancncn

RxJava 便查手册

介绍

添加依赖

implementation 'io.reactivex.rxjava2:rxjava:xxx'
implementation 'io.reactivex.rxjava2:rxandroid:xxx'

最新版本号获取地址RxJava,RxAndroid

需要了解的基本概念

RxJava由三部分组成: Observable被观察者,Observer观察者,subscribe订阅

操作符

创建

  1. create()
public static  Observable create(ObservableOnSubscribe source)
  
//----
Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext("Hello Observer");
        e.onComplete();
    }
});
//--
Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(String s) {
        Log.d("chan","------> onNext " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {
        Log.d("chan","------> onComplete ");
    }
};
        
observable.subscribe(observer);
  1. just()
    创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。
public static  Observable just(T item) 
......
public static  Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)

//----
Observable.just(1, 2, 3)
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  onSubscribe");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  onComplete ");
    }
});
  1. fromArray()
    和 just() 类似，只不过 fromArray 可以传入多于10个的变量，并且可以传入一个数组
public static  Observable fromArray(T... items)

//---
Integer array[] = {1, 2, 3, 4};
Observable.fromArray(array)
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  onSubscribe");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  onComplete ");
    }
});
  1. fromCallable()
    这里的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它会返回一个结果值，这个结果值就是发给观察者的。
public static  Observable fromCallable(Callable supplier)

Observable.fromCallable(new Callable < Integer > () {

    @Override
    public Integer call() throws Exception {
        return 1;
    }
})
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "------>  accept " + integer);
    }
});
  1. fromFuture()
    参数中的 Future 是 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，它可以通过 get() 方法来获取 Callable 返回的值。
public static  Observable fromFuture(Future future)

//----
FutureTask < String > futureTask = new FutureTask < > (new Callable < String > () {
    @Override
    public String call() throws Exception {
        Log.d(TAG, "CallableDemo is Running");
        return "返回结果";
    }
});

Observable.fromFuture(futureTask)
    .doOnSubscribe(new Consumer < Disposable > () {//doOnSubscribe() 的作用就是只有订阅时才会发送事件
    @Override
    public void accept(Disposable disposable) throws Exception {
        futureTask.run();
    }
})
.subscribe(new Consumer < String > () {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, "------>  accept " + s);
    }
});
  1. fromIterable()
    直接发送一个 List 集合数据给观察者
public static  Observable fromIterable(Iterable source)

//----
List list = new ArrayList<>();
list.add(0);
list.add(1);
list.add(2);
list.add(3);
Observable.fromIterable(list)
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  onSubscribe");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  onComplete ");
    }
});
  1. defer()
    这个方法的作用就是直到被观察者被订阅后才会创建被观察者。
public static  Observable defer(Callable> supplier)

//----

// i 要定义为成员变量
Integer i = 100;
        
Observable observable = Observable.defer(new Callable>() {
    @Override
    public ObservableSource call() throws Exception {
        return Observable.just(i);
    }
});

i = 200;

Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
};

observable.subscribe(observer);

i = 300; //最后返回这个值

observable.subscribe(observer);
  1. timer()
    当到指定时间后就会发送一个 0L 的值给观察者。
public static Observable timer(long delay, TimeUnit unit) 
......

//----
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer < Long > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Long aLong) {
        Log.d(TAG, "------>  onNext " + aLong);// 输出0 只执行一次
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. interval()
    每隔一段时间就会发送一个事件，这个事件是从0开始，不断增1的数字。
public static Observable interval(long period, TimeUnit unit)
public static Observable interval(long initialDelay, long period, TimeUnit unit)
......

//----
Observable.interval(4, TimeUnit.SECONDS)
.subscribe(new Observer < Long > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------> =onSubscribe ");
    }

    @Override
    public void onNext(Long aLong) {
        Log.d(TAG, "------> =onNext " + aLong);// 间隔多长时间  多次执行
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. intervalRange()
    可以指定发送事件的开始值和数量，其他与 interval() 的功能一样
public static Observable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
public static Observable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

//----
Observable.intervalRange(2, 5, 2, 1, TimeUnit.SECONDS)
.subscribe(new Observer < Long > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------> =onSubscribe ");
    }

    @Override
    public void onNext(Long aLong) {
        Log.d(TAG, "------> =onNext " + aLong); 
        // 结果 2,3,4,5,6 (2开始,5次)
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. range()
    同时发送一定范围的事件序列。
public static Observable rangeLong(long start, long count)

//----
Observable.range(2, 5)
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------> =onSubscribe ");
    }

    @Override
    public void onNext(Integer aLong) {
        Log.d(TAG, "------> =onNext " + aLong);// 23456
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. rangeLong()
    作用与 range() 一样，只是数据类型为 Long
public static Observable rangeLong(long start, long count)
  1. empty() & never() & error()
    • empty() ： 直接发送 onComplete() 事件
    • never()：不发送任何事件
    • error()：发送 onError() 事件
Observable.empty()
.subscribe(new Observer < Object > () {

    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe");
    }

    @Override
    public void onNext(Object o) {
        Log.d(TAG, "------>  =onNext");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError " + e);
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete");
    }
});  

//----
empty() -->  ------>  =onSubscribe ------>  =onComplete
never() -->  ------>  =onSubscribe
error() -->   ------>  =onSubscribe ------>  =onError java.lang.NullPointerException

转换

  1. map()
    map可以将被观察者发送的数据类型转变成其他的类型
public final  Observable map(Function mapper)

//-----
Observable.just(1, 2, 3)
.map(new Function < Integer, String > () {
    @Override
    public String apply(Integer integer) throws Exception {
        return "I'm " + integer;
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "------>   onSubscribe");
    }

    @Override
    public void onNext(String s) {
        Log.e(TAG, "------>   onNext " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. flatMap()
    这个方法可以将事件序列中的元素进行整合加工，返回一个新的被观察者。
    flatMap() 其实与 map() 类似，但是 flatMap() 返回的是一个 Observerable。现在用一个例子来说明 flatMap() 的用法。
public final  Observable flatMap(Function> mapper)
......

//----
Observable.fromIterable(personList)
.flatMap(new Function < Person, ObservableSource < Plan >> () {
    @Override
    public ObservableSource < Plan > apply(Person person) {
        return Observable.fromIterable(person.getPlanList());
    }
})
.flatMap(new Function < Plan, ObservableSource < String >> () {
    @Override
    public ObservableSource < String > apply(Plan plan) throws Exception {
        return Observable.fromIterable(plan.getActionList());
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "------>  =action: " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
  1. concatMap()
    concatMap() 和 flatMap() 基本上是一样的，只不过 concatMap() 转发出来的事件是有序的，而 flatMap() 是无序的。
public final  Observable concatMap(Function> mapper)
public final  Observable concatMap(Function> mapper, int prefetch)

//-----
// ^^^^^  flatMap()
  1. buffer()
    从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。
public final Observable> buffer(int count, int skip)
......

//-----
//buffer 有两个参数，一个是 count，另一个 skip。count 缓冲区元素的数量，skip 就代表缓冲区满了之后，发送下一次事件序列的时候要跳过多少元素。
Observable.just(1, 2, 3, 4, 5)
.buffer(2, 1)
.subscribe(new Observer < List < Integer >> () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(List < Integer > integers) {
        Log.d(TAG, "------>  缓冲区大小： " + integers.size());
        for (Integer i: integers) {
            Log.d(TAG, "------>  元素： " + i);
        }
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

//----结果
// 从结果可以看出，每次发送事件，指针都会往后移动一个元素再取值，直到指针移动到没有元素的时候就会停止取值。
05-21 14:09:34.015 22421-22421/com.example.rxjavademo D/chan: ------>  缓冲区大小： 2
------>  元素： 1
------>  元素： 2
------>  缓冲区大小： 2
------>  元素： 2
------>  元素： 3
------>  缓冲区大小： 2
------>  元素： 3
------>  元素： 4
------>  缓冲区大小： 2
------>  元素： 4
------>  元素： 5
------>  缓冲区大小： 1
------>  元素： 5
  1. groupBy()
    将发送的数据进行分组，每个分组都会返回一个被观察者。
public final  Observable> groupBy(Function keySelector)

//-------
Observable.just(5, 2, 3, 4, 1, 6, 8, 9, 7, 10)
.groupBy(new Function < Integer, Integer > () {
    @Override
    public Integer apply(Integer integer) throws Exception {
        return integer % 3;
    }
})
.subscribe(new Observer < GroupedObservable < Integer, Integer >> () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>   onSubscribe ");
    }

    @Override
    public void onNext(GroupedObservable < Integer, Integer > integerIntegerGroupedObservable) {
        Log.d(TAG, "------>   onNext ");
        integerIntegerGroupedObservable.subscribe(new Observer < Integer > () {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "------>   GroupedObservable onSubscribe ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "------>   GroupedObservable onNext  groupName: " + integerIntegerGroupedObservable.getKey() + " value: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "------>   GroupedObservable onError ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "------>   GroupedObservable onComplete ");
            }
        });
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>   onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>   onComplete ");
    }
});

//----结果---
05-26 14:38:02.062 21451-21451/com.example.rxjavademo D/chan: ------>   onSubscribe 
05-26 14:38:02.063 21451-21451/com.example.rxjavademo D/chan: ------>   onNext 
------>   GroupedObservable onSubscribe     ------>   GroupedObservable onNext  groupName: 2 value: 5
------>   GroupedObservable onNext  groupName: 2 value: 2
------>   onNext 
------>   GroupedObservable onSubscribe 
------>   GroupedObservable onNext  groupName: 0 value: 3
05-26 14:38:02.064 21451-21451/com.example.rxjavademo D/chan: ------>   onNext 
------>   GroupedObservable onSubscribe 
------>   GroupedObservable onNext  groupName: 1 value: 4
------>   GroupedObservable onNext  groupName: 1 value: 1
------>   GroupedObservable onNext  groupName: 0 value: 6
------>   GroupedObservable onNext  groupName: 2 value: 8
------>   GroupedObservable onNext  groupName: 0 value: 9
------>   GroupedObservable onNext  groupName: 1 value: 7
------>   GroupedObservable onNext  groupName: 1 value: 10
05-26 14:38:02.065 21451-21451/com.example.rxjavademo D/chan: ------>   GroupedObservable onComplete 
------>   GroupedObservable onComplete 
------>   GroupedObservable onComplete 
------>   onComplete
  1. scan()
    将数据以一定的逻辑聚合起来。
public final Observable scan(BiFunction accumulator)

//-------

Observable.just(1, 2, 3, 4, 5)
.scan(new BiFunction < Integer, Integer, Integer > () {
    @Override
    public Integer apply(Integer integer, Integer integer2) throws Exception {
        Log.d(TAG, "------>   apply ");
        Log.d(TAG, "------>   integer " + integer);
        Log.d(TAG, "------>   integer2 " + integer2);
        return integer + integer2;
    }
})
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "------>   accept " + integer);
    }
});
  1. window()
    发送指定数量的事件时，就将这些事件分为一组。window 中的 count 的参数就是代表指定的数量，例如将 count 指定为2，那么每发2个数据就会将这2个数据分成一组。
public final Observable> window(long count)
......

//-------
//有几组   就会走几个 onComplete()

组合操作符

  1. concat()
    可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat() 最多只可以发送4个事件。
public static  Observable concat(ObservableSource source1, ObservableSource source2, ObservableSource source3, ObservableSource source4)
......
  1. concatArray()
    与 concat() 作用一样，不过 concatArray() 可以发送多于 4 个被观察者。
public static  Observable concatArray(ObservableSource... sources)
  1. merge()
    这个方法月 concat() 作用基本一样，知识 concat() 是串行发送事件，而 merge() 并行发送事件。
    我的理解是 concat()一个完了走另个, 而merge()是好朋友一起走 数据乱了.
 public static  Observable merge(ObservableSource source1, ObservableSource source2, ObservableSource source3, ObservableSource source4)
......
  1. concatArrayDelayError() & mergeArrayDelayError()
    在 concatArray() 和 mergeArray() 两个方法当中，如果其中有一个被观察者发送了一个 Error 事件，那么就会停止发送事件，如果你想 onError() 事件延迟到所有被观察者都发送完事件后再执行的话，就可以使用 concatArrayDelayError() 和 mergeArrayDelayError()
public static  Observable concatArrayDelayError(ObservableSource... sources)
public static  Observable mergeArrayDelayError(ObservableSource... sources)
  1. zip()
    会将多个被观察者合并，根据各个被观察者发送事件的顺序一个个结合起来，最终发送的事件数量会与源 Observable 中最少事件的数量一样。
public static  Observable zip(ObservableSource source1, ObservableSource source2, BiFunction zipper)
......
  1. combineLatest() & combineLatestDelayError()
    combineLatest() 的作用与 zip() 类似，但是 combineLatest() 发送事件的序列是与发送的时间线有关的，当 combineLatest() 中所有的 Observable 都发送了事件，只要其中有一个 Observable 发送事件，这个事件就会和其他 Observable 最近发送的事件结合起来发送，这样可能还是比较抽象
public static  Observable combineLatest(ObservableSource source1, ObservableSource source2, BiFunction combiner)
.......
  1. reduce()
    与 scan() 操作符的作用也是将发送数据以一定逻辑聚合起来，这两个的区别在于 scan() 每处理一次数据就会将事件发送给观察者，而 reduce() 会将所有数据聚合在一起才会发送事件给观察者。
public final Maybe reduce(BiFunction reducer)
  1. collect()
    将数据收集到数据结构当中。
public final  Single collect(Callable initialValueSupplier, BiConsumer collector)

//-----
Observable.just(1, 2, 3, 4)
.collect(new Callable < ArrayList < Integer >> () {
    @Override
    public ArrayList < Integer > call() throws Exception {
        return new ArrayList < > ();
    }
},
new BiConsumer < ArrayList < Integer > , Integer > () {
    @Override
    public void accept(ArrayList < Integer > integers, Integer integer) throws Exception {
        integers.add(integer);
    }
})
.subscribe(new Consumer < ArrayList < Integer >> () {
    @Override
    public void accept(ArrayList < Integer > integers) throws Exception {
        Log.d(TAG, "------>  accept " + integers);  [1,2,3,4]
    }
});
  1. startWith() & startWithArray()
    在发送事件之前追加事件，startWith() 追加一个事件，startWithArray() 可以追加多个事件。追加的事件会先发出。
public final Observable startWith(T item)
public final Observable startWithArray(T... items)

//----

Observable.just(5, 6, 7)
.startWithArray(2, 3, 4)
.startWith(1)
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "------>  accept " + integer); //分别打出 1,2,3,4,5,6,7
    }
});
  1. count()
    返回被观察者发送事件的数量。
public final Single count()  

//-----
Observable.just(1, 2, 3)
.count()
.subscribe(new Consumer < Long > () {
    @Override
    public void accept(Long aLong) throws Exception {
        Log.d(TAG, "------>    aLong " + aLong);  // 3
    }
});

功能操作符

  1. delay()
    延迟一段事件发送事件。
public final Observable delay(long delay, TimeUnit unit)

// onSubscribe 不会延时  Next() 会
  1. doOnEach()
    Observable 每发送一件事件之前都会先回调这个方法。并且可以取出 onNext() 发送的值。不仅仅是onNext();
public final Observable doOnEach(final Consumer> onNotification)
  1. doOnNext()
    Observable 每发送 onNext() 之前都会先回调这个方法。
public final Observable doOnNext(Consumer onNext)
  1. doAfterNext()
    Observable 每发送 onNext() 之后都会回调这个方法。
public final Observable doAfterNext(Consumer onAfterNext)
  1. doOnComplete()
    Observable 每发送 onComplete() 之前都会回调这个方法。
public final Observable doOnComplete(Action onComplete)
  1. doOnError()
    Observable 每发送 onError() 之前都会回调这个方法。
public final Observable doOnError(Consumer onError)
  1. doOnSubscribe()
    Observable 每发送 onSubscribe() 之前都会回调这个方法。
public final Observable doOnSubscribe(Consumer onSubscribe)
  1. doOnDispose()
    当调用 Disposable 的 dispose() 之后回调该方法。
public final Observable doOnDispose(Action onDispose)

/*
* 疑问  --> Disposable 是个啥?
*/
  1. doOnLifecycle()
    在回调 onSubscribe 之前回调该方法的第一个参数的回调方法，可以使用该回调方法决定是否取消订阅。
public final Observable doOnLifecycle(final Consumer onSubscribe, final Action onDispose)

/*
 * 不懂 ~ ~ 
*/
  1. doOnTerminate() & doAfterTerminate()
    doOnTerminate 是在 onError 或者 onComplete 发送之前回调，而 doAfterTerminate 则是 onError 或者 onComplete 发送之后回调。
public final Observable doOnTerminate(final Action onTerminate)
public final Observable doAfterTerminate(Action onFinally)
  1. doFinally()
    在所有事件发送完毕之后回调该方法。
    这里可能你会有个问题，那就是 doFinally() 和 doAfterTerminate() 到底有什么区别？区别就是在于取消订阅，如果取消订阅之后 doAfterTerminate() 就不会被回调，而 doFinally() 无论怎么样都会被回调，且都会在事件序列的最后。
public final Observable doFinally(Action onFinally)
  1. onErrorReturn()
    当接受到一个 onError() 事件之后回调，返回的值会回调 onNext() 方法，并正常结束该事件序列。
public final Observable onErrorReturn(Function valueSupplier)


//----
Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onError(new NullPointerException());
    }
})
.onErrorReturn(new Function() {
    @Override
    public Integer apply(Throwable throwable) throws Exception {
        Log.d(TAG, "------>  =onErrorReturn " + throwable);
        return 404;
    }
})
.subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe ");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  =onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete ");
    }
});

//----
05-23 18:35:18.175 19239-19239/? D/chan: ------>  =onSubscribe 
------>  =onNext 1
------>  =onNext 2
------>  =onNext 3
------>  =onErrorReturn java.lang.NullPointerException
------>  =onNext 404
------>  =onComplete
  1. onErrorResumeNext()
    当接收到 onError() 事件时，返回一个新的 Observable，并正常结束事件序列。
public final Observable onErrorResumeNext(Function> resumeFunction)

//----
Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onError(new NullPointerException());
    }
})
.onErrorResumeNext(new Function>() {
    @Override
    public ObservableSource apply(Throwable throwable) throws Exception {
        Log.d(TAG, "------>  =onErrorResumeNext " + throwable);
        return Observable.just(4, 5, 6);
    }
})
.subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe ");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  =onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete ");
    }
});

//-----
05-23 18:43:10.910 26469-26469/? D/chan: ------>  =onSubscribe 
------>  =onNext 1
------>  =onNext 2
------>  =onNext 3
------>  =onErrorResumeNext java.lang.NullPointerException
------>  =onNext 4
------>  =onNext 5
------>  =onNext 6
------>  =onComplete
  1. onExceptionResumeNext()
    与 onErrorResumeNext() 作用基本一致，但是这个方法只能捕捉 Exception。
public final Observable onExceptionResumeNext(final ObservableSource next)
  1. retry()
    如果出现错误事件，则会重新发送所有事件序列。times 是代表重新发的次数。
public final Observable retry(long times)  

//----
Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onError(new Exception("404"));
    }
})
.retry(2)
.subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe ");
    }

    @Override
    public void onNext(Integer integer) {
        Log.d(TAG, "------>  =onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete ");
    }
});

05-23 22:46:18.537 22239-22239/com.example.louder.rxjavademo D/chan: ------>  =onSubscribe 
05-23 22:46:18.538 22239-22239/com.example.louder.rxjavademo D/chan: ------>  =onNext 1
------>  =onNext 2
------>  =onNext 3
------>  =onNext 1
------>  =onNext 2
------>  =onNext 3
------>  =onNext 1
------>  =onNext 2
------>  =onNext 3
------>  =onError
  1. retryUntil()
    出现错误事件之后，可以通过此方法判断是否继续发送事件。
public final Observable retryUntil(final BooleanSupplier stop)
  1. retryWhen()
    当被观察者接收到异常或者错误事件时会回调该方法，这个方法会返回一个新的被观察者。如果返回的被观察者发送 Error 事件则之前的被观察者不会继续发送事件，如果发送正常事件则之前的被观察者会继续不断重试发送事件。
Observable.create(new ObservableOnSubscribe < String > () {
    @Override
    public void subscribe(ObservableEmitter < String > e) throws Exception {
        e.onNext("chan");
        e.onNext("ze");
        e.onNext("de");
        e.onError(new Exception("404"));
        e.onNext("haha");
    }
})
.retryWhen(new Function < Observable < Throwable > , ObservableSource > () {
    @Override
    public ObservableSource  apply(Observable < Throwable > throwableObservable) throws Exception {
        return throwableObservable.flatMap(new Function < Throwable, ObservableSource > () {
            @Override
            public ObservableSource  apply(Throwable throwable) throws Exception {
                if(!throwable.toString().equals("java.lang.Exception: 404")) {
                    return Observable.just("可以忽略的异常");
                } else {
                    return Observable.error(new Throwable("终止啦"));
                }
            }
        });
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe ");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "------>  =onNext " + s);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError " + e.toString());
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete ");
    }
});

//---- 
05-24 09:13:25.622 28372-28372/com.example.rxjavademo D/chan: ------>  =onSubscribe 
05-24 09:13:25.623 28372-28372/com.example.rxjavademo D/chan: ------>  =onNext chan
------>  =onNext ze
------>  =onNext de
05-24 09:13:25.624 28372-28372/com.example.rxjavademo D/chan: ------>  =onError java.lang.Throwable: 终止啦


//----
//将 onError(new Exception("404")) 改为 onError(new Exception("303")) 看看打印结果：
------>  =onNext chan
05-24 09:54:08.653 29694-29694/? D/chan: ------>  =onNext ze
------>  =onNext de
------>  =onNext chan
------>  =onNext ze
------>  =onNext de
------>  =onNext chan
------>  =onNext ze
------>  =onNext de
------>  =onNext chan
------>  =onNext ze
------>  =onNext de
------>  =onNext chan
------>  =onNext ze
------>  =onNext de
------>  =onNext chan
......
  1. repeat()
    重复发送被观察者的事件，times 为发送次数。
public final Observable repeat(long times)

// 重复 一遍 onNext();
// onSubscribe()-> ...next...onComplete()
  1. repeatWhen()
    这个方法可以会返回一个新的被观察者设定一定逻辑来决定是否重复发送事件。
public final Observable repeatWhen(final Function, ? extends ObservableSource> handler)

//这里分三种情况，如果新的被观察者返回 onComplete 或者 onError 事件，则旧的被观察者不会继续发送事件。如果被观察者返回其他事件，则会重复发送事件。
  1. subscribeOn()
    指定被观察者的线程，要注意的时，如果多次调用此方法，只有第一次有效。
public final Observable subscribeOn(Scheduler scheduler)
  1. observeOn()
    指定观察者的线程，每指定一次就会生效一次。
public final Observable observeOn(Scheduler scheduler)

Schedulers.computation( )
用于使用计算任务，如事件循环和回调处理
Schedulers.immediate( )
当前线程
Schedulers.io( )
用于 IO 密集型任务，如果异步阻塞 IO 操作。
Schedulers.newThread( )
创建一个新的线程
AndroidSchedulers.mainThread()
Android 的 UI 线程，用于操作 UI。

过滤操作符

  1. filter()
    通过一定逻辑来过滤被观察者发送的事件，如果返回 true 则会发送事件，否则不会发送。
public final Observable filter(Predicate predicate)


//----
 Observable.just(1, 2, 3)
    .filter(new Predicate < Integer > () {
        @Override
        public boolean test(Integer integer) throws Exception {
            return integer < 2;
        }
})
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "------>  =onSubscribe ");
    }

    @Override
    public void onNext(Integer integer) {
        i += integer;
        Log.d(TAG, "------>  =onNext " + integer);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "------>  =onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "------>  =onComplete ");
    }
});


//-----
05-24 22:57:32.562 12776-12776/com.example.louder.rxjavademo D/chan: ------>  =onSubscribe 
------>  =onNext 1
------>  =onComplete
  1. ofType()
    可以过滤不符合该类型事件
public final  Observable ofType(final Class clazz)

//---
Observable.just(1, 2, 3, "chan", "zhide")
.ofType(Integer.class)
.subscribe(new Observer < Integer > () {
  1. skip()
    跳过正序某些事件，count 代表跳过事件的数量
public final Observable skip(long count)

//---
Observable.just(1, 2, 3)
.skip(2)
.subscribe(new Observer < Integer > () {

//最后结果只有3
  1. distinct()
    过滤事件序列中的重复事件。
public final Observable distinct() 

//---
Observable.just(1, 2, 3, 3, 2, 1)
.distinct()
.subscribe(new Observer < Integer > () {
  1. distinctUntilChanged()
    过滤掉连续重复的事件
public final Observable distinctUntilChanged()

//----
Observable.just(1, 2, 3, 3, 2, 1)
.distinctUntilChanged()
.subscribe(new Observer < Integer > () {
//--> 12321
  1. take()
    控制观察者接收的事件的数量。
public final Observable take(long count)

//---
Observable.just(1, 2, 3, 4, 5)
.take(3)
.subscribe(new Observer < Integer > () {
//-> 123
  1. debounce()
    如果两件事件发送的时间间隔小于设定的时间间隔则前一件事件就不会发送给观察者。
    throttleWithTimeout() 与此方法的作用一样，这里就不再赘述了。
public final Observable debounce(long timeout, TimeUnit unit)
//-> 是前一事件
  1. firstElement() && lastElement()
    firstElement() 取事件序列的第一个元素，lastElement() 取事件序列的最后一个元素。
public final Maybe firstElement()
public final Maybe lastElement()
  1. elementAt() & elementAtOrError()
    elementAt() 可以指定取出事件序列中事件，但是输入的 index 超出事件序列的总数的话就不会出现任何结果。这种情况下，你想发出异常信息的话就用 elementAtOrError() 。 --> elementAtOrError 会抛出异常 !!!!!!
public final Maybe elementAt(long index)
public final Single elementAtOrError(long index)

条件操作符

  1. all()
    判断事件序列是否全部满足某个事件，如果都满足则返回 true，反之则返回 false。
public final Observable ambWith(ObservableSource other)

//---
Observable.just(1, 2, 3, 4)
.all(new Predicate < Integer > () {
    @Override
    public boolean test(Integer integer) throws Exception {
        return integer < 5;
    }
})
.subscribe(new Consumer < Boolean > () {

//-->   true
  1. takeWhile()
    可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送。
public final Observable takeWhile(Predicate predicate)

//----
Observable.just(1, 2, 3, 4)
.takeWhile(new Predicate < Integer > () {
    @Override
    public boolean test(Integer integer) throws Exception {
        return integer < 3;
    }
})
.subscribe(new Consumer < Integer > () {

// -> 1,2
  1. skipWhile()
    可以设置条件，当某个数据满足条件时不发送该数据，反之则发送。
public final Observable skipWhile(Predicate predicate)

// 上面的例子  -> 3,4
  1. takeUntil()
    可以设置条件，当事件满足此条件时，下一次的事件就不会被发送了。
Observable.just(1, 2, 3, 4, 5, 6)
.takeUntil(new Predicate < Integer > () {
    @Override
    public boolean test(Integer integer) throws Exception {
        return integer > 3;
    }
})
.subscribe(new Consumer < Integer > () {

// -> 1234
// 注意是下一次事件 !!!
  1. skipUntil()
    当 skipUntil() 中的 Observable 发送事件了，原来的 Observable 才会发送事件给观察者。
public final  Observable skipUntil(ObservableSource other)

//---
Observable.intervalRange(1, 5, 0, 1, TimeUnit.SECONDS)
.skipUntil(Observable.intervalRange(6, 5, 3, 1, TimeUnit.SECONDS))
.subscribe(new Observer < Long > () {
  1. sequenceEqual()
    判断两个 Observable 发送的事件是否相同。
public static  Single sequenceEqual(ObservableSource source1, ObservableSource source2)

//---
Observable.sequenceEqual(Observable.just(1, 2, 3),
Observable.just(1, 2, 3))
.subscribe(new Consumer < Boolean > () {

// -> true
  1. contains()
    判断事件序列中是否含有某个元素，如果有则返回 true，如果没有则返回 false。
public final Single contains(final Object element)

// -----
Observable.just(1, 2, 3)
.contains(3)
.subscribe(new Consumer < Boolean > () {

// -> true
  1. isEmpty()
    判断事件序列是否为空。
public final Single isEmpty()
  1. amb()
    amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的事件，其余 Observable 将会被丢弃。
public static  Observable amb(Iterable> sources)
  1. defaultIfEmpty()
    如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值。
public final Observable defaultIfEmpty(T defaultItem)

//---
Observable.create(new ObservableOnSubscribe < Integer > () {

    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onComplete();
    }
})
.defaultIfEmpty(666)
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "------> onNext " + integer);
    }
});

//---> onNext 666

Document

你可能感兴趣的:(RxJava 便查手册)

  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 活给自己看，笑容才灿烂 听着了么
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 2019-10-24 柒月的可可
    今日上班无事，人又懒怠动，不知道如何打发这个下午，终于打开了。我大概是把当日记来写的。重庆的天气骤然凉了。早上出门的时候，满地都是落叶，脚踩上去，却是刚下过雨，叶子已润掉，走不出声响。白天在办公室不见天日，对温度也无甚感觉，晚上一个人回到家，屋子里窗户都开着，被冷风吹了一天，一迈进屋，便觉冷气森然。将近二十度的天气，竟要裹着毯子才觉温暖。再过一周，就到十一月。扛过十一月，就可以开暖气了。然而我真的
  • 第一四三章：天降奇兵 逸川
    “是她！”为了护住公孙枝，季姜（姜姓吕氏女，名子芸）舍身朝着刺来的长戟迎了过去。待公孙枝反应过来，长戟的尖刃已经抵到了季姜的胸前，让他只感手足无措。然就在这千钧一发之际，有一支羽箭突然从山巅飞来直插入狄兵脖颈，将其连人带戟射倒在地。顺着羽箭飞来的方向望去，却见到一名头戴白色纱笠的女子，正站在山脊上左右开弓。每有羽箭射出，便立时有狄兵应声而倒，端是飒爽无比：“竟不知她技艺如此娴熟！”“她是谁？”听到
  • 三梦 | 心碎了还是醉了 培根不是肉
    今天，让我一起走进彝族火把节。图片发自App“中国彝族火把节之乡·2016布拖民间火把节”在离学校走约一个时辰路程的地方举行，奔着要在如此隆重的节日之中好好欣赏一番的目的，三梦团队一早便和随队的两个孩子整装待发。图片发自App第一部分:吉尔吉呷我万万没有想到，从踏出校门开始，从我牵上那个孩子的手开始，我心的触动就没有停过。图片发自App我以为我这一路会在观察、拍照和思考中度过，但我发现我错了。这个
  • 但行好事，莫问前程 浅草拾光
    鸿星尔克被冲上了热搜，他可能做梦也没有想到自己的一个善举便迎来了他的春天。在这次河南救灾中很多明星企业都纷纷捐款，而一个快被人遗忘的品牌掏出了自己的家底。在自己年利润是亏损2.28亿的时候还大方的捐了五千万物资。热心的网友纷纷留言，大家都跑去直播间支持国货，去实体店买鞋子。以至于订单爆满，仓库清空。老板劝大家理性消费，大家反而更冲动。就是这样一种热情，这样一种情怀，感动了平凡的你我。大家都说华夏儿
  • 2021-09-13一切向好发展 昀妡
    今天，一位学员在群里发了一条求助信息。问题是：一个学生小男孩3年级了，学习态度不端正不认真，也不和老师家长沟通，怎么办？我正好看到了这条消息，便加了她的微信。我问她是否方便电话沟通。在征求学员的同意后，我和她电话沟通了10分钟，给了她一些建议。通过这件事，我看到了自己积极主动的一面。之前，我总说自己消极被动，但其实，问题的根源在于目标不清晰。如果知道方向，还是会突破心理障碍往前走。比如，陌生感召。
  • 山海师秘录（草稿小段） 白淼清流
    “阿弱，山北头还有两树好梨！我们给你留着呢，你快去采了吧，我们玩会儿就回家了。”几个伙伴都望着宁虚，其中一个胖胖喊道。宁虚望过去：“知道啦！你们趁着路好走，赶紧回家吧，这天一会儿怕是要下雨！”说罢，宁虚紧了紧后背的竹筐，迈步向山上走去。今天是村里采梨的最后一天，最多倒晚饭时，剩下的梨子便不许村民再采摘，熟透了便掉到地上，当做下次结果的肥料。宁虚顺着工匠铺出的简陋石道，却没有去同伴所说的山北头，而是
  • 这段婚姻还有必要持继续下去吗？ 2020从这里开始
    今夜辗转难眠，脑海一直在思考以后的路怎么走，是继续，还是结束？“七年之痒”对我的婚姻也真的是如期而至。七年前的前天领的结婚证，七年后的今晚我们却在沟通如何修补我们的婚姻，当初结婚与他于我都是因为大龄青年，在家里父母催促下，当时双方相处也觉得合适。在认识恋爱半年后便匆匆结婚，因为我彼此性格都属于不善表达，也不喜好争吵，因此日常生活琐事的不满基本都几语带过，原以为平淡生活都是这么过的。未曾想这些怨愤都
  • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 errorreactmongodb数据库
    背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
  • iPhone怎么删除重复照片，可以尝试这几种方法 2401_85240355 iphoneios
    在数字化时代，智能手机尤其是iPhone成为我们日常生活中不可或缺的一部分。随着我们不断使用iPhone拍照，重复照片的积累逐渐成为一个普遍问题。这不仅占用了大量的存储空间，也使得照片库变得杂乱无章。本文将介绍几种有效的iPhone怎么删除重复照片方法，并介绍如何利用CleanMyPhone来简化这一过程。iPhone怎么删除重复照片方法一：人工筛查人工筛查是最直接的方法，尽管它可能比较耗时。这种
  • 记录幸福（三月） 杨芸
    3月6日中午，匆匆忙忙与老爸和三妹在高铁站候车厅见了一面，两个南瓜包传递了亲人间的爱，那一刻好幸福好满足。他们进站后，我带着离别的忧伤，走到出口，突然想起朵儿喜欢吃的奥尔良鸡腿煲，便折回去，买了她和我，还有朵爸各自喜爱的。以前和亲人每次分开，都要难过许久，那天我竟然突然明白了一个道理，正因为爱家人，所以要让自己过的更开心更舒适，才能长寿，有更多的时间去爱他们。而不是忧心忡忡的过日子哦。最爱的家人回
  • 【学生作品】写给未来孩子的一封信（徐奥） 简思莼
    1、人皆养子望聪明，无灾无难到公卿——写给未来孩子的一封信文/徐奥亲爱的孩子:你好啊！我是你过去的母亲，和你一样，现在的我也是一个孩子，这是我给你写的第一封信。未来的你如果是个天真可爱的小公主，我便化身为王子。宠爱你，但不是溺爱；呵护你，但不是纵容。我会坐在书桌前，陪你一起读书写字，一起学习，一起散步。我会在街上给你挑选衣服，把你打扮成漂亮的洋娃娃。我不会压制你的天赋，我会让你选择自己的兴趣爱好。
  • 久梦忽醒惊回头 山雾生
    一直以来，我都觉得这人生的二十个年头，其实只是一场梦，像是午睡过久，陷入梦魇，怎么也挣扎不出，偶尔迷茫惊醒，却也起不得身，只是空洞的发愣，而后复又辗转入梦。有些时候，觉得自己似乎醒了，可看了看陌生的环境，陌生的人，又觉得，睡得过久，世事变迁，已经回不去入睡之时。我好像是在某一天，突然就觉得人生没了意义，便昏昏沉沉入了这个梦，看不明白哪里是梦中，哪里是现实，或许偶尔是清醒的，可更多时候是沉睡的，我知
  • 2022-07-06学会放手 杨晓玲乐平市第十一小学
    2022年7月5日星期一晴今天结束了国培培训，上午收拾好物品，带着孩子整理心情，带着憧憬去到孩子新的学校，因为从小我有意培养孩子自己整理自己内务，孩子很认真的把自己要用的都整理好，不用的都另外装好，这一点孩子的能力还是挺强的。把自己的行李按学校提出的要求认真的整理好，我们便出发了。我们早早的来到学校，时间还早，便让她到阿姨那休息了一会儿，每去到一个新的地方，能迅速的安顿下来，这是非常好的。时间很快
  • 自动写论文的网站推荐这5款实用类工具 小猪包333 写论文人工智能深度学习计算机视觉AI写作
    在当今学术研究和写作领域，AI论文写作工具的出现极大地提高了写作效率和质量。这些工具不仅能够帮助研究人员快速生成论文草稿，还能进行内容优化、查重和排版等操作。以下是五款实用类工具推荐，特别是千笔-AIPassPaper。1.千笔-AIPassPaper千笔-AIPassPaper是一款功能强大且全面的AI论文写作助手，用户只需输入基本的研究需求和关键词，便能迅速生成一篇完整的论文。该工具利用先进的
  • 推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！ 小猪包333 写论文人工智能AI写作深度学习计算机视觉
    在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
  • AI论文写作推荐哪个好？分享5款AI论文写作带数据图表网站 小猪包333 写论文人工智能深度学习计算机视觉
    在当今学术研究和写作领域，AI论文写作工具的出现极大地提高了写作效率和质量。这些工具不仅能够帮助研究人员快速生成论文草稿，还能进行内容优化、查重和排版等操作。以下是五款推荐的AI论文写作工具，包括千笔-AIPassPaper。千笔-AIPassPaper千笔-AIPassPaper是一款功能强大的AI论文写作助手，旨在帮助用户快速生成高质量的论文内容。AI论文，免费大纲，10分钟3万字https:
  • 读《红楼梦》第十九回 情切切良宵花解语 意绵绵静日玉生香 梦一场_c315
    元春回宫，贾府上下又忙碌了二三日，方收拾停当，个个是累得人仰马翻。王熙凤为了不落人口舌也只能硬撑着，凡事冲在前头。袭人的母亲来面见贾母，将袭人接回去吃年饭，晚上才会回来，宝玉甚觉无聊。宁府这边唱戏，贾珍来邀宝玉过府观赏，刚欲出门，元春赐了糖蒸酥酪来，宝玉想着平日里袭人最爱吃，便留给袭人，自己出门看戏去了。到了宁府，只闻锣鼓喧天，热闹非凡，宝玉稍坐了片刻，忽想起一间小书房里挂着一张美人图，今日府上这
  • 毕业论文附录一般都写什么?大学生写论文是干嘛用的 写个原创论文 人工智能深度学习AI写作chatgpt论文阅读
    毕业论文的附录通常包含一些在正文中不便于展示或详细阐述的内容，但对理解论文整体又具有重要意义的资料。具体来说，附录可能包含以下内容：AI论文，免费大纲，10分钟3万字，查重高于15%退费，支持数据图表！！AIPaperPass-AI论文写作指导平台AIPaperPass是AI原创论文写作平台，免费千字大纲，5分钟生成3万字初稿，提供答辩汇报ppt、开题报告、任务书等，40篇真实中英文知网参考文献，
  • 日念一好（27）2022-1-7 思辰1218
    1、感恩科室欧阳同志，小冰箱出故障，设备科解决不了的问题，他三下五除二便解决了，节省时间与科室开支，工作上有如此伙伴，真是舒心！2、感恩小姐妹的惦念，出差祁东，发现好吃的马蹄，立马告知给我捎了些，瞬间涌上一股暖流。3、感恩全姐，送来一大袋好吃的纸皮核桃，大家齐分享，被爱包围的感觉棒极了。4、感恩芳芳昨晚的线上陪伴，一番电话粥让我倍受滋养。
  • 有心栽花花不发，无心插枝枝发芽 幽默静好
    今年的倒春寒来势凶猛，仿佛一夜之间，开得热热闹闹的迎春花，便像是使完了力气，结束了一年一度的花期。小区里的园丁是勤劳的，将那些开败了的枝条进行精心修剪，我散步路过，看见堆在地上的不少，便随手捡了几枝。记不得曾经在哪里看过，说迎春花很好种植，只要捡略粗的枝条，随便插在花盆里，按时浇浇水就能成活。我也想试一试。回家找了个小花盆，将捡来的枝条剪成几小节，将盆插满。放在了阳台的一个角落里。说实话，我没太在
  • 3.增删改查--连接查询 问女何所忆
    关系型数据库的一个特点就是，多张表之间存在关系，以致于我们可以连接多张表进行查询操作，所以连接查询会是关系型数据库中最常见的操作。连接查询主要分为三种，交叉连接、内连接和外连接，我们一个个说。1、交叉连接交叉连接其实连接查询的第一个阶段，它简单表现为两张表的笛卡尔积形式，具体例子：如果你没学过数学中的笛卡尔积概念，你可以这样简单的理解这里的交叉连接：两张表的交叉连接就是一个连接合并的过程，T1表中
  • Regular Expression 正则表达式 Aimyon_36 DataDevelopment正则表达式redis数据库
    RegularExpression前言1.基本匹配2.元字符2.1点运算符.2.2字符集2.2.1否定字符集2.3重复次数2.3.1*号2.3.2+号2.3.3?号2.4{}号2.5(...)特征标群2.6|或运算符2.7转码特殊字符2.8锚点2.8.1^号2.8.2$号3.简写字符集4.零宽度断言（前后预查）4.1?=...正先行断言4.2?!...负先行断言4.3?Thefatcatsaton
  • 研究表明，中年人“失业”成为了趋势，关键原因有这4点 舒山有鹿
    01在职场中，一直存在这么一个定律——35岁中年失业定律。很多人都特别疑惑，35岁还未到中年期，为什么人们会把“中年”跟“失业”挂钩呢？有句话，说得很现实：“35岁之前辞职，叫跳槽；35岁之后辞职，叫失业。”一般来说，35岁失业和40岁失业的本质是差不多的。只要他们还未升到管理层，便被单位辞退，就证明他们只能“另谋出路”了。况且，随着环境的愈发复杂，行业问题的频频发生，线下商业的不景气，那中年人找
  • 以研发创新为驱动力，黄山谷捷助力新能源汽车产业高质量发展 L913197600 黄山谷捷制造科技
    在新能源汽车产业蓬勃发展的浪潮中，车规级功率半导体作为驱动电机控制系统的核心部件，其性能与稳定性直接关系到汽车的动力输出、能效转化及安全性能。在这一关键领域，黄山谷捷股份有限公司（以下简称“黄山谷捷”或“公司”）以卓越的研发实力、精湛的生产工艺和严格的质量控制体系，成为行业内的佼佼者，特别是在功率半导体散热基板领域，更是树立了新的标杆。自2012年成立以来，黄山谷捷便深谙“科技是第一生产力”的真谛
  • C/C++Win32编程基础详解视频下载 择善Zach 编程C++Win32
    课题视频：C/C++Win32编程基础详解 视频知识：win32窗口的创建                   windows事件机制 主讲：择善Uncle老师 学习交流群：386620625 验证码：625 --
  • Guava Cache使用笔记 bylijinnan javaguavacache
    1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常 我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。 实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 2.Guava
  • 解决ora-01652无法通过128（在temp表空间中） 0624chenhong oracle
    解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程 一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。 分析过程：    既然是temp表空间有问题，那当
  • Struct在jsp标签 不懂事的小屁孩 struct
    非UI标签介绍： 控制类标签： 1：程序流程控制标签   if   elseif    else <s:if test="isUsed"> <span class="label label-success">True</span> </
  • 按对象属性排序 换个号韩国红果果 JavaScript对象排序
    利用JavaScript进行对象排序，根据用户的年龄排序展示 <script> var bob={ name;bob, age:30 } var peter={ name;peter, age:30 } var amy={ name;amy, age:24 } var mike={ name;mike, age:29 } var john={
  • 大数据分析让个性化的客户体验不再遥远 蓝儿唯美 数据分析
    顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。 分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。 挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。 然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
  • java笔记4 a-john java
    操作符 1，使用java操作符       操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。       操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
  • 从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序 aijuans 嵌入式学习
        笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。     笔者因此写上自己的学习心得，希望能给和我一样转变
  • 在springmvc中解决FastJson循环引用的问题 asialee 循环引用fastjson
              我们先来看一个例子：           package com.elong.bms; import java.io.OutputStream; import java.util.HashMap; import java.util.Map; import co
  • ArrayAdapter和SimpleAdapter技术总结 百合不是茶 androidSimpleAdapterArrayAdapter高级组件基础
    ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果   ArrayAdapter;的数据可以是数组或者是队列        // 获得下拉框对象 AutoCompleteTextView textview = (AutoCompleteTextView) this
  • 九封信 bijian1013 人生励志
            有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。         2014，写给人
  • Linux下安装MySQL Web 管理工具phpMyAdmin sunjing PHPInstallphpMyAdmin
    PHP http://php.net/ phpMyAdmin http://www.phpmyadmin.net Error compiling PHP on CentOS x64   一、安装Apache 请参阅http://billben.iteye.com/admin/blogs/1985244   二、安装依赖包 sudo yum install gd
  • 分布式系统理论 bit1129 分布式
    FLP One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes,
  • ssh2整合(spring+struts2+hibernate)-附源码 白糖_ eclipsespringHibernatemysql项目管理
    最近抽空又整理了一套ssh2框架，主要使用的技术如下： spring做容器，管理了三层(dao,service,actioin)的对象 struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 hibernate与数据库交互 BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 MySql数据库   项目用eclipse
  • treetable bug记录 braveCS table
    // 插入子节点删除再插入时不能正常显示。修改： //不知改后有没有错，先做个备忘 Tree.prototype.removeNode = function(node) { // Recursively remove all descendants of +node+ this.unloadBranch(node); // Remove
  • 编程之美-电话号码对应英语单词 bylijinnan java算法编程之美
    import java.util.Arrays; public class NumberToWord { /** * 编程之美 电话号码对应英语单词 * 题目： * 手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ， * 要求对一段数字，输出其代表的所有可能的字母组合
  • jquery ajax读书笔记 chengxuyuancsdn jQuery ajax
    1、jsp页面 <%@ page language="java" import="java.util.*" pageEncoding="GBK"%> <% String path = request.getContextPath(); String basePath = request.getScheme()
  • JWFD工作流拓扑结构解析伪码描述算法 comsci 数据结构算法工作活动J#
      对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析   /*  流程图拓扑结构解析伪码描述算法         public java.util.ArrayList DFS(String graphid, String stepid, int j)
  • oracle I/O 从属进程 daizj oracle
    I/O 从属进程 　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
  • 高级排序:希尔排序 dieslrae 希尔排序
    public void shellSort(int[] array){ int limit = 1; int temp; int index; while(limit <= array.length/3){ limit = limit * 3 + 1;
  • 初二下学期难记忆单词 dcj3sjt126com englishword
    kitchen 厨房 cupboard 厨柜 salt 盐 sugar 糖 oil 油 fork 叉；餐叉 spoon 匙；调羹 chopsticks 筷子 cabbage 卷心菜；洋白菜 soup 汤 Italian 意大利的   Indian 印度的 workplace  工作场所 even 甚至；更 Italy 意大利 laugh 笑 m
  • Go语言使用MySQL数据库进行增删改查 dcj3sjt126com mysql
    目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: http://code.google.c...o-mysql-dri
  • git命令 shuizhaosi888 git
    ---------------设置全局用户名： git config --global user.name "HanShuliang" //设置用户名 git config --global user.email "[email protected]" //设置邮箱 ---------------查看环境配置 git config --li
  • qemu-kvm 网络 nat模式 (四) haoningabc kvmqemu
    qemu-ifup-NAT #!/bin/bash BRIDGE=virbr0 NETWORK=192.168.122.0 GATEWAY=192.168.122.1 NETMASK=255.255.255.0 DHCPRANGE=192.168.122.2,192.168.122.254 TFTPROOT= BOOTP= function check_bridge()
  • 不要让未来的你，讨厌现在的自己 jingjing0907 生活 奋斗 工作 梦想
     故事one 　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
  • 枚举类型详解 一路欢笑一路走 enum枚举详解enumsetenumMap
    枚举类型详解 一.Enum详解      1.1枚举类型的介绍   JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。      Demo:一个最简单的枚举类   public enum ColorType { RED
  • 第11章 动画效果（上） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Eclipse中jsp、js文件编辑时，卡死现象解决汇总 ljf_home eclipsejsp卡死js卡死
    使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下：   1、取消验证 windows–>perferences–>validation 把 除了manual 下面的全部点掉，build下只留 classpath dependency Valida
  • MySQL编程中的6个重要的实用技巧 tomcat_oracle mysql
    每一行命令都是用分号(;)作为结束 对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')");
  • zoj 3820 Building Fire Stations(二分+bfs) 阿尔萨斯 Build
    题目链接：zoj 3820 Building Fire Stations 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点最多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他