RxJava----操作符：算术和聚合操作符

最新推荐文章于 2021-03-02 12:06:32 发布
最新推荐文章于 2021-03-02 12:06:32 发布
阅读量3.1k 收藏
点赞数
分类专栏： 开源框架 文章标签： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20198405/article/details/51260739
版权

Mathematical and Aggregate Operators（算术和聚合操作符）

count

count 函数和 Java 集合中的 size 或者 length 一样。用来统计源 Observable 完成的时候一共发射了多少个数据。
这里写图片描述

        Observable<Integer> values = Observable.range(0, 3);
        values.subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {
                log("values:Complete!");
            }

            @Override
            public void onError(Throwable e) {
                log("values:" + e.getMessage().toString());
            }

            @Override
            public void onNext(Integer integer) {
                log("values:" + integer);
            }
        });
        values.count()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {
                        log("count:Complete!");
                    }

                    @Override
                    public void onError(Throwable e) {
                        log("count:" + e.getMessage().toString());
                    }

                    @Override
                    public void onNext(Integer integer) {
                        log("count:" + integer);
                    }
                });

结果：

values: 0
values: 1
values: 2
values: Complete!
count: 3
count: Complete!

如果发射数据的个数超过了 int 最大值，则可以使用 countLong 函数。

reudce

你可能从 [MapReduce] 中了解过 reduce。该思想是使用源 Observable 中的所有数据两两组合来生成一个单一的 数据。在大部分重载函数中都需要一个函数用来定义如何组合两个数据变成一个。

public final Observable<T> reduce(Func2<T,T,T> accumulator)

这里写图片描述

        Observable<Integer> values = Observable.range(0,5);
        values.reduce(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return integer+integer2;
            }
        })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {
                        log("Sum:Complete!");
                    }
                    @Override
                    public void onError(Throwable e) {
                        log("Sum:"+e.getMessage().toString());
                    }
                    @Override
                    public void onNext(Integer integer) {
                        log("Sum:"+integer);
                    }
                });

        values.reduce(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return (integer>integer2) ? integer2 : integer;
            }
        })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {
                        log("Min:Complete!");
                    }
                    @Override
                    public void onError(Throwable e) {
                        log("Min:"+e.getMessage().toString());
                    }
                    @Override
                    public void onNext(Integer integer) {
                        log("Min:"+integer);
                    }
                });

结果：

Sum: 10
Sum: Complete!
Min: 0
Min: Complete!
  • Rx 中的 reduce 和并行系统中的 reduce 不一样。
  • 在并行系统中的 reduce 是指，计算的取值是不相关的，这样多个机器可以独立并行工作。
  • 在 Rx 中是使用从数据流中第一个数据到最后一个数据（从左往右）中的数据来调用 参数 accumulator ，accumulator 用前一次返回的结果和下一个数据来再次调用 accumulator （累加器）。
  • 下面这个重载函数更加暴露了这个设计意图。
public final <R> Observable<R> reduce(R initialValue, Func2<R,? super T,R> accumulator)
        Observable<String> values = Observable.just("Rx", "is", "easy");
        values.reduce(0, new Func2<Integer, String, Integer>() {
            @Override
            public Integer call(Integer integer, String s) {
                return integer+1;
            }
        })
           //实现Last
//        values.reduce("", new Func2<String, String, String>() {
//            @Override
//            public String call(String s, String s2) {
//                return s2;
//            }
//        })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {
                        log("Count:Complete!");
                    }
                    @Override
                    public void onError(Throwable e) {
                        log("Count:"+e.getMessage().toString());
                    }
                    @Override
                    public void onNext(Integer integer) {
                        log("Count:"+integer);
                    }
                });

结果：

Count:3
Count: Complete!

上面示例中的 accumulator 参数为
new Func2<String, String, String>()，其中call（integer，s）需要两个参数 integer和s， 当第一个数据从 源 Observable 发射出来的时候，由于 call（integer，s）还没有调用过，所以使用 初始值 0 来替代 integer，使用第一个字符串“Rx” 来调用 accumulator （也就是new Func2()），这样 call（integer，s）返回的值就是 integer+ 1 （而 integer为初始值 0 ，所以返回 1， 可以看到 这个 s参数 为源 Observable 的值在这里是没有用的）；这样 源Observable 每次发射一个数据，accumulator 就把上一次的结果加1 返回。和 count 的功能一样。

