How could I make a stream pipeline more variable in Java?

Question

I wrote a stream pipeline:

private void calcMin(Clazz clazz) {
    OptionalInt min = listOfObjects.stream().filter(y -> (y.getName()
                    .matches(clazz.getFilter())))
                    .map(y -> (y.getUserNumber()))
                    .mapToInt(Integer::intValue)
                    .min();
    list.add(min.getAsInt());
}

This pipeline gives me the lowest UserNumber.

So far, so good.

But I also need the greatest UserNumber. And I also need the lowest GroupNumber. And also the greatest GroupNumber.

I could write:

private void calcMax(Clazz clazz) {
    OptionalInt max = listOfObjects.stream().filter(y -> (y.getName()
                    .matches(clazz.getFilter())))
                    .map(y -> (y.getUserNumber()))
                    .mapToInt(Integer::intValue)
                    .max();
    list.add(max.getAsInt());
}

And I could also write the same for .map(y -> (y.getGroupNumber())).

This will work, but it is very redudant.

Is there a way to do it more variable?

Answer 1

For the sake of variety, I want to add the following approach which uses a nested Collectors.teeing (Java 12 or higher) which enables to get all values by just streaming over the collection only once.

For the set up, I am using the below simple class :

@AllArgsConstructor
@ToString
@Getter
static class MyObject {
    int userNumber;
    int groupNumber;
}

and a list of MyObjects:

List<MyObject> myObjectList = List.of(
        new MyObject(1, 2),
        new MyObject(2, 3),
        new MyObject(3, 4),
        new MyObject(5, 3),
        new MyObject(6, 2),
        new MyObject(7, 6),
        new MyObject(1, 12));

If the task was to get the max and min userNumber one could do a simple teeing like below and add for example the values to map:

Map<String , Integer> maxMinUserNum =
        myObjectList.stream()
                    .collect(
                            Collectors.teeing(
                                    Collectors.reducing(Integer.MAX_VALUE, MyObject::getUserNumber, Integer::min),
                                    Collectors.reducing(Integer.MIN_VALUE, MyObject::getUserNumber, Integer::max),
                                    (min,max) -> {
                                        Map<String,Integer> map = new HashMap<>();
                                        map.put("minUser",min);
                                        map.put("maxUser",max);
                                        return map;
                                    }));
System.out.println(maxMinUserNum);

//output: {minUser=1, maxUser=7}

Since the task also includes to get the max and min group numbers, we could use the same approach as above and only need to nest the teeing collector :

Map<String , Integer> result =
    myObjectList.stream()
                .collect(
                        Collectors.teeing(
                                Collectors.teeing(
                                        Collectors.reducing(Integer.MAX_VALUE, MyObject::getUserNumber, Integer::min),
                                        Collectors.reducing(Integer.MIN_VALUE, MyObject::getUserNumber, Integer::max),
                                        (min,max) -> {
                                            Map<String,Integer> map = new LinkedHashMap<>();
                                            map.put("minUser",min);
                                            map.put("maxUser",max);
                                            return map;
                                        }),
                                Collectors.teeing(
                                        Collectors.reducing(Integer.MAX_VALUE, MyObject::getGroupNumber, Integer::min),
                                        Collectors.reducing(Integer.MIN_VALUE, MyObject::getGroupNumber, Integer::max),
                                        (min,max) -> {
                                            Map<String,Integer> map = new LinkedHashMap<>();
                                            map.put("minGroup",min);
                                            map.put("maxGroup",max);
                                            return map;
                                        }),
                                (map1,map2) -> {
                                    map1.putAll(map2);
                                    return map1;
                                }));

System.out.println(result);

output

{minUser=1, maxUser=7, minGroup=2, maxGroup=12}

Answer 2

The solution may reduce redundancy but it removes readability from the code.

 IntStream maxi = listOfObjects.stream().filter(y -> (y.getName()
                .matches(clazz.getFilter())))
                .map(y -> (y.getUserNumber()))
                .mapToInt(Integer::intValue);
    System.out.println(applier(() -> maxi, IntStream::max));
    //System.out.println(applier(() -> maxi, IntStream::min));

...

public static OptionalInt applier(Supplier<IntStream> supplier, Function<IntStream, OptionalInt> predicate) {
    return predicate.apply(supplier.get());
}

Answer 3

There are two differences in the examples: the map() operation, and the terminal operation (min() and max()). So, to reuse the rest of the pipeline, you'll want to parameterize these.

I will warn you up front, however, that if you call this parameterized method directly from many places, your code will be harder to read. Comprehension of the caller's code will be easier if you keep a helper function—with a meaningful name—that delegates to the generic method. Obviously, there is a balance here. If you wanted to add additional functional parameters, the number of helper methods would grow rapidly and become cumbersome. And if you only call each helper from one place, maybe using the underlying function directly won't add too much clutter.

You don't show the type of elements in the stream. I'm using the name MyClass in this example as a placeholder.

    private static OptionalInt extremum(
        Collection<? extends MyClass> input,
        Clazz clazz,
        ToIntFunction<? super MyClass> valExtractor,
        Function<IntStream, OptionalInt> terminalOp) {

        IntStream matches = input.stream()
            .filter(y -> y.getName().matches(clazz.getFilter()))
            .mapToInt(valExtractor);
        return terminalOp.apply(matches);
    }

    private OptionalInt calcMinUserNumber(Clazz clazz) {
        return extremum(listOfObjects, clazz, MyClass::getUserNumber, IntStream::min);
    }

    private OptionalInt calcMaxUserNumber(Clazz clazz) {
        return extremum(listOfObjects, clazz, MyClass::getUserNumber, IntStream::max);
    }

    private OptionalInt calcMinGroupNumber(Clazz clazz) {
        return extremum(listOfObjects, clazz, MyClass::getGroupNumber, IntStream::min);
    }

    private OptionalInt calcMaxGroupNumber(Clazz clazz) {
        return extremum(listOfObjects, clazz, MyClass::getGroupNumber, IntStream::max);
    }

    ...

And here's a usage example:

calcMaxGroupNumber(clazz).ifPresent(list::add);