@Test
public void testGroupingByWithDomain() {
List<String> data = Arrays.asList("a", "foo", "test", "ququq", "bar", "blahblah");
Collector<String, ?, String> collector =
MoreCollectors.collectingAndThen(
MoreCollectors.groupingBy(
String::length,
IntStreamEx.range(10).boxed().toSet(),
TreeMap::new,
MoreCollectors.first()),
Object::toString);
checkShortCircuitCollector(
"groupingWithDomain",
"{0=Optional.empty, 1=Optional[a], 2=Optional.empty, 3=Optional[foo], 4=Optional[test], 5=Optional[ququq], "
+ "6=Optional.empty, 7=Optional.empty, 8=Optional[blahblah], 9=Optional.empty}",
data.size(),
data::stream,
collector);
Map<String, String> name2sex = new LinkedHashMap<>();
name2sex.put("Mary", "Girl");
name2sex.put("John", "Boy");
name2sex.put("James", "Boy");
name2sex.put("Lucie", "Girl");
name2sex.put("Fred", "Boy");
name2sex.put("Thomas", "Boy");
name2sex.put("Jane", "Girl");
name2sex.put("Ruth", "Girl");
name2sex.put("Melanie", "Girl");
Collector<Entry<String, String>, ?, Map<String, List<String>>> groupingBy =
MoreCollectors.groupingBy(
Entry::getValue,
StreamEx.of("Girl", "Boy").toSet(),
MoreCollectors.mapping(Entry::getKey, MoreCollectors.head(2)));
AtomicInteger counter = new AtomicInteger();
Map<String, List<String>> map =
EntryStream.of(name2sex).peek(c -> counter.incrementAndGet()).collect(groupingBy);
assertEquals(Arrays.asList("Mary", "Lucie"), map.get("Girl"));
assertEquals(Arrays.asList("John", "James"), map.get("Boy"));
assertEquals(4, counter.get());
Collector<Entry<String, String>, ?, Map<String, String>> groupingByJoin =
MoreCollectors.groupingBy(
Entry::getValue,
StreamEx.of("Girl", "Boy").toSet(),
MoreCollectors.mapping(
Entry::getKey, Joining.with(", ").maxChars(16).cutAfterDelimiter()));
counter.set(0);
Map<String, String> mapJoin =
EntryStream.of(name2sex).peek(c -> counter.incrementAndGet()).collect(groupingByJoin);
assertEquals("Mary, Lucie, ...", mapJoin.get("Girl"));
assertEquals("John, James, ...", mapJoin.get("Boy"));
assertEquals(7, counter.get());
}
@Test
public void testAndInt() {
List<Integer> ints = Arrays.asList(0b1100, 0b0110, 0b101110, 0b11110011);
Collector<Integer, ?, OptionalInt> collector = MoreCollectors.andingInt(Integer::intValue);
checkShortCircuitCollector("andInt", OptionalInt.of(0), 4, ints::stream, collector);
checkCollectorEmpty("andIntEmpty", OptionalInt.empty(), collector);
assertEquals(
OptionalInt.of(0),
IntStreamEx.iterate(16384, i -> i + 1).parallel().boxed().collect(collector));
assertEquals(
OptionalInt.of(16384),
IntStreamEx.iterate(16384, i -> i + 1).parallel().limit(16383).boxed().collect(collector));
Collector<Integer, ?, Integer> unwrapped =
MoreCollectors.collectingAndThen(
MoreCollectors.andingInt(Integer::intValue), OptionalInt::getAsInt);
assertTrue(unwrapped.characteristics().contains(Characteristics.UNORDERED));
checkShortCircuitCollector("andIntUnwrapped", 0, 4, ints::stream, unwrapped);
checkShortCircuitCollector(
"andIntUnwrapped", 0, 2, Arrays.asList(0x1, 0x10, 0x100)::stream, unwrapped);
}
@Test
public void testFlatMapping() {
{
Map<Integer, List<Integer>> expected =
IntStreamEx.rangeClosed(1, 100)
.boxed()
.toMap(x -> IntStreamEx.rangeClosed(1, x).boxed().toList());
Collector<Integer, ?, Map<Integer, List<Integer>>> groupingBy =
Collectors.groupingBy(
Function.identity(),
MoreCollectors.flatMapping(
x -> IntStream.rangeClosed(1, x).boxed(), Collectors.toList()));
checkCollector(
"flatMappingSimple", expected, () -> IntStreamEx.rangeClosed(1, 100).boxed(), groupingBy);
}
Function<Entry<String, List<String>>, Stream<String>> valuesStream =
e -> e.getValue() == null ? null : e.getValue().stream();
List<Entry<String, List<String>>> list =
EntryStream.of(
"a", Arrays.asList("bb", "cc", "dd"), "b", Arrays.asList("ee", "ff"), "c", null)
.append("c", Arrays.asList("gg"), "b", null, "a", Arrays.asList("hh"))
.toList();
{
Map<String, List<String>> expected =
EntryStream.of(list.stream())
.flatMapValues(l -> l == null ? null : l.stream())
.grouping();
checkCollector(
"flatMappingCombine",
expected,
list::stream,
Collectors.groupingBy(
Entry::getKey, MoreCollectors.flatMapping(valuesStream, Collectors.toList())));
AtomicInteger openClose = new AtomicInteger();
Collector<Entry<String, List<String>>, ?, Map<String, List<String>>> groupingBy =
Collectors.groupingBy(
Entry::getKey,
MoreCollectors.flatMapping(
valuesStream.andThen(
s -> {
if (s == null) return null;
openClose.incrementAndGet();
return s.onClose(openClose::decrementAndGet);
}),
Collectors.toList()));
checkCollector(
"flatMappingCombineClosed",
expected,
list::stream,
MoreCollectors.collectingAndThen(
groupingBy,
res -> {
assertEquals(0, openClose.get());
return res;
}));
boolean catched = false;
try {
Collector<Entry<String, List<String>>, ?, Map<String, List<String>>> groupingByException =
Collectors.groupingBy(
Entry::getKey,
MoreCollectors.flatMapping(
valuesStream.andThen(
s -> {
if (s == null) return null;
openClose.incrementAndGet();
return s.onClose(openClose::decrementAndGet)
.peek(
e -> {
if (e.equals("gg")) throw new IllegalArgumentException(e);
});
}),
Collectors.toList()));
list.stream()
.collect(
MoreCollectors.collectingAndThen(
groupingByException,
res -> {
assertEquals(0, openClose.get());
return res;
}));
} catch (IllegalArgumentException e1) {
assertEquals("gg", e1.getMessage());
catched = true;
}
assertTrue(catched);
}
{
Map<String, List<String>> expected =
EntryStream.of(
"a", Arrays.asList("bb"), "b", Arrays.asList("ee"), "c", Arrays.asList("gg"))
.toMap();
Collector<Entry<String, List<String>>, ?, List<String>> headOne =
MoreCollectors.flatMapping(valuesStream, MoreCollectors.head(1));
checkCollector(
"flatMappingSubShort",
expected,
list::stream,
Collectors.groupingBy(Entry::getKey, headOne));
checkShortCircuitCollector(
"flatMappingShort",
expected,
4,
list::stream,
MoreCollectors.groupingBy(Entry::getKey, StreamEx.of("a", "b", "c").toSet(), headOne));
AtomicInteger cnt = new AtomicInteger();
Collector<Entry<String, List<String>>, ?, List<String>> headPeek =
MoreCollectors.flatMapping(
valuesStream.andThen(s -> s == null ? null : s.peek(x -> cnt.incrementAndGet())),
MoreCollectors.head(1));
assertEquals(
expected, StreamEx.of(list).collect(Collectors.groupingBy(Entry::getKey, headPeek)));
assertEquals(3, cnt.get());
cnt.set(0);
assertEquals(
expected,
StreamEx.of(list)
.collect(
MoreCollectors.groupingBy(
Entry::getKey, StreamEx.of("a", "b", "c").toSet(), headPeek)));
assertEquals(3, cnt.get());
}
{
Map<String, List<String>> expected =
EntryStream.of(
"a",
Arrays.asList("bb", "cc"),
"b",
Arrays.asList("ee", "ff"),
"c",
Arrays.asList("gg"))
.toMap();
Collector<Entry<String, List<String>>, ?, List<String>> headTwo =
MoreCollectors.flatMapping(valuesStream, MoreCollectors.head(2));
checkCollector(
"flatMappingSubShort",
expected,
list::stream,
Collectors.groupingBy(Entry::getKey, headTwo));
AtomicInteger openClose = new AtomicInteger();
boolean catched = false;
try {
Collector<Entry<String, List<String>>, ?, Map<String, List<String>>> groupingByException =
Collectors.groupingBy(
Entry::getKey,
MoreCollectors.flatMapping(
valuesStream.andThen(
s -> {
if (s == null) return null;
openClose.incrementAndGet();
return s.onClose(openClose::decrementAndGet)
.peek(
e -> {
if (e.equals("gg")) throw new IllegalArgumentException(e);
});
}),
MoreCollectors.head(2)));
list.stream()
.collect(
MoreCollectors.collectingAndThen(
groupingByException,
res -> {
assertEquals(0, openClose.get());
return res;
}));
} catch (IllegalArgumentException e1) {
assertEquals("gg", e1.getMessage());
catched = true;
}
assertTrue(catched);
}
}