按日期将事件列表分组到事件字典中

Question

我一直在努力学习RxJava2，我一直在为此苦苦挣扎。

因此，我有一个结构来表示如下所示的事件：

class Event{
public Date when;
public String eventName;
}

在某个地方，我从存储库中查询要按日期分组的事件列表。

因此，给定一个事件列表，例如：

• 活动1 六月
• 活动2 六月
• 活动3 七月
• 活动4 八月
• 活动5 八月

我想对它们进行分组，以便

• 六月
  • 事件1
  • 事件2
• 七月
  • 事件3
• 八月
  • 事件4
  • 活动5

到目前为止，在我看来，我所拥有的是非常丑陋的，我很确定我过度"工程"了这个......

repository.getAllEvents()
.toObservable()
.flatMap(new Function<Events, Observable<Event>>() {
@Override
public Observable<Event> apply(@NonNull Events events) throws Exception {
return Observable.fromIterable(events.getEvents());
}
})
.groupBy(new Function<Event, Date>() {
@Override
public Date apply(@NonNull Event event) throws Exception {
return event.when;
}
})
.flatMap(new Function<GroupedObservable<Date, Event>, Observable<Object>>() {
@Override
public Observable<Object> apply(@NonNull GroupedObservable<Date, Event> dateEventGroupedObservable) throws Exception {
final Date key = dateEventGroupedObservable.getKey();
return dateEventGroupedObservable.toList().toObservable().flatMap(new Function<List<Event>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull List<Event> events) throws Exception {
return Observable.just(new Pair<Date, List<Event>>(key, events));
}
});
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Object o) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});

到目前为止，这给了我一个提供 Pair 的可观察量>但正如你所看到的，它被转换为 Object，老实说，我无法理解泛型地狱-.-">

关于我如何处理这个问题的任何提示？

谢谢

Answer 1

您只需使用运算符即可实现collect：

repository.getAllEvents()
.flatMapIterable(events -> events.getEvents())
.collect(() -> new HashMap<Date, List<Event>>(), 
(map, event) -> putEventIntoMap(map, event)
)
...

没有λ：

// I assume that getAllEvents returns Events class
repository.getAllEvents()
.flatMapIterable(new Function<Events, Iterable<? extends Event>>() {
@Override
public Iterable<? extends Event> apply(@NonNull Events events) throws Exception {
return events.getEvents();
}
})
.collect(new Callable<HashMap<Date, List<Event>>>() {
@Override
public HashMap<Date, List<Event>> call() throws Exception {
return new HashMap<Date, List<Event>>();
}}, new BiConsumer<HashMap<Date, List<Event>>, Event>() {
@Override
public void accept(@NonNull HashMap<Date, List<Event>> map, @NonNull Event event) throws Exception {
putEventIntoMap(map, event);
}}
)
...

将事件放入地图的方法：

private void putEventIntoMap(HashMap<Date, List<Event>> map, Event event) {
if (map.containsKey(event.when)) {
map.get(event.when).add(event);
} else {
List<Event> list = new ArrayList<>();
list.add(event);
map.put(event.when, list);
}
}

Answer 2

根据奥斯特罗维多夫@Maxim答案，我能够将其改编为以下工作解决方案：

repository.getAllEvents()
// Convert the Single<Events> into an Observable<Events>
.toObservable()
// Transform the stream Events into a List<Event> stream / observable
.flatMapIterable(new Function<Events, List<Event>>() {
@Override
public List<Event> apply(@NonNull Events events) throws Exception {
return events.getEvents();
}
})
// Group each Event from the List<Event> by when (date)
.groupBy(new Function<Event, Date>() {
@Override
public Date apply(@NonNull Event event) throws Exception {
return event.when;
}
})
// For each grouped stream (not sure if its correct to call it like this)
// Lets generate a new stream that is a Pair<Date, List<Event>>
.flatMap(new Function<GroupedObservable<Date, Event>, Observable<Pair<Date, List<Event>>>>() {
@Override
public Observable<Pair<Date, List<Event>>> apply(@NonNull GroupedObservable<Date, Event> dateEventGroupedObservable) throws Exception {
final Date key = dateEventGroupedObservable.getKey();
// toList() takes a big role here since it is forcing 
// for the dateEventGroupedObservable to complete and only then 
// streaming a Single<List<Event>> which is why I convert it back to observable
return dateEventGroupedObservable.toList().toObservable().flatMap(new Function<List<Event>, Observable<Pair<Date, List<Event>>>>() {
@Override
public Observable<Pair<Date, List<Event>>> apply(@NonNull List<Event> events) throws Exception {
return Observable.just(new Pair<Date, List<Event>>(key, events));
}
});
}
})
// We can now collect all streamed pairs of (Date, List<Event>) 
// into an HashMap
.collect(new Callable<HashMap<Date, List<Event>>>() {
@Override
public HashMap<Date, List<Event>> call() throws Exception {
return new HashMap<Date, List<Event>>();
}
}, new BiConsumer<HashMap<Date, List<Event>>, Pair<Date, List<Event>>>() {
@Override
public void accept(@NonNull HashMap<Date, List<Event>> dateListHashMap, @NonNull Pair<Date, List<Event>> dateListPair) throws Exception {
dateListHashMap.put(dateListPair.first, new ArrayList<Event>(dateListPair.second));
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new SingleObserver<HashMap<Date, List<Event>>>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onSuccess(HashMap<Date, List<Event>> dateListHashMap) {
}
@Override
public void onError(Throwable e) {
}
});

是的，它很长而且很丑，但我很确定有了 lambdas，这看起来会更好。现在，问题是...这段代码用于馈送回收器视图适配器，所以我想知道以命令式方式简单地做到这一点是否更容易......哦，好吧，服务于学习目的:)