RXjava创建函数

最新推荐文章于 2024-07-09 10:51:40 发布

红豆和绿豆

最新推荐文章于 2024-07-09 10:51:40 发布

阅读量172

点赞数

分类专栏： rxjava

本文链接：https://blog.csdn.net/u011955252/article/details/113918385

版权

rxjava 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

如何创建一个Observable 被观察者对象一共有11个函数 create，just，from，defer，repeat ，interval，timer，range，empty，error，

（1）create函数

您可以使用Create 运算符从头创建Observable 。Observable 有 OnNext OnError OnComplete OnNext 可以发送多次，观察者执行多次。 OnComplete 只能发送一次发送之后在次发送 onNext 则不会生效 OnError 只能调用一次发送错误事件，如果使用retry（）函数捕获这个错误，否则事件流全部停止执行。

public class RxJavaCreate {
    public static void main(String[] args) {
        Observable.<Integer>create(observableEmitter->{
            try{
                if(!observableEmitter.isDisposed()){
                    for (int i=0;i<4;i++){
                        observableEmitter.onNext(i);
                        if(i==2){
                            observableEmitter.onError(new Exception("heihei"));
                        }
                    }
                    observableEmitter.onComplete();
                }
            }catch (Exception e){
                observableEmitter.onError(e);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Observer.onSubscribe");

            }

            @Override
            public void onNext(Integer integer) {
                System.out.println("Observer.onNext  "+integer);

            }

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

            }

            @Override
            public void onComplete() {
                System.out.println("Observer.onComplete");

            }
        });
    }
}

Observer.onSubscribe
Observer.onNext  0
Observer.onNext  1
Observer.onNext  2
Observer.onError java.lang.Exception: heihei

2 just函数

public class RxJavaJust {

    public static void main(String[] args) {
        //just函数创建被观察者，最多发送10个数据项，要求数据项类型一致
        Observable.just("zhangsan", "lisi", "wangwu", "zhaoliu", "xieguangkun").subscribe(System.out::println);
    }
}

zhangsan
lisi
wangwu
zhaoliu
xieguangkun

3、from

将各种其他对象和数据类型转换为Observable 支持集合、数组、Runable、Callable、Action、Future

package rxjava;

import io.reactivex.Completable;
import io.reactivex.Observable;
import io.reactivex.functions.Action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

public class RxJavaFrom {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>(Arrays.asList("zhangsan","lisi","wangwu"));
        Observable.fromIterable(list).subscribe(System.out::println);
        System.out.println("----------------");
        String[] array=new String[]{"zhangsan","lisi","wangwu"};
        Observable.fromArray(array).subscribe(System.out::println);
        System.out.println("----------------");
        //线程允许有返回值
        Callable<String> callable=()->{
            return "zhangsan";
        };
        Observable.fromCallable(callable).subscribe(System.out::println);
        System.out.println("----------------");
        //线程不允许有返回值，不允许抛出异常
        Runnable runnable= ()->{
          System.out.println("zhangsan");
        };
        Completable.fromRunnable(runnable).subscribe(()->System.out.println("runnable"));
        System.out.println("----------------");
        //action接口允许抛出异常
        Action action=()->{
            System.out.println("zhangsan");
//            throw  new Exception("heihie");
        };
        Completable.fromAction(action).subscribe(()->System.out.println("action"));
        System.out.println("----------------");
        ScheduledExecutorService executorService= Executors.newSingleThreadScheduledExecutor();
        Future<String> future=executorService.schedule(()->"zhangsan",1, TimeUnit.SECONDS);
        Observable.fromFuture(future).subscribe(System.out::println);
        executorService.shutdown();
    }
}

zhangsan
lisi
wangwu
----------------
zhangsan
lisi
wangwu
----------------
zhangsan
----------------
zhangsan
runnable
----------------
zhangsan
action
----------------
zhangsan

(4)repeat

创建可多次发出特定项目的Observable

在重复操作多次发出的一个项目

