Rxjava传值的使用

最新推荐文章于 2023-09-13 23:06:11 发布
最新推荐文章于 2023-09-13 23:06:11 发布
阅读量2.4k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15059163/article/details/78705246
版权

1.导包

    compile 'io.reactivex.rxjava2:rxjava:2.1.3'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
2.主函数
 

public class MainActivity extends AppCompatActivity {

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv= findViewById(R.id.tv);
    }

    public void cc(View view) {
        switch (view.getId()) {
            case R.id.but1:  //普通上下游传值
                Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                        e.onNext(1);
                        e.onNext(2);
                        e.onNext(3);
                    }
                });
                Observer<Integer> observable1 = new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d("aaa", "onNext: " + integer);
                        tv.setText("" + integer);

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                };
                observable.subscribe(observable1);
                break;
            case R.id.but2:    //链式上下游传值
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                        e.onNext(1);
                        e.onNext(2);
                        e.onNext(3);
                    }
                }).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        tv.setText(integer + "");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });


                break;
            case R.id.but3:   //发送中中断
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                        e.onNext(1);
                        e.onNext(2);
                        e.onNext(3);
                        e.onComplete();
                        e.onNext(4);
                    }
                }).subscribe(new Observer<Integer>() {
                    private Disposable mDisposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        mDisposable = d;
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d("aa", "onNext: " + integer + mDisposable.isDisposed());

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

                break;
            case R.id.but4:     //只关心onnext事件的操作
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                        e.onNext(1);
                        e.onNext(2);
                        e.onNext(3);
                        e.onComplete();
                        e.onNext(4);
                    }
                }).subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d("aa", "accept: " + integer);
                    }
                });

                break;
            case R.id.but5:    //just()方式创建Observable
                Observable.just("woshinidie")
                        .subscribe(new Observer<String>() {
                                       @Override
                                       public void onSubscribe(Disposable d) {

                                       }

                                       @Override
                                       public void onNext(String s) {
                                           tv.setText(s);
                                       }

                                       @Override
                                       public void onError(Throwable e) {

                                       }

                                       @Override
                                       public void onComplete() {

                                       }
                                   }
                        );
                break;
            case R.id.but6:     //fromIterable()方式创建Observable
                Observable.fromIterable(new ArrayList<String>() {
                    {
                        for (int i = 0; i < 5; i++) {
                            add("sb" + i);
                        }
                    }
                }).subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d("aa", "onNext: " + s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

                break;
            case R.id.but7:   //defer()方式创建Observable
                Observable<String> ob = Observable.defer(new Callable<ObservableSource<? extends String>>() {
                    @Override
                    public ObservableSource<? extends String> call() throws Exception {
                        return Observable.just("woshinidie");
                    }
                });
                ob.subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                      tv.setText(s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });



                break;
            case R.id.but8:     //interval( )方式创建Observable
                Observable.interval(3, TimeUnit.SECONDS)
                        .subscribe(new Observer<Long>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Long aLong) {
                                tv.setText(""+aLong);
                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        });

                break;
            case R.id.but9:     //timer( )方式创建Observable
                Observable.timer(5, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        tv.setText("延迟5s后调用了:onNext");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
                break;
            case R.id.but10:     //range( )方式创建Observable
                Observable.range(1, 5).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d("aa", "连续收到:" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
                break;
            case R.id.but11:    //repeat( )方式创建Observable

                Observable.just(123).repeat().subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        tv.setText("重复integer" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

                break;
            case R.id.but12:  //map()操作符
                Observable.just("hellorxjava")
                        .map(new Function<String, Integer>() {
                            @Override
                            public Integer apply(String s) throws Exception {
                                return s.length();
                            }
                        }).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        tv.setText("接收到被转换的数据结果:"+integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

                break;
            case R.id.but13:  //flatMap()操作符
                Observable.just(new ArrayList<String>(){
                    {
                        for (int i = 0; i < 3; i++) {
                            add("data"+i);
                        }
                    }
                }).flatMap(new Function<List<String>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(List<String> strings) throws Exception {
                        return Observable.fromIterable(strings);
                    }
                }).subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.d("aa", "flatMap转换后,接收到的"+o);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

                break;
            case R.id.but14:  //filter()操作符
                Observable
                        .just(new ArrayList<String>(){
                            {
                                for (int i = 0; i < 5; i++) {
                                    add("data"+i);
                                }
                            }
                        })
                        .flatMap(new Function<List<String>, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(List<String> strings) throws Exception {
                                return Observable.fromIterable(strings);
                            }
                        }).filter(new Predicate<Object>() {
                    @Override
                    public boolean test(Object s) throws Exception {
                        String newStr = (String) s;
                        if (newStr.contains("3")){
                            return true;
                        }
                        return false;
                    }
                }).subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d("aa", "accept: "+(String)o);
                    }
                });

                break;
            case R.id.but15:  //take()操作符
                Observable.just(new ArrayList<String>(){
                    {
                        for (int i = 0; i < 8; i++) {
                            add("data"+i);
                        }
                    }
                }).flatMap(new Function<List<String>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(List<String> strings) throws Exception {
                        return Observable.fromIterable(strings);
                    }
                }).take(5).subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object s) throws Exception {
                        Log.d("aa", s.toString());
                    }
                });

                break;
            case R.id.but16:     //doOnNext()操作符
                Observable.just(new ArrayList<String>(){
                    {
                        for (int i = 0; i < 6; i++) {
                            add("data"+i);
                        }
                    }
                }).flatMap(new Function<List<String>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(List<String> strings) throws Exception {
                        return Observable.fromIterable(strings);
                    }
                }).take(5).doOnNext(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d("aa", "额外的准备工作!");
                    }
                }).subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object s) throws Exception {
                        Log.d("aa", s.toString());
                    }
                });

                break;
        }
    }



}





