Android 未完成的呼叫不整齐

我是Rx编程新手（到目前为止，我玩得很开心^^）。 我正在尝试将AsyncTask调用转换为Rx函数

我的职能：

• 获取所有已安装的应用程序
• 规范化标签
• 按字母顺序排序
• 按字母组排列（这是一个多重映射（字母，应用程序列表））并将结果传递给适配器以显示所有内容

以下是我到目前为止在Rx方面的表现：

Observable.from(getInstalledApps(getActivity(), false))
    .subscribeOn(Schedulers.newThread())
    .observeOn(AndroidSchedulers.mainThread())
    .map(new Func1<ResolvedActivityInfoWrapper, ResolvedActivityInfoWrapper>() {
      @Override
      public ResolvedActivityInfoWrapper call(ResolvedActivityInfoWrapper act) {
        // Normalize labels
act.setLabel(Normalizer.normalize(act.getLabel(getPackageManager()).replace(String.valueOf((char) 160), "").trim(), Normalizer.Form.NFD).replaceAll("\\p{M}", ""));
        return act;
      }
    })
    .toList()
    .subscribe(new Observer<List<ResolvedActivityInfoWrapper>>() {
      List<ResolvedActivityInfoWrapper> list;
      @Override
      public void onCompleted() {
        Observable.from(list).groupBy(new Func1<ResolvedActivityInfoWrapper, String>() {
          @Override
          public String call(ResolvedActivityInfoWrapper input) {
//Get groups by letter
            String label = input.getLabel(getPackageManager());
            if (!TextUtils.isEmpty(label)) {
              String firstChar = label.substring(0, 1);
              if (pattern.matcher(firstChar).matches()) {
                return firstChar.toUpperCase();
              }
            }
            return "#";
          }
        }).subscribe(this); // implementation below
      }

      @Override
      public void onError(Throwable e) {

      }

      @Override
      public void onNext(List<ResolvedActivityInfoWrapper> list) {
        Collections.sort(list, new Comparator<ActivityInfoWrapper>() {
          @Override
// Sort all the apps in the list, not sure it's a good way to do it
          public int compare(ActivityInfoWrapper info1, ActivityInfoWrapper info2) {
            return info1.getLabel(getPackageManager()).compareToIgnoreCase(info2.getLabel(getPackageManager()));
          }
        });
        this.list = list;
      }
    });

Observable.from（getInstalledApps（getActivity（），false））
.subscribeOn（Schedulers.newThread（））
.observeOn（AndroidSchedulers.mainThread（））
.map（新函数1（）{
@凌驾
公共ResolvedActivityInfoWrapper调用（ResolvedActivityInfoWrapper法案）{
//规范化标签
act.setLabel（Normalizer.normalize（act.getLabel（getPackageManager（））.replace（String.valueOf（（char）160），“”）.trim（），Normalizer.Form.NFD.replaceAll（\\p{M}，“”））；
回归法；
}
})
托利斯先生（）
.订阅（新观察员）{
名单；
@凌驾
未完成的公共无效（）{
可观察的.from（list）.groupBy（new Func1（）{
@凌驾
公共字符串调用（ResolvedActivityInfoWrapper输入）{
//通过信件获得团体
String label=input.getLabel（getPackageManager（））；
如果（！TextUtils.isEmpty（标签））{
String firstChar=label.substring（0,1）；
if（pattern.matcher（firstChar.matches（））{
返回firstChar.toUpperCase（）；
}
}
返回“#”；
}
}).订阅（此）；//下面的实现
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（列表）{
Collections.sort（list，newcomparator（）{
@凌驾
//对列表中的所有应用程序进行排序，但不确定这是否是一个好方法
公共int比较（ActivityInfoWrapper info1、ActivityInfoWrapper info2）{
返回info1.getLabel（getPackageManager（））.compareTignoreCase（info2.getLabel（getPackageManager（））；
}
});
this.list=列表；
}
});

一旦我按字母分组，完成后，我将订阅以下内容：