对于前面只返回一个数据结果的操作函数，大部分都可以通过 reduce 来实现。对于那些 源 Observable 没有完成就返回的操作函数来说，是不能使用 reduce 来实现的。所以 可以用 reduce 来实现 last，但是用 reduce 实现的 all 函数和原来的 all 是不太一样的。

Aggregation to collections（把数据聚合到集合中）

使用 reduce 可以把源Observable 发射的数据放到一个集合中：

        Observable<Integer> values = Observable.range(10,5);
        values
                .reduce(new ArrayList<Integer>(), new Func2<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
                    @Override
                    public ArrayList<Integer> call(ArrayList<Integer> integers, Integer integer) {
                        integers.add(integer);
                        return integers;
                    }
                })
                .subscribe(new Observer<ArrayList<Integer>>() {
                    @Override
                    public void onCompleted() {
                        log("Complete!");
                    }
                    @Override
                    public void onError(Throwable e) {
                        log( e.getMessage().toString());
                    }
                    @Override
                    public void onNext(ArrayList<Integer> arrayList) {
                        log(arrayList.toString());
                    }
                });

reduce 的参数初始值为 new ArrayList()， reduce把源Observable 发射的数据添加到这个 List 中。当 源Observable 完成的时候，返回这个 List 对象。
结果：

[10, 11, 12, 13, 14]
Complete!

collect

  • 前面提到的，使用 reduce 可以把源Observable 发射的数据放到一个集合中，其实并不太符合 Rx 操作符的原则。
  • 操作符有个原则是不能修改其他对象的状态。
  • 所以符合原则的实现应该是在每次转换中都创建一个新的 ArrayList 对象。

下面是一个符合原则但是效率很低的实现：.

    .reduce(new ArrayList<Integer>(), new Func2<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
                    @Override
                    public ArrayList<Integer> call(ArrayList<Integer> integers, Integer integer) {
                        ArrayList<Integer> newAcc = (ArrayList<Integer>) integers.clone();
                        newAcc.add(integer);
                        return integers;
                    }
                })

上面每一个值都创建一个新对象的性能是无法接受的，需要通过文档说明你没有遵守 Rx 的原则使用不可变对象，避免其他人误解。为此，

  • Rx 提供了一个 collect 函数来实现该功能，该函数使用了一个可变的 accumulator 。
        Observable<Integer> values = Observable.range(10,5);
        values
                .collect(new Func0<ArrayList<Integer>>() {
                    @Override
                    public ArrayList<Integer> call() {
                        return new ArrayList<Integer>();
                    }
                }, new Action2<ArrayList<Integer>, Integer>() {
                    @Override
                    public void call(ArrayList<Integer> arrayList, Integer integer) {
                        arrayList.add(integer);

                    }
                })
                .subscribe(new Action1<ArrayList<Integer>>() {
                    @Override
                    public void call(ArrayList<Integer> integers) {
                        log(integers.toString());
                    }
                });

结果：

[10, 11, 12, 13, 14]

toList

        Observable<Integer> values = Observable.range(10,5);
        values
                .toList()
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        log(integers.toString());
                    }
                });.

结果：

[10, 11, 12, 13, 14]

toSortedList

toSortedList 和前面类似，返回一个排序后的 list，下面是该函数的定义：

public final Observable<java.util.List<T>> toSortedList()
public final Observable<java.util.List<T>> toSortedList(
    Func2<? super T,? super T,java.lang.Integer> sortFunction)

可以使用默认的比较方式来比较对象，也可以提供一个比较参数。该比较参数和 Comparator 接口语义一致。
下面通过一个自定义的比较参数来返回一个倒序排列的整数集合：

        Observable<Integer> values = Observable.range(10,5);
        values
                .toSortedList(new Func2<Integer, Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer, Integer integer2) {
                        return integer2 - integer;
                    }
                })
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        log(integers.toString());
                    }
                });

结果：

[14, 13, 12, 11, 10]

toMap

toMap 把数据流 T 变为一个 Map<TKey,T>。 该函数有三个重载形式：

public final <K> Observable<java.util.Map<K,T>> toMap(
    Func1<? super T,? extends K> keySelector)
public final <K,V> Observable<java.util.Map<K,V>> toMap(
    Func1<? super T,? extends K> keySelector,
    Func1<? super T,? extends V> valueSelector)
