.groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.toList(); .groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.take(10).toList(); .groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.filter(i -> i <= 20).toList(); .groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.take(20).toList(); .groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.takeWhile(i -> i < 30).toList(); .groupBy(n -> n) .flatMap(g -> { return g.take(3).reduce((s, s2) -> s + s2); .groupBy(n -> n % 2 == 0) .flatMap(g -> { return g.take(10).toList(); .groupBy(n -> n % 2 == 0)
@Override public Observable<GroupedObservable<K, R>> call(Observable<T> o) { return o.groupBy(keySelector, elementSelector, evictingMapFactory); } };
@Override public Observable<GroupedObservable<K, R>> call(Observable<T> o) { return o.groupBy(keySelector, elementSelector, evictingMapFactory); } };
private static Observable<Object> sampleModifyOrOverflowEventsOnly(Observable<?> events, final long sampleTimeMs) { return events // group by true if is modify or overflow, false otherwise .groupBy(IS_MODIFY_OR_OVERFLOW) // only sample if is modify or overflow .flatMap(sampleIfTrue(sampleTimeMs)); }
public static void main(String[] args) throws Exception { Observable<Integer> source = range(1, 10000); source .doOnRequest(i -> System.out.println("Requested " + i)) .groupBy(v -> v % 5) .flatMap(g -> g.observeOn(Schedulers.io()).map(GroupByTest2::calculation), 4) .subscribe(i -> System.out.println("Got " + i)); Thread.sleep(100000); }
@Override public void run() { Observable.range(1, 10).groupBy(new Func1<Integer, String>() { @Override public String call(Integer integer) { return (integer % 2 == 0) ? "even" : "odd"; } }).subscribe(new Action1<GroupedObservable<String, Integer>>() { @Override public void call(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) { log("group ok:" + stringIntegerGroupedObservable.getKey()); stringIntegerGroupedObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { log(integer + " of group " + stringIntegerGroupedObservable.getKey()); } }); } }); } });
@Override public Observable<Map<String, TaggedBucketPoint>> call(Observable<DataPoint<? extends Number>> dataPoints) { Predicate<DataPoint<? extends Number>> filter = dataPoint -> true; for (Entry<String, String> entry : tags.entrySet()) { boolean positive = (!entry.getValue().startsWith("!")); Pattern pattern = filterPattern(entry.getValue()); filter = filter.and(dataPoint -> { return dataPoint.getTags().containsKey(entry.getKey()) && (positive == pattern.matcher(dataPoint.getTags().get(entry.getKey())).matches()); }); } return dataPoints .filter(filter::test) .groupBy(dataPoint -> tags.entrySet().stream().collect( toMap(Entry::getKey, e -> dataPoint.getTags().get(e.getKey())))) .flatMap(group -> group.collect(() -> new TaggedDataPointCollector(group.getKey(), percentiles), TaggedDataPointCollector::increment)) .map(TaggedDataPointCollector::toBucketPoint) .toMap(bucketPoint -> bucketPoint.getTags().entrySet().stream().map(e -> e.getKey() + ":" + e.getValue()).collect(joining(","))); } }
public static Observable<List<Fix>> writeFixes(final Func1<Fix, String> fileMapper, Observable<Fix> fixes, int bufferSize, boolean zip, BinaryFixesFormat format) { return fixes // group by filename .groupBy(fileMapper) // buffer fixes by filename .flatMap(buffer(bufferSize)) // write each list to a file .doOnNext(writeFixList(fileMapper, zip, format)); }
@Override public Observable<List<NumericBucketPoint>> call(Observable<DataPoint<? extends Number>> dataPoints) { return dataPoints .groupBy(dataPoint -> buckets.getIndex(dataPoint.getTimestamp())) .flatMap(group -> group.collect(() -> new NumericDataPointCollector(buckets, group.getKey(), percentiles), NumericDataPointCollector::increment)) .map(NumericDataPointCollector::toBucketPoint) .toMap(NumericBucketPoint::getStart) .map(pointMap -> NumericBucketPoint.toList(pointMap, buckets)); } }
@Override public Observable<List<NumericBucketPoint>> call(Observable<DataPoint<? extends Number>> dataPoints) { return dataPoints .groupBy(dataPoint -> buckets.getIndex(dataPoint.getTimestamp())) .flatMap(group -> group.collect(() -> new NumericDataPointCollector(buckets, group.getKey(), percentiles), NumericDataPointCollector::increment)) .map(NumericDataPointCollector::toBucketPoint) .toMap(NumericBucketPoint::getStart) .map(pointMap -> NumericBucketPoint.toList(pointMap, buckets)); } }
@Override public Observable<List<AvailabilityBucketPoint>> findAvailabilityStats(MetricId<AvailabilityType> metricId, long start, long end, Buckets buckets) { checkArgument(isValidTimeRange(start, end), "Invalid time range"); return this.findDataPoints(metricId, start, end, 0, ASC) .groupBy(dataPoint -> buckets.getIndex(dataPoint.getTimestamp())) .flatMap(group -> group.collect(() -> new AvailabilityDataPointCollector(buckets, group.getKey()), AvailabilityDataPointCollector::increment)) .map(AvailabilityDataPointCollector::toBucketPoint) .toMap(AvailabilityBucketPoint::getStart) .map(pointMap -> AvailabilityBucketPoint.toList(pointMap, buckets)); }
@Override public Observable<List<AvailabilityBucketPoint>> findAvailabilityStats(MetricId<AvailabilityType> metricId, long start, long end, Buckets buckets) { checkArgument(isValidTimeRange(start, end), "Invalid time range"); return this.findDataPoints(metricId, start, end, 0, ASC) .groupBy(dataPoint -> buckets.getIndex(dataPoint.getTimestamp())) .flatMap(group -> group.collect(() -> new AvailabilityDataPointCollector(buckets, group.getKey()), AvailabilityDataPointCollector::increment)) .map(AvailabilityDataPointCollector::toBucketPoint) .toMap(AvailabilityBucketPoint::getStart) .map(pointMap -> AvailabilityBucketPoint.toList(pointMap, buckets)); }
public static void main(String[] args) { Observable<String> names = Observable.just( "John", "Steve", "Ruth", "Sam", "Jane", "James"); names.groupBy(s -> s.charAt(0)) .flatMap(grp -> grp.publish(o -> o.first().concatWith(o.ignoreElements()))) .subscribe(s -> System.out.println(s)); } }
public static void main(String[] args) { System.setProperty("rx.ring-buffer.size", "16"); List<AppInfo> list = new ArrayList<>(); for (int i = 0; i < 10; i++) { for (int j = 0; j < 3; j++) { AppInfo ai = new AppInfo(); ai.name = i + " - " + j; ai.date = LocalDate.of(2016, 3, i + 1); list.add(ai); } } Observable<GroupedObservable<String, AppInfo>> o = Observable.from(list) .groupBy(v -> v.date.format(DateTimeFormatter.ofPattern("MM/yyyy"))); Observable.concat(o) .subscribe(System.out::println); } }
private Observable.Transformer<BoundStatement, Integer> applyMicroBatching() { return tObservable -> tObservable .groupBy(b -> { ByteBuffer routingKey = b.getRoutingKey(ProtocolVersion.NEWEST_SUPPORTED, codecRegistry); Token token = metadata.newToken(routingKey); for (TokenRange tokenRange : session.getCluster().getMetadata().getTokenRanges()) { if (tokenRange.contains(token)) { return tokenRange; } } log.warn("Unable to find any Cassandra node to insert token " + token.toString()); return session.getCluster().getMetadata().getTokenRanges().iterator().next(); }) .flatMap(g -> g.compose(new BoundBatchStatementTransformer())) .flatMap(batch -> rxSession .execute(batch) .compose(applyInsertRetryPolicy()) .map(resultSet -> batch.size()) ); }
@Test public void sample_157() throws Exception { Observable<BigDecimal> totalPrice = Observable .just("bread", "butter", "egg", "milk", "tomato", "cheese", "tomato", "egg", "egg") .groupBy(prod -> prod) .flatMap(grouped -> grouped .count() .map(quantity -> { String productName = grouped.getKey(); return Pair.of(productName, quantity); })) .flatMap(order -> rxGroceries .purchase(order.getKey(), order.getValue()) .subscribeOn(schedulerA)) .reduce(BigDecimal::add) .single(); }
@Override public void exitObject(ObjectContext ctx) { if (ctx.logical_operator() != null) { Observable<MetricId<T>> leftObservable = popObservable(ctx.object(0).getText().hashCode()); Observable<MetricId<T>> rightObservable = popObservable(ctx.object(1).getText().hashCode()); observables.remove(ctx.object(0).getText().hashCode()); observables.remove(ctx.object(1).getText().hashCode()); Observable<MetricId<T>> result = leftObservable.concatWith(rightObservable); if (ctx.logical_operator().AND() != null) { //group by metric and then use one element from the groups with two elements //if a group has two elements it is in both sets, hence AND result = result .groupBy(m -> m) .flatMap(s -> s.skip(1).take(1)); } else if (ctx.logical_operator().OR() != null) { result = result.distinct(); } pushObservable(ctx.getText().hashCode(), result); } else { if (ctx.object(0) != null && ctx.object(0).getText().hashCode() != ctx.getText().hashCode()) { Observable<MetricId<T>> expressionObservable = popObservable(ctx.object(0).getText().hashCode()); observables.remove(ctx.object(0).getText().hashCode()); pushObservable(ctx.getText().hashCode(), expressionObservable); } } };
@Test public void sample_52() throws Exception { FactStore factStore = new CassandraFactStore(); Observable<ReservationEvent> facts = factStore.observe(); Observable<GroupedObservable<UUID, ReservationEvent>> grouped = facts.groupBy(ReservationEvent::getReservationUuid); grouped.subscribe(byUuid -> { byUuid.subscribe(this::updateProjection); }); }
@Test public void test1() { rx.Observable.range(1, 20) .groupBy(v -> v % 3) .concatMap(g -> g.toList()) .toList() .subscribe(System.out::println); }
@Test public void so() throws Exception { rx.Observable .defer(() -> rx.Observable.from(longTimeFunc())) .doOnNext(strings -> sout("RX_TAG_FIRST", Arrays.toString(strings))) .groupBy(rows -> rows[0]) .doOnNext(groupedObservable -> sout("RX_TAG_TWO", groupedObservable.getKey())) .concatMap(group -> group.collect(Shop::new, (shop, rows) -> { shop.id = Integer.parseInt(rows[0]); shop.name = rows[1]; shop.coordinates.add(new Coordinate(rows[2], rows[3])); })) .doOnNext(shop -> sout("RX_TAG_THREE", String.valueOf(shop))) .toList() .doOnNext(shops -> sout("RX_TAG_FOUR", String.valueOf(shops))) .subscribeOn(Schedulers.io()) .observeOn(Schedulers.computation()) .subscribe(shops -> sout("RX_TAG_SUBSCRIBE", String.valueOf(shops))); Thread.sleep(1000); } }