3.主布局
 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    android:orientation="vertical"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="comqq.example.hasee.myapplication.MainActivity">

    <Button
        android:id="@+id/but1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="普通上下游传值"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="链式上下游传值"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="发送中中断"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="只关心onnext事件的操作"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but5"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="just()方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but6"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="fromIterable()方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but7"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="defer()方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but8"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="interval( )方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but9"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="timer( )方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but10"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="range( )方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but11"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="repeat( )方式创建Observable"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but12"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="map()操作符"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but13"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="flatMap()操作符"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but14"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="filter()操作符"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but15"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="take()操作符"
        android:onClick="cc"/>
    <Button
        android:id="@+id/but16"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="doOnNext()操作符"
        android:onClick="cc"/>


    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>



 





 

 


                

        

        

    

  


    

      

        

            

              
                
                  孜燃
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
RxJava的使用

				
			

			

				

					10-27
				

			

		

		

			
				
为了更好地理解RxJava，你需要了解它的基本概念，掌握如何创建和订阅Observable，以及如何使用各种Operator来处理数据流。此外，对于Android开发，了解如何与Android组件配合以及处理线程和异常也至关重要。通过深入...

			
		

	



                

              
                



	

		

			

				
					
RxJava2——1之数据发送和接收

				
			

			

				

					qq_34707150的博客
				

				

					12-04
					
					850
					
				

			

		

		

			
				
RxJava2与RxJava相比不同之处

1、package的更改

rx1包名由原来的rx.xxx更改为io.reactivex.xxx，并且在同一个module之下，rx1和rx2是不兼容的。

2、背压支持

RxJava在1.0只有一个个观察者模式，只能部分支持背压