public final <K,V> Observable<java.util.Map<K,V>> toMap(
    Func1<? super T,? extends K> keySelector,
    Func1<? super T,? extends V> valueSelector,
    Func0<? extends java.util.Map<K,V>> mapFactory)
  • keySelector 功能是从一个值 T 中获取他对应的 key。
  • valueSelector 功能是从一个值 T 中获取需要保存 map 中的值。
  • mapFactory 功能是创建该 map 对象。

来看看一个示例：
有这么一个 Person 对象：

class Person {
    public final String name;
    public final Integer age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

下面的代码使用 Person 的 name 作为 key， Person 作为 map 的value：

        Observable<Person> values = Observable.just(
                new Person("Will", 25),
                new Person("Nick", 40),
                new Person("Saul", 35)
        );
        values
                .toMap(new Func1<Person, String>() {
                    @Override
                    public String call(Person person) {
                        return person.name;
                    }
                })
                .subscribe(new Action1<Map>() {
                    @Override
                    public void call(Map mMap) {
                        log(mMap.toString());
                    }
                });.

结果：

Saul=Person@5280919c, Will=$Person@5280914c, Nick=$Person@52809174}

还可以用 Person 的 age 作为map 的value：

        values
            .toMap(new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.name;
                    }
                }, new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.age;
                    }
                })

结果：

{Saul=35, Will=25, Nick=40}

还可以自定义如何生成这个 map 对象：

        values
            .toMap(new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.name;
                    }
                }, new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.age;
                    }
                }, new Func0<Map<Object, Object>>() {
                    @Override
                    public Map<Object, Object> call() {
                        return new HashMap();
                    }
                })

最后一个参数为工厂函数，每次一个新的 Subscriber 订阅的时候， 都会返回一个新的 map 对象。

toMultimap

通常情况下多个 value 的 key 可能是一样的。 一个 key 可以映射多个 value 的数据结构为
multimap，multimap 的 value 为一个集合。该过程被称之为 “grouping” （分组）。

public final <K> Observable<java.util.Map<K,java.util.Collection<T>>> toMultimap(
    Func1<? super T,? extends K> keySelector)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(
    Func1<? super T,? extends K> keySelector,
    Func1<? super T,? extends V> valueSelector)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(
    Func1<? super T,? extends K> keySelector,
    Func1<? super T,? extends V> valueSelector,
    Func0<? extends java.util.Map<K,java.util.Collection<V>>> mapFactory)
public final <K,V> Observable<java.util.Map<K,java.util.Collection<V>>> toMultimap(
    Func1<? super T,? extends K> keySelector,
    Func1<? super T,? extends V> valueSelector,
    Func0<? extends java.util.Map<K,java.util.Collection<V>>> mapFactory,
    Func1<? super K,? extends java.util.Collection<V>> collectionFactory)

下面是通过 age 来分组 Person 的实现：

        Observable<Person> values = Observable.just(
                new Person("Will", 35),
                new Person("Nick", 40),
                new Person("Saul", 35)
        );
        values
                .toMultimap(
                        new Func1<Person, Object>() {
                            @Override
                            public Object call(Person person) {
                                return person.age;
                            }
                        }, new Func1<Person, Object>() {
                            @Override
                            public Object call(Person person) {
                                return person.name;
                            }
                        })
                .subscribe(new Action1<Map>() {
                    @Override
                    public void call(Map mMap) {
                        log(mMap.toString());
                    }
                });

结果：

{35=[Will, Saul], 40=[Nick]}

toMultimap 的参数和 toMap 类似，最后一个 collectionFactory 参数是用来创建 value 的集合对象的，collectionFactory 使用 key 作为参数，这样你可以根据 key 来做不同的处理。下面示例代码中没有使用这个 key 参数：

        Observable<Person> values = Observable.just(
                new Person("Will", 35),
                new Person("Nick", 40),
                new Person("Saul", 35)
        );

        values
        .toMultimap(
                new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.age;
                    }
                }, new Func1<Person, Object>() {
                    @Override
                    public Object call(Person person) {
                        return person.name;
                }, new Func0<Map<Object, Collection<Object>>>() {
                    @Override
                    public Map<Object, Collection<Object>> call() {
                        return new HashMap();
                    }
                }, new Func1<Object, Collection<Object>>() {
                    @Override
                    public Collection<Object> call(Object o) {
                        return new ArrayList();
                    }
                }) // 没有使用这个 key 参数

