继续打包

这一节，我们继续学习打包

Zip

这个看上就是打包的，他的目的就是将两个观察源进行打包起来，这里有区别，就是他能够将几个item 进行重装处理，主要是利用BiFunction进行重装

var source1 = Observable.just("SADsd", "SDsdassd")
val source3 = Observable.range(1, 6)
Observable.zip<String, Int, String>(source1, source3, BiFunction<String, Int, String> { x, y -> "$x : $y" }).subscribe { println("Letter is $it") }

这和前面的merge，concat 是不一样的,打入同一个观察源，而且还可以对其中的信息进行合并处理，当时这里是一对一的，如果两个信息源是不一样的，那么以最短的哪一个为主， 上面例子中，souce3如果是单独发送，则有5个信息源可以发送，但是由于source1只有两个信息源，所以当我们输出的时，只会输出两个。

这里重点说说和merge 的区别，merge 主要是将观察源进行线性组合，只是简单的将各个观察源放在同一个观察源中使用，信息源是不会丢失的，但是zip 的方式有点不一样，如果把观察看成是一个数组，那么每一次，我们都会从数组中取同一序号的信息源进行拼装，具体拼装方式你可以自己定义，你甚至可以对某些信息源不进行处理,但是merge只能对单个信息源进行处理，就好比过隧道，merge是单行道进行排队前进，而zip就是多行道并肩前进,还可以相互递眼神进行交流。

zipWith

zipWith 功能的方面和zip是差不多的，只是他是针对一个已经存在的观察源，对其他观察源进行打包处理，我将两个拥有不同长短的信息源，作为调用方，看看是否能影响输出，从实验的结果来看，是没有什么影响的。

  source1.zipWith(source3, BiFunction<String, Int, String> { le, num ->
            "$le is at num $num"
        }).subscribe { println("Print: $it") }
    source3.zipWith(source1, BiFunction<Int,String,String>{ letter, num ->
            "Front: $letter is at $num"
        }).subscribe { println("$it") }

zip集合interval

主要思路是一样的，只是现在带有interval的延迟功能，爽不爽！

val strings = Observable.just("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
val seconds = Observable.interval(1, TimeUnit.SECONDS)
Observable.zip(strings, seconds, BiFunction<String, Long, String> { letter, seconds ->
            "$letter is at $seconds"
        }).subscribe { println("$it : ${LocalTime.now()}") }
Thread.sleep(6000)

combine latest合并最后

和zip类似，都可以对信息源排队处理，但是这里只合并最后一个,当时需要注意的是，当时最后一个观察源时，会正常输出，而不是最后一个信息源，这可能就是合并最后的另一种表现吧

        var source1 = Observable.just("SADsd", "SDsdassd", "SDSDSD", "DSDSDS", "Sdsw", "aaaa")
        var source2 = Observable.just("BBBBBB", "CCCCCCCCCCC")
        val source3 = Observable.range(1, 6)
        Observable.combineLatest(source1, source2, source3, Function3<String, String, Int, String> { let, let2, num ->
            "$let --- $let2 is at num $num"
        }).subscribe { println(it) }
        Observable.combineLatest(source3, source2, source1, Function3<Int, String, String, String> { let, let2, num ->
            "$let --- $let2 is at num $num"
        }).subscribe { println(it) }

withLatestFrom

这是combine latest 的变种，调用者的信息源正常发送，被调用者只组合最后一个，来来来，看代码

  source1.withLatestFrom(source2, BiFunction<String, String, String> { s1, s2 ->
            "$s1 and $s2"
        }).subscribe { println(it) }
  /** 输出
        SADsd and CCCCCCCCCCC
        SDsdassd and CCCCCCCCCCC
        SDSDSD and CCCCCCCCCCC
        DSDSDS and CCCCCCCCCCC
        Sdsw and CCCCCCCCCCC
        aaaa and CCCCCCCCCCC
         **/

分组group

就是将观察源进行分组，相当分组打包在GroupedObservable中

  var source1 = Observable.just("SADsd", "SDsdassd", "SDSDSD", "DSDSDS", "Sdsw", "aaaa", "bbbb")
  var byLengths = source1.groupBy {
            it.length
        }
 byLengths.flatMapSingle { it.toList() }.subscribe { println(it) }
 /**打印
[Sdsw, aaaa, bbbb]
[SADsd]
[SDSDSD, DSDSDS]
[SDsdassd]
 */