public <K> FlowGrouping<K, B, B, FlowGroup<K, B>> groupBy(final Mapper<? super B, K> toKey) { return groupBy(toKey, Flow.<K, FlowGroup<K, B>>hashMapSupplier()); }
public <K, V> FlowToMap<K, V, FlowGroup<K, B>> toMap(Supplier<Map<K, FlowGroup<K, B>>> groupMapSupplier, Mapper<B, K> toKey, Mapper<FlowGroup<K, B>, V> toValue) { return groupBy(toKey, groupMapSupplier).toMap(toValue); }
public <K, V> FlowToMap<K, V, FlowGroup<K, B>> toMap(Supplier<Map<K, FlowGroup<K, B>>> groupMapSupplier, Mapper<B, K> toKey, Mapper<FlowGroup<K, B>, V> toValue) { return groupBy(toKey, groupMapSupplier).toMap(toValue); }
public <K> FlowGrouping<K, B, B, FlowGroup<K, B>> groupBy(final Mapper<? super B, K> toKey) { return groupBy(toKey, Flow.<K, FlowGroup<K, B>>hashMapSupplier()); }
@Test public void test_toMap_2() { Map<Boolean, List<Integer>> map = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .toMap() .get(); Assert.assertEquals(2, map.size()); Assert.assertEquals(1, map.get(true).size()); Assert.assertEquals(Integer.valueOf(2), map.get(true).get(0)); Assert.assertEquals(2, map.get(false).size()); Assert.assertEquals(Integer.valueOf(1), map.get(false).get(0)); Assert.assertEquals(Integer.valueOf(3), map.get(false).get(1)); }
@Test public void test_each_2() { final AtomicInteger counter = new AtomicInteger(); Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .each(new Consumer<FlowGroup<Boolean, Integer>>() { @Override public void consume(FlowGroup<Boolean, Integer> group) { counter.incrementAndGet(); } }).execute(); Assert.assertEquals(2, counter.get()); }
@Test public void test_merge() { List<Integer> result = Flow.of(1, 2, 3, 4, 5, 6) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .merge() .toList() .get(); Assert.assertEquals(6, result.size()); Assert.assertEquals(Integer.valueOf(1), result.get(0)); Assert.assertEquals(Integer.valueOf(2), result.get(1)); Assert.assertEquals(Integer.valueOf(3), result.get(2)); Assert.assertEquals(Integer.valueOf(4), result.get(3)); Assert.assertEquals(Integer.valueOf(5), result.get(4)); Assert.assertEquals(Integer.valueOf(6), result.get(5)); }
@Test public void test_flatMap_2() { ArrayList<Integer> integers = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer it) { return it % 2 == 0; } }) .flatMap(new Mapper<FlowGroup<Boolean, Integer>, Flow<Integer>>() { @Override public Flow<Integer> map(final FlowGroup<Boolean, Integer> group) { return group; } }) .toList().get(); Assert.assertEquals(3, integers.size()); Assert.assertEquals(Integer.valueOf(1), integers.get(0)); Assert.assertEquals(Integer.valueOf(2), integers.get(1)); Assert.assertEquals(Integer.valueOf(3), integers.get(2)); }
@Test public void test_each_with_index_2() { final StringBuilder sb = new StringBuilder(); Flow.of(2, 4, 6) .groupBy(new Mapper<Integer, Integer>() { @Override public Integer map(Integer integer) { return integer; } }) .each(new ConsumerWithInt<FlowGroup<Integer, Integer>>() { @Override public void consume(int i, FlowGroup<Integer, Integer> integerIntegerFlowGroup) { if (sb.length() != 0) sb.append(", "); sb.append(i); } }) .execute(); Assert.assertEquals("0, 1, 2", sb.toString()); }
@Test public void test_grouping_1() { List<ArrayList<Integer>> result = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer it) { return it % 2 == 0; } }) .flatMap(new Mapper<FlowGroup<Boolean, Integer>, FlowProcessOnEnd<?, ArrayList<Integer>>>() { @Override public FlowProcessOnEnd<?, ArrayList<Integer>> map(FlowGroup<Boolean, Integer> group) { return group.toList(); } }) .toSortedList(new Comparator<List<Integer>>() { @Override public int compare(List<Integer> o1, List<Integer> o2) { return o1.size() < o2.size() ? -1 : (o1.size() == o2.size() ? 0 : 1); } }).get(); Assert.assertEquals(2, result.size()); Assert.assertEquals(1, result.get(0).size()); Assert.assertEquals(Integer.valueOf(2), result.get(0).get(0)); Assert.assertEquals(2, result.get(1).size()); Assert.assertEquals(Integer.valueOf(1), result.get(1).get(0)); Assert.assertEquals(Integer.valueOf(3), result.get(1).get(1)); }
@Test public void test_grouping_3() { List<Integer> result = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer it) { return it % 2 == 0; } }) .flatMap(new Mapper<FlowGroup<Boolean, Integer>, FlowProcessOnEnd<?, Integer>>() { @Override public FlowProcessOnEnd<?, Integer> map(FlowGroup<Boolean, Integer> group) { return group.first(); } }) .toSortedList() .get(); Assert.assertEquals(2, result.size()); Assert.assertEquals(Integer.valueOf(1), result.get(0)); Assert.assertEquals(Integer.valueOf(2), result.get(1)); }
final Map<Boolean, AtomicInteger> counters = new HashMap<Boolean, AtomicInteger>(); Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer it) {
@Test public void test_each_3() { final AtomicInteger counter = new AtomicInteger(); Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .each(new Consumer<FlowGroup<Boolean, Integer>>() { @Override public void consume(FlowGroup<Boolean, Integer> group) { counter.incrementAndGet(); } }) .first() .get(); Assert.assertEquals(1, counter.get()); }
@Test public void test_toMap_3() { Map<Boolean, List<Integer>> map = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .filter(new Filter<FlowGroup<Boolean, Integer>>() { @Override public boolean allow(FlowGroup<Boolean, Integer> group) { return group.getKey(); } }) .toMap() .get(); Assert.assertEquals(1, map.size()); Assert.assertEquals(1, map.get(true).size()); Assert.assertEquals(Integer.valueOf(2), map.get(true).get(0)); }
@Test public void test_each_with_index_4() { final StringBuilder sb = new StringBuilder(); Flow.of(2, 4, 6) .groupBy(new Mapper<Integer, Integer>() { @Override public Integer map(Integer integer) { return integer; } }) .each(new ConsumerWithInt<FlowGroup<Integer, Integer>>() { @Override public void consume(int i, FlowGroup<Integer, Integer> integerIntegerFlowGroup) { if (sb.length() != 0) sb.append(", "); sb.append(i); } }) .first() .get(); Assert.assertEquals("0", sb.toString()); }
@Test public void test_limit_3() { Assert.assertEquals("{1=[1], 2=[2], 3=[3]}", Flow.of(1, 2, 3, 4, 5) .groupBy(new Mapper<Integer, Integer>() { @Override public Integer map(Integer integer) { return integer; } }) .limit(3) .toMap() .get() .toString() ); }
@Test public void test_grouping_4() { final AtomicInteger counter = new AtomicInteger(); Integer result = Flow.of(1, 2, 3) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer it) { counter.incrementAndGet(); return it % 2 == 0; } }) .flatMap(new Mapper<FlowGroup<Boolean, Integer>, FlowProcessOnEnd<?, Integer>>() { @Override public FlowProcessOnEnd<?, Integer> map(FlowGroup<Boolean, Integer> group) { return group.first(); } }) .first() .get(); Assert.assertEquals(Integer.valueOf(1), result); Assert.assertEquals(1, counter.get()); }
@Test public void test_merge_2() { List<Integer> result = Flow.of(1, 2, 3, 4, 5, 6) .groupBy(new Mapper<Integer, Boolean>() { @Override public Boolean map(Integer integer) { return integer % 2 == 0; } }) .filter(new Filter<FlowGroup<Boolean, Integer>>() { @Override public boolean allow(FlowGroup<Boolean, Integer> group) { return group.getKey(); } }) .merge() .toList() .get(); Assert.assertEquals(3, result.size()); Assert.assertEquals(Integer.valueOf(2), result.get(0)); Assert.assertEquals(Integer.valueOf(4), result.get(1)); Assert.assertEquals(Integer.valueOf(6), result.get(2)); }
@Test public void test_skip_2() { Assert.assertEquals("3,4,5", Flow.of(1, 2, 3, 4, 5) .groupBy(new Mapper<Integer, Integer>() { @Override public Integer map(Integer integer) { return integer; } }) .skip(2) .map(new Mapper<FlowGroup<Integer, Integer>, Integer>() { @Override public Integer map(FlowGroup<Integer, Integer> group) { return group.key; } }) .join(",") .get()); }
@Test public void test_limit_2() { Assert.assertEquals("1,2,3", Flow.of(1, 2, 3, 4, 5) .groupBy(new Mapper<Integer, Integer>() { @Override public Integer map(Integer integer) { return integer; } }) .limit(3) .map(new Mapper<FlowGroup<Integer, Integer>, Integer>() { @Override public Integer map(FlowGroup<Integer, Integer> group) { return group.key; } }) .join(",") .get()); }