import io.reactivex.Observable;

public class RxjavaRepeat {

    public static void main(String[] args) {
        Observable.just("zhangsan").repeat(5).subscribe(System.out::println);
    }
}

zhangsan
zhangsan
zhangsan
zhangsan
zhangsan

5、defer

在观察者订阅之前不要创建Observable，并为每个观察者创建一个新的Observable

package rxjava;


import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

import static java.lang.Thread.sleep;

public class RxjavaDefer {
    public static void main(String[] args) {
        //defer会等待直到观察者订阅它才会创建。defer能够为每一个观察者创建一个独立的被观察者。
        Observable<Long> observable=Observable.defer(()->{
            long systime=System.currentTimeMillis();
            Observable observable1=Observable.just(systime);
            System.out.println("heihei "+observable1);
            return observable1;
        });

        observable.subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                System.out.println(aLong);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
        System.out.println(observable.toString());
        try {
            sleep(1000);
        } catch (InterruptedException e) {
        }
        observable.subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                System.out.println(aLong);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

        System.out.println(observable.toString());

    }
}

heihei io.reactivex.internal.operators.observable.ObservableJust@27ddd392
1613894953060
io.reactivex.internal.operators.observable.ObservableDefer@555590
heihei io.reactivex.internal.operators.observable.ObservableJust@6d1e7682
1613894954065
io.reactivex.internal.operators.observable.ObservableDefer@555590

6 interval

创建一个Observable，它发出以给定时间间隔间隔的整数序列

http://reactivex.io/documentation/operators/interval.html

该间隔符返回一个可观察发出的递增整数的无限序列，与排放之间你选择的时间恒定的间隔。

package rxjava;

import io.reactivex.Observable;

import java.util.concurrent.TimeUnit;

public class RxjavaInterval {
    public static void main(String[] args) throws InterruptedException {
        Observable.interval(3, TimeUnit.SECONDS).subscribe(System.out::println);

        Thread.sleep(100000);
    }
}

7 timer

创建一个Observable，它在给定的延迟后发出特定的项目

计时器

该定时器操作创建一个可观察的是在您指定的时间跨度后，发射一种特定的项目。

package rxjava;


import io.reactivex.Observable;

import java.util.concurrent.TimeUnit;

public class RxjavaTimer {

    public static void main(String[] args) throws InterruptedException {
        Observable.timer(1, TimeUnit.SECONDS).subscribe(v->System.out.println("zhangsan"));

        Thread.sleep(2000);
    }
}

zhangsan

8 range

创建一个Observable，它发出特定范围的连续整数

该范围运营商发出了一系列的连续整数

public class RxjavaRange {
    public static void main(String[] args) {
        Observable.range(1,4).subscribe(x->System.out.println(x));
        Observable.rangeLong(200,5).subscribe(x->System.out.println(x));
    }
}

9 empty 创建一个空的不发射任何数据的Observale

package rxjava;


import io.reactivex.Observable;

public class RxjavaEmpty {
    public static void main(String[] args) throws InterruptedException {
        //不发出任何数据 因此也不会接收到zhangsan数据
        Observable.empty().subscribe(x->System.out.println("zhangsan"));
        Thread.sleep(1000);
    }
}

10 error 创建一个立即发送error的Observale

package rxjava;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxjavaError {
    public static void main(String[] args) {
        Observable.error(new Exception("heihie")).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {

            }

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

            @Override
            public void onComplete() {

            }
        });
    }
}

java.lang.Exception: heihie

红豆和绿豆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RXjava创建函数

如何创建一个Observable 被观察者对象一共有11个函数 create，just，from，defer，repeat ，interval，timer，range，empty，error，（1）create函数您可以使用Create运算符从头创建Observable。Observable 有 OnNext OnError OnComplete OnNext 可以发送多次，观察者执行多次。 OnComplete 只能发送一次发送之后在次发送 onNext 则不会生效OnError...
复制链接

扫一扫