@Override
  public void onCompleted() {
//display the apps
}

  @Override
  public void onError(Throwable e) {

  }

  @Override
  public void onNext(GroupedObservable<String, ResolvedActivityInfoWrapper> input) {
//For each list of apps by letter i subscribe with an observer that will handle those apps (observer code below)
    input.subscribe(new TestObserver(input.getKey()));
  }

@覆盖
未完成的公共无效（）{
//显示应用程序
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（GroupedObservable输入）{
//对于每一个应用列表，我都会向一个负责处理这些应用的观察员订阅（观察员代码如下）
subscribe（新的TestObserver（input.getKey（））；
}

观察员：

private class TestObserver implements Observer<ResolvedActivityInfoWrapper> {

    List<ResolvedActivityInfoWrapper> list;
    String letter;

    public TestObserver(String letter) {
      list = new ArrayList<>();
      this.letter = letter;
    }

    @Override
    public void onCompleted() {
      adapter.addData(letter, list);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(ResolvedActivityInfoWrapper input) {
      list.add(input);
    }
}

私有类TestObserver实现了Observer{
名单；
字符串字母；
公共TestObserver（字符串字母）{
列表=新的ArrayList（）；
这个字母=字母；
}
@凌驾
未完成的公共无效（）{
adapter.addData（字母、列表）；
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（ResolvedActivityInFoWwrapper输入）{
列表。添加（输入）；
}
}

每件事都能正常工作，但有一个问题：观察者的未完成项调用顺序不正确。所以我得到了我所有的应用程序，按字母排序，但组的显示顺序不正确（先是C，然后是Y，然后是M等等…）

我猜代码中有很多错误，你能帮我解决这个问题吗？也许你能理解这一切是如何运作的

谢谢

更新： 按照评论部分的建议（谢谢大家），以下是我在规范标签后的尝试：

Observable.from(list).groupBy(new Func1<ResolvedActivityInfoWrapper, String>() {
          @Override
          public String call(ResolvedActivityInfoWrapper input) {
            String label = input.getLabel(getPackageManager());
            if (!TextUtils.isEmpty(label)) {
              String firstChar = label.substring(0, 1);
              if (pattern.matcher(firstChar).matches()) {
                return firstChar.toUpperCase();
              }
            }
            return "#";
          }
        })
            .toSortedList(new Func2<GroupedObservable<String, ResolvedActivityInfoWrapper>, GroupedObservable<String, ResolvedActivityInfoWrapper>, Integer>() {
              @Override
              public Integer call(GroupedObservable<String, ResolvedActivityInfoWrapper> obs1, GroupedObservable<String, ResolvedActivityInfoWrapper> obs2) {
                return obs1.getKey().compareToIgnoreCase(obs2.getKey());
              }
            })
            .subscribe(new Observer<List<GroupedObservable<String, ResolvedActivityInfoWrapper>>>() {
              @Override
              public void onCompleted() {

              }

              @Override
              public void onError(Throwable e) {

              }

              @Override
              public void onNext(List<GroupedObservable<String, ResolvedActivityInfoWrapper>> input) {
                String test = input.get(0).getKey();
              }
            });

Observable.from（list）.groupBy（new Func1（）{
@凌驾
公共字符串调用（ResolvedActivityInfoWrapper输入）{
String label=input.getLabel（getPackageManager（））；
如果（！TextUtils.isEmpty（标签））{
String firstChar=label.substring（0,1）；
if（pattern.matcher（firstChar.matches（））{
返回firstChar.toUpperCase（）；
}
}
返回“#”；
}
})
.toSortedList（新函数2（）{
@凌驾
公共整数调用（GroupedObservable obs1、GroupedObservable obs2）{
返回obs1.getKey（）；
}
})
.订阅（新观察员）{
@凌驾
未完成的公共无效（）{
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（列表输入）{
String test=input.get（0.getKey（）；
}
});

---

但它从未进入比较函数。

您正在排序，然后分组。你需要分组，然后排序。所以我想我应该在每次添加数据时在适配器中排序，因为我在onCompleted中没有所有的信息。我会试试看，但是一旦我得到所有未完成的数据，真的没有办法对它们进行排序吗？似乎执行了您希望的操作。除非您的groupBy函数抛出由于您没有在onError中执行任何操作而未被注意到的错误，否则上次更新应该可以运行。