Observable(被观察者)/Observer（观察者）
	Observable(被观察者)/Subscriber(...

			
		

	



                


  
              

                


	

		

			

				
					
Activity之间的数据传递方法汇总

				
			

			

				

					hdbdhdbh的博客
				

				

					08-26
					
					3818
					
				

			

		

		

			
				
PS：Intent 还支持通过 Bundle 封装数据，然后传递 Bundle，但是查看 intent.putExtra 的实现，我们会发现，其实 intent.putExtra 的内部也是维护的一个 Bundle，因此，通过 putExtra 放入的数据，取出时也可以通过 Bundle 去取。其实 Activity 之间数据传递的方法还是很多的，也各有优缺点，但最最最最最常用的还是第一种—— Intent，其他方法都是理论可行，实际使用起来都会有点鸡肋，或者得不偿失。

			
		

	





	

		

			

				
					
java中的参数传递（值传递和引用传递详解）

				
			

			

				

					Diligent的博客
				

				

					09-13
					
					2312
					
				

			

		

		

			
				
java中的参数传递只有值传递，对于基本数据类型传递的是值的副本，引用数据类型传递的是引用的副本。

			
		

	



		

			
		



	

		

			

				
					
最通俗易懂的教你使用RxJava3(一)

				
			

			

				

					luo_boke的博客
				

				

					04-12
					
					5092
					
				

			

		

		

			
				
Rxjava系列文章，从入门到精深循序渐进式分析讲解。自我总结归纳防加强自己的知识体系构建，希望能帮助路过的你。

			
		

	





	

		

			

				
					
java rx.observable_RxJava2:Observable和Observer如何传递

				
			

			

				

					weixin_35719402的博客
				

				

					02-26
					
					251
					
				

			

		

		

			
				
以Observable为例,先上代码://①ObservableJust observable = (ObservableJust) Observable.just("hello rxjava2");//②ObservableSubscribeOn subscribe = (ObservableSubscribeOn) observable.subscribeOn(Schedulers.io())...

			
		

	





	

		

			

				
					
RxJava2使用简介Demo

				
			

			

				

					12-27
				

			

		

		

			
				
**RxJava2使用简介**  RxJava是一个在Java虚拟机上运行的反应式编程库，它将观察者模式和函数响应式编程的概念结合在一起，为异步编程和事件处理提供了强大的工具。RxJava2是其第二代版本，相较于第一代，它在性能、...

			
		

	





	

		

			

				
					
RxJava使用

				
			

			

				

					12-05
				

			

		

		

			
				
1. **网络请求**：使用RxJava进行网络请求可以将请求、解析和处理逻辑封装在一起，使代码更加简洁。  2. **异步任务**：通过`subscribeOn()`和`observeOn()`控制线程，可以轻松实现后台下载、计算等任务，同时在UI...

			
		

	





	

		

			

				
					
RxJava2配置及使用详解

				
			

			

				

					08-30
				

			

		

		

			
				
RxJava2 配置及使用详解  RxJava2 是一个功能强大且流行的响应式编程库，用于处理异步数据流。它基于观察者模式，实现了事件的异步处理。RxJava2 的配置和使用涉及到多个方面，包括 Observable、Observer、Emitter、...

			
		

	





	

		

			

				
					
RxJava使用测试

				
			

			

				

					12-26
				

			

		

		

			
				
在Android中，使用`RxAndroidPlugins`和`RxLifecycle`库可以很好地处理RxJava的生命周期问题，确保在Activity或Fragment销毁时自动取消订阅。  **实践案例**  在`MyRxDemo`项目中，你可以看到如何实际运用RxJava进行...

			
		

	





	

		

			

				
					
Android RxJava的使用

				
			

			

				

					06-08
				

			

		

		

			
				
**Android RxJava的使用**  RxJava是一个在Java虚拟机上运行的反应式编程库，它为Android开发提供了强大的异步处理能力。通过观察者模式，它使得事件处理、数据流管理和响应式编程变得简单易懂。这个技术在Android...

			
		

	





	

		

			

				
					
RxJava的使用详解

				
			

			

				

					06-30
				

			

		

		

			
				
在这个详尽的讨论中，我们将深入理解RxJava的核心概念、操作符以及如何在实际项目中有效地使用它。  首先，让我们了解什么是反应式编程。反应式编程是一种编程范式，它强调数据流和变换，以及在变化的数据源上建立...

			
		

	





	

		

			

				
					
Android rxjava的使用

				
			

			

				

					05-04
				

			

		

		

			
				
本篇文章将详细讲解如何在Android中使用RxJava，包括事件的发送、线程的调度以及数据的比对。  首先，让我们理解一下RxJava的核心概念。RxJava是一个基于观察者模式的库，它允许我们通过定义Observable（可观察者）...

			
		

	





	

		

			

				
					
RxJava之BehaviorSubject使用

				
			

			

				

					09-07
				

			

		

		

			
				
在Android开发中，RxJava是一个广泛使用的响应式编程库，它允许开发者以声明式的方式处理异步数据流。BehaviorSubject是RxJava中的一个特殊类型的行为观察者，它扮演着 observable 和 observer 的双重角色，能够存储...

			
		

	





	

		

			

				
					
android Rxjava简单使用Demo

				
			

			

				

					08-09
				

			

		

		

			
				
RxJava是一种在Java VM上使用 Reactive Extensions 的库，它允许你通过声明式的方式处理异步数据流。这种数据流可以是事件、数据或者任何其他可观察的对象序列。RxJava的设计理念是将观察者模式和发布/订阅模式结合...

			
		

	





	

		

			

				
					
java发送list数据,RxJava实现遍历List集合定时发射每条数据

				
			

			

				

					weixin_34024555的博客
				

				

					03-12
					
					1479
					
				

			

		

		

			
				
场景：遍历一个List集合，每次循环结束都等待一定时间再继续下一次循环。普通做法for (String s : strings) {Thread.sleep(1000);}上面这种做法简单粗暴，就是不够优雅，在子线程进行时，循环没结束且刚好在sleep中时，我们尝试interrupt此子线程的时候会抛java.lang.InterruptedException异常RxJava做法：使用ZIP操作符...

			
		

	





	

		

			

				
					
RxJava.zip()实现遍历List集合定时发射每条数据

				
			

			

				

					火星男孩的分享空间
				

				

					07-14
					
					234
					
				

			

		

		

			
				
RxJava.zip()实现遍历List集合定时发射每条数据

			
		

	





	

		

			

				
					
Android RxJava 2 的用法 just 、from、map、subscribe、flatmap、Flowable、Function、Consumer ...

				
			

			

				

					Gabriel的专栏
				

				

					05-08
					
					519
					
				

			

		

		

			
				
先简单说说RxJava的用途与价值
用途: 异步 (也就是开线程跳转)
价值: 面对复杂的逻辑,它依然 简洁 ,代码 易读

RxJava2 与 RxJava 最大的不一样的地方,就是 Flowable ,这个 Flowable 取代了Rxjava 中的

简单的使用:
下面展示一段代码:

Flowable
    .fromArray(weeks)
    .map(new Function<String, String>() {
      @Override
...

			
		

	





	

		

			

				
					
使用RXJava 的心得以及不用传参数的请求 解决办法

				
			

			

				

					会飞的小驴粪蛋
				

				

					05-26
					
					2480
					
				

			

		

		

			
				
使用@Field

代码如下：


/**
 * 
 *
 * @param description
 * @return
 */
@FormUrlEncoded
@POST("/customer/getAccountB")
Observable<BaseResponse> getAccountBillP(@Field("description") RequestBody descr...

			
		

	





	

		

			

				
					
RxJava怎么使用

					
最新发布

				
			

			

				

					09-12
				

			

		

		

			
				
以下是使用RxJava的基本步骤：  1. **添加依赖**：如果你使用的是Maven，可以在pom.xml文件中添加```<dependency>```标签引入RxJava库。  2. **创建Observable**：你可以通过多种方式创建Observable，比如从网络请求...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值