注意事项

这些操作函数都有非常有限的用法。这些函数只是用来给初学者把数据收集到集合中使用的，并且内部使用传统的方式来处理数据。这些方式不应该在实际项目中实现，因为他们和使用Rx 的理念并不相符。
Concatenation

一个数据流发射完后继续发射下一个数据流是一种很常见的组合方法。

concat

concat 操作函数把多个数据流按照顺序一个一个的发射数据。第一个数据流发射完后，继续发射下一个。 concat 函数有多个重载函数：

public static final <T> Observable<T> concat(
    Observable<? extends Observable<? extends T>> observables)
public static final <T> Observable<T> concat(
    Observable<? extends T> t1,
    Observable<? extends T> t2)
public static final <T> Observable<T> concat(Observable<? extends T> t1,
    Observable<? extends T> t2,
    Observable<? extends T> t3)
public static final <T> Observable<T> concat(Observable<? extends T> t1,
    Observable<? extends T> t2,
    Observable<? extends T> t3,
    Observable<? extends T> t4)
// All the way to 10 observables

这里写图片描述
示例：

        Observable<Integer> seq1 = Observable.range(0, 3);
        Observable<Integer> seq2 = Observable.range(10, 3);
        Observable.concat(seq1, seq2)
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                });

结果：

0
1
2
10
11
12

如果需要组合的数据流是动态的，则依然可以使用 concat 来组合返回多个 Observable 的情况。

下面的示例中，使用groupBy 来把一个 Observable 中的数据流分组为多个 Observable ，这样 groupBy 返回的是多个
Observable， 然后使用 concat 把这些 动态生成的 Observable 给组合起来：

        Observable<String> words = Observable.just(
                "First",
                "Second",
                "Third",
                "Fourth",
                "Fifth",
                "Sixth"
        );
        Observable
                .concat(words.groupBy(new Func1<String, Object>() {
                    @Override
                    public Object call(String s) {
                        return s.charAt(0);
                    }
                }))
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                });

结果：

First
Fourth
Fifth
Second
Sixth
Third

concat 的行为有点像 concatMap 操作函数的扁平处理（flattening phase）。事实上， concatMap 等价于 先应用 map 操作函数然后再使用 concat。

concatWith

concatWith 函数是 concat 的另外一种使用方式，可以通过串联的方法来一个一个的组合数据流。

    Observable<Integer> seq1 = Observable.range(0, 3);
    Observable<Integer> seq2 = Observable.range(10, 3);
    Observable<Integer> seq3 = Observable.just(20);

    seq1.concatWith(seq2)
        .concatWith(seq3)
        .subscribe(System.out::println);
}

结果：

0
1
2
10
11
12
20

amb

amb 的参数为多个 Observable，使用第一个先发射数据的 Observable ，其他的 Observable 被丢弃。

public static final <T> Observable<T> amb(
    java.lang.Iterable<? extends Observable<? extends T>> sources)
public static final <T> Observable<T> amb(
    Observable<? extends T> o1,
    Observable<? extends T> o2)
public static final <T> Observable<T> amb(
    Observable<? extends T> o1,
    Observable<? extends T> o2,
    Observable<? extends T> o3)

这里写图片描述

         Observable.amb(
                Observable.timer(100, TimeUnit.MILLISECONDS)
                        .map(new Func1<Long, Object>() {
                            @Override
                            public Object call(Long aLong) {
                                return "First";
                            }
                        }),
                Observable.timer(50, TimeUnit.MILLISECONDS)
                        .map(new Func1<Long, Object>() {
                            @Override
                            public Object call(Long aLong) {
                                return "Second";
                            }
                        })
                )
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                });

结果：

Second
  • 由于第二个 Observable 先开始发射数据，所以第一个 Observable 被丢弃了， 使用 第二个 Observable。
  • 该操作函数可以用于如下情况：

你有多个廉价的资源提供方，但是这些资源提供方返回数据的时间是不一样的。例如一个天气预报应用，可以从多个数据源获取数据，当其中一个数据源返回数据的时候，就丢弃其的请求，而使用这个数据源。

