RxJava 中的笛卡尔积

Question

是否可以在 rxjava 中获取两个可观察量的笛卡尔乘积？

像这样：

A -> 1,2,3
B -> a,b
A x B -> (1, a), (1, b), (2, a), (2, b), (3, a), (3, b)

Answer 1

你想要的是

，对于一个数字，产生与你有字母一样的对。因此，您可以使用map和flatMap运算符轻松实现这一点。

    Observable<Integer> number = Observable.from(Arrays.asList(1, 2, 3));
    Observable<String> letters = Observable.from(Arrays.asList("a", "b"));
    Observable<Pair> cartesian = number.flatMap((n) -> letters.map((l) -> new Pair(n, l)));

Answer 2

"加入"不是你要找的吗？

    Observable<Integer> a = Observable.fromArray(1, 2, 3);
    Observable<String>  b = Observable.fromArray("a", "b");
    Observable<?> left  = Observable.never();
    Observable<?> right = Observable.never();
    Observable<Pair<Integer, String>> pairs = a.join(b, (aa)->left, (bb)->right, (ai, bi)-> Pair.of(ai, bi));

Answer 3

这是笛卡尔映射的伪。

A  ->  Pair<A,"letter">  ->  C
B  ->  Pair<B,"number">  ->  D
Merge(C,D) -> lift(new CartesianOperator) -> Result  

笛卡尔运算符将存储数字列表和字符列表。

如果引入了独特的角色。您可以为唯一字符与记录数字列表的每个组合生成响应。然后，您将您的独特角色添加到包机列表中，然后重复该过程。

您可以对唯一数字执行相同的操作。

最后，您将能够发送类似 1,1,2,3 和 a，b，b 的内容，并接收类似 （a，1）（a，2）（a，3）（b，1）（b，2）（b，3） 之类的内容

编辑：

因此，这是一个快速且不可扩展的实现，可以正常工作。它需要一个对对象。

其中值 1 是您的"a"、"b"、"1"、"2"或"3"，以及值 2 是您的类型"（"数字"或"字符"）

它返回映射到数字的可观察字符对。

public class CartesianOperator implements Observable.Operator<Pair<String,String>,Pair<String,String>> {

@Override
public Subscriber<? super Pair<String, String>> call(final Subscriber<? super     Pair<String, String>> subscriber) {
return new Subscriber<Pair<String, String>>() {
  List<String> numbers;
  List<String> characters;
  @Override
  public void onCompleted() {
  }
  @Override
  public void onError(Throwable e) {
  }
  @Override
  public void onNext(Pair<String, String> stringStringPair) {
    if(stringStringPair.second == "number")
    {
      if(numbers.size() == 0)
      {
        numbers.add(stringStringPair.first);
      }
      else
      {
        if(numbers.contains(stringStringPair.first))
        {}
        else
        {
          for(String temp: characters)
          {
            //Return Every permutation of existing characters with new number
            subscriber.onNext( new Pair<String,String>(temp,stringStringPair.first));
          }
        }
      }
    }
    else // Assume vallue is a character
    {
      if(characters.size() == 0)
      {
        characters.add(stringStringPair.first);
      }
      else
      {
        if(characters.contains(stringStringPair.first))
        {}
        else
        {
          for(String temp: numbers)
          {
            //Return Every permutation of existing numbers with new character
            subscriber.onNext( new Pair<String,String>(stringStringPair.first,temp));
          }
        }
      } 
    }
  }
};
}
}

如果你不知道一对对象是什么，它本质上是一个封装另外两个对象的对象。

pairObject.first  

返回我的对的第一个对象

pairObject.second

返回我的对的第二个对象

我认为它现在已经弃用了。