回顾RxJava中的链 Random rand=new Random（）； Observable random1=Observable.just（rand.nextInt（））； Observable random2=random1.flatMap（r1->Observable.just（r1*rand.nextInt（））； 2.订阅（System.out:：println）；

上面的代码只是取几个随机数，将它们相乘，然后打印输出

我的问题是：在我打印结果的时候，有没有一种优雅的方法可以获得第一个随机值？请注意，我的实际系统正在进行异步调用，而不仅仅是生成随机数

下面是一些我不认为优雅的例子：

Random rand = new Random();
Observable<Integer> random1 = Observable.just(rand.nextInt());
Observable<Integer> random2 = random1.flatMap(r1->Observable.just(r1 * rand.nextInt()));
random2.subscribe(System.out::println);

Random rand=new Random（）；
Observable random1=Observable.just（rand.nextInt（））；
随机1.订阅（r1->{
Observable random2=Observable.just（r1*rand.nextInt（））；
2.订阅（r2->{
系统输出打印项次（r1）；
系统输出打印项次（r2）；
});
});

Random rand=new Random（）；
Observable random1=Observable.just（rand.nextInt（））；
可观察结果=随机1.平面图（r1->{
int[]对=新的int[2]；
对[0]=r1；
pair[1]=r1*rand.nextInt（）；
可观察的返回。仅（对）；
});
结果：订阅（配对->{
System.out.println（对[0]）；
System.out.println（对[1]）；
});

Random rand=new Random（）；
int[]hack=newint[1]；
Observable random1=Observable.just（rand.nextInt（））.doOnNext（r1->hack[0]=r1）；
Observable random2=random1.flatMap（r1->Observable.just（r1*rand.nextInt（））；
2.订阅（r2->{
System.out.println（hack[0]）；
系统输出打印项次（r2）；
});

最后，还有一点，我不确定这是否是好的做法：

Random rand = new Random();
int[] hack = new int[1];
Observable<Integer> random1 = Observable.just(rand.nextInt()).doOnNext(r1->hack[0]=r1);
Observable<Integer> random2 = random1.flatMap(r1->Observable.just(r1 * rand.nextInt()));
random2.subscribe(r2->{
  System.out.println(hack[0]);
  System.out.println(r2);
});

Random rand=new Random（）；
Observable random1=Observable.just（rand.nextInt（））；
Observable random2=random1.flatMap（r1->Observable.just（r1*rand.nextInt（））；
random2.subscribe（r2->System.out.println（random1.toBlocking（）.first（））；

简短回答：否

您最干净的选项可能是构建一个类来“包装”您的输入并沿链传递它（或者使用某种元组类）

第三个示例中，传递的

int[]

对是最接近的：

Random rand = new Random();
Observable<Integer> random1 = Observable.just(rand.nextInt());
Observable<Integer> random2 = random1.flatMap(r1->Observable.just(r1 * rand.nextInt()));
random2.subscribe(r2-> System.out.println(random1.toBlocking().first()));

---

与此类似，值得一看——它似乎表明您的第一种方法（嵌套可观察对象以访问外部可观察对象输入）是最好的。但是，如果您关心的链上有多个级别，那么这可能会导致一些相当深的嵌套。

zip操作符如何

Random rand = new Random();
Observable.just(rand.nextInt())
  .flatMap(r1->{
    int[] pair = new int[2];
    pair[0] = r1;
    pair[1] = r1 * rand.nextInt();
    return Observable.just(pair);
  })
  .subscribe(pair-> {
    System.out.println(pair[0]);
    System.out.println(pair[1]);
  });

Random rand=new Random（）；
Observable random1=Observable.just（rand.nextInt（））；
Observable random2=Observable.just（rand.nextInt（））；
random1.zipWith（random2，Pair:：new）.subscribe（System.out:：println）；

有一个

flatMap

重载，允许您指定一个Func2，该Func2接收源值以及从被展平的可观察对象获取的每个值：

Random rand = new Random();
Observable<Integer> random1 = Observable.just(rand.nextInt());
Observable<Integer> random2 = Observable.just(rand.nextInt());

random1.zipWith(random2, Pair::new).subscribe(System.out::println);

Random rand=new Random（）；
Observable random1=Observable.just（rand.nextInt（））；
可观测随机数2=随机数1.2(
r1->Observable.just（r1*rand.nextInt（）），
（r1，r2）->Arrays.asList（r1，r2））；
2.订阅（System.out:：println）；

在本例中，两个随机数不相乘。我之所以包括它，是因为我的实际用例有第二个可观察的对象，这取决于第一个和其余部分应该可以编译。我在RxJava2中找不到这个版本的

flatMap

，请链接Javadoc好吗？

Random rand = new Random();
Observable.just(rand.nextInt())
  .flatMap(r1->{
    int[] pair = new int[2];
    pair[0] = r1;
    pair[1] = r1 * rand.nextInt();
    return Observable.just(pair);
  })
  .subscribe(pair-> {
    System.out.println(pair[0]);
    System.out.println(pair[1]);
  });

Random rand = new Random();
Observable<Integer> random1 = Observable.just(rand.nextInt());
Observable<Integer> random2 = Observable.just(rand.nextInt());

random1.zipWith(random2, Pair::new).subscribe(System.out::println);

Random rand = new Random();
Observable<Integer> random1 = Observable.just(rand.nextInt());
Observable<List<Integer>> random2 = random1.flatMap(
    r1 -> Observable.just(r1 * rand.nextInt()),
    (r1, r2) -> Arrays.asList(r1, r2));

random2.subscribe(System.out::println);