ambWith

  • 同样，还有一个 ambWith 版本的函数，可以通过链式调用每个 Observable。让代码看起来更优雅一些：
        servable.timer(100, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Object>() {
                    @Override
                    public Object call(Long aLong) {
                        return "First";
                    }
                })
                .ambWith(Observable.timer(50, TimeUnit.MILLISECONDS).map(new Func1<Long, Object>() {
                    @Override
                    public Object call(Long aLong) {
                        return "Second";
                    }
                }))
                .ambWith(Observable.timer(70, TimeUnit.MILLISECONDS).map(new Func1<Long, Object>() {
                    @Override
                    public Object call(Long aLong) {
                        return "Third";
                    }
                }))
                .subscribe(new Action1<Object>() {
                     @Override
                     public void call(Object o) {
                        log(o.toString());
                     }
                });

结果：

Second

Sum

计算并发射数据序列的和

Average

计算Observable发射的数据序列的平均值，然后发射这个结果

Max

计算并发射数据序列的最大值

Min

计算并发射数据序列的最小值

项目源码 GitHub求赞，谢谢！
引用：
RxJava 教程第二部分：事件流基础之 聚合 - 云在千峰
Android RxJava使用介绍（三） RxJava的操作符 - 呼啸而过的专栏 - 博客频道 - CSDN.NET

