RxJava的使用

RxJava的使用

1、app   build.gradle中添加

    compile 'io.reactivex.rxjava2:rxjava:2.0.0'
    compile 'org.reactivestreams:reactive-streams:1.0.0'

2、测试

package com.test.main;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;

/**
 * http://blog.youkuaiyun.com/qq_35064774/article/details/53057332
 * RxJava 察者模式+迭代器模式+函数式编程
 */

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity222222";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//        testOne();
//        testTwo();
//        test3();
//        test4();
    }

    private void testOne() {
        //创建一个Flowable对象很简单,直接调用Flowable.create即可。
        Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                Log.i(TAG, "FlowableOnSubscribe subscribe: ");
                e.onNext("Hello Rxjava2");//发射了一个字符串"hello RxJava 2"。
                e.onComplete();
            }
        }, BackpressureStrategy.BUFFER);

//        创建一个Subscriber
        Subscriber subscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.i(TAG, "onSubscribe: ");
                s.request(Long.MAX_VALUE);//调用request去请求资源,参数就是要请求的数
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "onNext: s= " + s);//onNext方法里面传入的参数就是Flowable中发射出来的。
            }


            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");

            }
        };

        flowable.subscribe(subscriber);//为了让”发射器”和”接收器”工作起来,我们还需要把他们组装在一起。
    }



    private void testTwo() {
        Flowable<String> flowable = Flowable.just("hello Rxjava 2");//直接调用Flowable.just创建一个发射字符串的”发射器”。

        Consumer consumer = new Consumer<String>() {//对于 Subscriber 来说,我们目前仅仅关心onNext方法

            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: s =" + s);
            }
        };

        flowable.subscribe(consumer);
    }


    private void test3() {//操作符
        Flowable.just("map")
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) throws Exception {
                        Log.i(TAG, "apply: s = " + s);
                        return s + "-day day up";// map 是把传递过来的结果末尾加上了签名,然后在传递给了订阅者。
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, "accept: s = " + s);
                    }
                });
    }


    private void test4() {//map 操作符进阶
        Flowable.just("map1")
                .map(new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        Log.i(TAG, "apply:  s.hashCode() = " + s.hashCode());
                        return s.hashCode();
                    }
                })
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        Log.i(TAG, "apply: integer = " + integer);
                        return integer.toString();
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: s = " + s);
            }
        });
    }

    private void test5() {//map 创建操作符


//        Observable.timer(3, TimeUnit.SECONDS, AndroidSchedulers.mainThread()).map(new Function<Long, Object>() {
//        })
//        Flowable.just("map1")
//                .map(new Function<String, Integer>() {
//                    @Override
//                    public Integer apply(String s) throws Exception {
//                        Log.i(TAG, "apply:  s.hashCode() = " + s.hashCode());
//                        return s.hashCode();
//                    }
//                })
//                .map(new Function<Integer, String>() {
//                    @Override
//                    public String apply(Integer integer) throws Exception {
//                        Log.i(TAG, "apply: integer = " + integer);
//                        return integer.toString();
//                    }
//                }).subscribe(new Consumer<String>() {
//            @Override
//            public void accept(String s) throws Exception {
//                Log.i(TAG, "accept: s = " + s);
//            }
//        });
    }



}


### 关于 RxJava 使用示例 #### 创建简单的 Observable 和 Subscriber 创建一个简单的Observable并订阅它来接收数据流中的事件是一个很好的起点。 ```java import io.reactivex.rxjava3.core.Observable; import io.reactivex.rxjava3.disposables.Disposable; public class SimpleExample { public static void main(String[] args) throws InterruptedException { // 创建一个发射整数序列的Observable Observable<Integer> observable = Observable.just(1, 2, 3); // 定义Subscriber处理接收到的数据项 Disposable disposable = observable.subscribe(System.out::println); Thread.sleep(100); // 等待完成 disposable.dispose(); // 清理资源 } } ``` 此代码片段展示了如何定义一个只发送三个整数值给观察者的可观察对象,并立即打印这些值[^1]。 #### 利用 map 转换操作符修改数据流 `map` 操作符允许转换来自上游的数据,在这里展示了一个字符串列表被映射成大写形式的例子: ```java import io.reactivex.rxjava3.core.Observable; public class MapOperatorExample { public static void main(String[] args) { List<String> words = Arrays.asList("hello", "world"); Observable.fromIterable(words) .map(String::toUpperCase) .subscribe(System.out::println); } } ``` 这段程序会把输入单词转为全大写字母输出. #### 实现线程调度功能 为了更好地模拟异步场景,可以使用 `Schedulers` 来指定不同的执行上下文: ```java import io.reactivex.rxjava3.schedulers.Schedulers; public class SchedulerExample { public static void main(String[] args) throws Exception { Observable.just("Hello from background thread!") .subscribeOn(Schedulers.newThread()) .observeOn(Schedulers.trampoline()) .subscribe(System.out::println); Thread.sleep(500L); // 让主线程等待以便看到后台线程的结果 } } ``` 上述例子演示了怎样让任务在一个新的线程上运行(`subscribeOn`),然后再切换回另一个特定的线程去消费结果(`observeOn`). 这对于实现UI更新非常有用[^2].
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值