pepe_士奇
关注
专栏目录
【Mysql数据库 第4章】MySQL的运算符、聚合函数的使用、MySQL数据库基本操作-DQL
KJ.JK
02-13 1万+
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习。位运算符是在二进制数上进行计算的运算符；位运算会先将操作数变成二进制数，进行位运算；数据库管理系统一个重要功能就是数据查询，数据查询不应只是简单返回数据库中存储的数据，通过MySQL运算符进行运算，就可以获取到表结构以外的另一种数据。还应该根据需要对数据进行筛选以及确定数据以什么样的格式显示。数据库中的表结构确立后，表中的数据代表的意义就已经确定。然后再将计算结果从二进制数变回十进制数。
RxJava实例-按钮点击数累加
开发简记
05-16 1164
RxJava实例 RxJava实例-线程切换 效果图 点击累加.gif 说明 在一定时间内（3s），对点击按钮的次数进行累计，每点击一下，输出一条log，当时间到时（3s），会输出这段时间内点击的次数 buffer操作符 实现这种效果的办法当然有很多种，这里用RxJava的buffer操作符来简单写一个demo。 image.png 这张图简单明了，不用多说。 实现方式 之前参考的代码用的是
RxJava 2.x 之聚合操作符
handy周
10-24 557
聚合操作符 startWith操作符 startWithArray操作符 concat/concatArray操作符 merge/mergeArray操作符 concatDelayError/mergeDelayError操作符 zip操作符 combineLatest操作符 combineLatestDelayError操作符 reduce操作符 count操作符 collect操作符 st...
RX操作符之算术和聚合操作（averageInteger、min、max、count、sum、contact、reduce、collect）
nicolelili1的专栏
08-11 2610
一、averageInteger 计算Observable的发射数字的平均值。Average操作符操作符一个发射数字的Observable，并发射单个值：原始Observable发射的数字序列的平均值。这个操作符不包含在RxJava核心模块中，它属于不同的rxjava-math模块。它被实现为四个操作符：averageDouble, averageFloat, averageInteger, a
Rxjava计算操作符
07-24 687
Rxjava中的算术运算符 说明：Rxjava中的算术运算并不是Rxjava的核心模块，而是在rxjava-math模块中，到目前为止rxjava-math只有一个版本。不经意看到了这个运算符，发现网上关于怎么使用的资料几乎没有，所以强迫症犯了，研究了一下做个记录。 算术运算符都包括什么 . averageInteger( )— 求序列平均数并发射 . averageLong( )
RxJava操作符(09-算术/聚合操作&连接操作)
openXu的专栏
06-16 6735
转载请标明出处： http://blog.csdn.net/xmxkf/article/details/51671826 本文出自:【openXu的博客】目录：算术聚合 Count Concat Reduce 连接操作 Publish Connect RefCount Replay 算术&聚合1. Count  Count操作符将一个Observable转换成一个发射单个值的Observab
Rxjava-中文文档
01-04
算术和聚合操作包括Average、Concat、Reduce、Max、Min、Count、Sum等，用于对发射的数据执行聚合计算。 异步操作和连接操作主要用于控制Observable的发射行为和管理订阅，例如Connect、Publish、RefCount、Replay...
Android-学习笔记-RxJava操作符(二)
zuochunsheng的博客
11-15 228
5 错误处理 onErrorResumeNext( ) — 指示Observable在遇到错误时发射一个数据序列 onErrorReturn( ) — 指示Observable在遇到错误时发射一个特定的数据 onExceptionResumeNext( ) — 指示Observable遇到错误时继续发射数据 retry( ) — 指示Observable遇到错误时重试。Retry操作符不会将原始...
第九章-操作符及sql函数.ppt
最新发布
03-24
操作符主要包括算术、比较、逻辑、集合和连接这五类。算术操作符如加、减、乘、除，常用于对数值进行计算。例如，可以增加或减少某个字段的值，或者调整成绩的百分比。比较操作符则用于比较两个值，例如等于、不等于...
MySQL 5.1中文手册：函数与操作符详解
MySQL 5.1简体中文手册的第12章深入探讨了数据库中的关键函数和操作符。这一章涵盖了广泛的主题，包括： 1. **操作符优先级**：介绍了MySQL中运算符的执行顺序，这对于编写有效的SQL语句至关重要，理解不同运算符的...
RxJava操作符
yang_song_song的博客
03-22 372
RXJAVA地址： https://github.com/ReactiveX/RxJava0.什么是观察者模式1.RXJAVA是什么2.最简单的DEMO在Rxjava当中最重要的就是操作符，RxJava当中有着庞大的操作符创建操作符：负责创建Observable对象just( ) — 将一个或多个对象转换成发射这个或这些对象的一个Observable from( ) — 将一个Iterable,
RxJava算术聚合连接及自定义操作符
BoBoMEe
05-03 1417
概述RxJava中的条件和boolean操作，及算术和 聚合操作,连接操作。条件操作符 amb() — 给定多个Observable，只让第一个发射数据的Observable发射全部数据 defaultIfEmpty(T t) — 发射来自原始Observable的数据，如果原始Observable没有发射数据，就发射一个默认数据T skipUntil() — 丢弃原始Observable发射的数据
RxJava 的操作符
流水不腐小夏
01-21 1393
著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：冷月 链接：https://www.zhihu.com/question/32209660/answer/63984697 来源：知乎ReactiveX的每种编程语言的实现都实现了一组操作符的集合。不同的实现之间有很多重叠的部分，也有一些操作符只存在特定的实现中。每种实现都倾向于用那种编程语言中他们熟悉的上下文中相
RxJava运算符
从零开始的教程世界
07-15 250
In this tutorial, we’ll discuss and implement the various operators that RxJava has. How each operator transforms the Observable sequences and what the subscriber sees? Let’s start! 在本教程中，我们将讨论和实现RxJa...
拆轮子系列--RxJava理解(一)--Map解析
weixin_33699914的博客
07-19 89
本系列文章如下： 拆轮子系列--RxJava前奏篇 拆轮子系列--RxJava理解(一)--Map解析 拆轮子系列--RxJava理解(二)--subscribeOn 拆轮子系列--RxJava理解(三)--observeOn 上一篇文章属于RxJava的前奏篇，大体介绍了下为什么要使用RxJava，本篇文章主要从RxJava的基本使用流程入手来对RxJava的源码进行分析，本文的分析源码基于...
Mathematical 算术和聚合操作
东子的博客 细节决定成败，点滴铸就辉煌。
03-21 600
本页展示的操作符用于对整个序列执行算法操作或其它操作，由于这些操作必须等待数据发射完成（通常也必须缓存这些数据），它们对于非常长或者无限的序列来说是危险的，不推荐使用。rxjava-math 模块的操作符 averageInteger( ) — 求序列平均数并发射 averageLong( ) — 求序列平均数并发射 averageFloat( ) — 求序列平均数并发射 averageDouble
安卓java 倒计时_用RxJava实现倒计时与踩坑
weixin_30974667的博客
03-02 281
废话不多说直接上代码：public class RxCountDown {public static Observable countdown(int time) {if (time < 0) time = 0;final int countTime = time;return Observable.interval(0, 1, TimeUnit.SECONDS).subscribeOn(A...
RxJava数学操作函数
红豆和绿豆的博客
02-22 152
1、count 统计数据流的数量，通过调用一次onComplete计算发送数量 package rxjava.macth; import io.reactivex.Observable; public class RxJavaCount { public static void main(String[] args) { Observable.range(1,10).count().subscribe(System.out::println); } } 10 .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值