To reuse the result of complexEvaluation in both filter and groupingBy, you can call before filtering and store the result in a wrapper class.

foos.stream()
    .map(foo -> {
        int bar = complexEvaluation(foo);
        if (bar > 1000) Pair.of(foo, true);
        if (bar < 0) Pair.of(foo, false);
        return Pair.of(foo, null);
    )
    .filter(fooPair -> fooPair.getRight() != null)
    .collect(Collectors.groupingBy(
        Pair::getRight(),
        Collectors.mapping(fooPair -> fooPair.getLeft().id, Collectors.toSet()
    );

However, this is only if you insist on using groupingBy for some reason.

An alternative with foreach would be much easier to read:

Map<Boolean, Set<Foo>> groups = new HashMap<>();
foos.stream()
    .forEach(foo -> {
        int bar = complexEvaluation(foo);
        if (bar > 1000) groups.computeIfAbsent(true, k->new HashSet<>()).add(foo);
        if (bar < 0)    groups.computeIfAbsent(false, k->new HashSet<>()).add(foo);
   })
    

If I understand your intent correctly you want to filter out some values while collecting them. It's doable with Collectors.filtering().

Note, that filtering() can eliminate all values for some buckets, but it'll not cause empty buckets to be removed. In the example below buckets for 1, 2, 3, 4, 5 will be empty.

    public static void main(String[] args) {
        var foos = List.of(-100, 1, 2, 3, 4, 5, 1001, 1002, 1003);
        
        var map = foos.stream()
                .collect(Collectors.groupingBy(
                            UnaryOperator.identity(),
                            Collectors.filtering(foo -> foo < 0 || foo > 1000,
                                    Collectors.toSet())));

        System.out.println(map);
    }

map

{1=[], 2=[], 3=[], -100=[-100], 4=[], 5=[], 1001=[1001], 1002=[1002], 1003=[1003]}

UPDATE

I revised this problem and the solution provided below computes the values beforehand.

In this version, undesired entries are filtered out in the stream, which makes the code inside Collector easier to read. I hope that instead of foo objects integer is used isn't a problem.

    public static void main(String[] args) {
        List<Integer> foos = List.of(-100, 1, 2, 3, 4, 5, 101, 102, 103);

        Map<Integer, Integer> fooToValue = getFooToValueMap(foos);

        Map<Boolean, Set<Integer>> map = getFoosMap(fooToValue);

        System.out.println(map);
    }

    private static Map<Boolean, Set<Integer>> getFoosMap(Map<Integer, Integer> fooToValue) {
        return fooToValue.entrySet().stream()
                .filter(entry -> entry.getValue() < 0 || entry.getValue() > 1000)
                .collect(Collectors.partitioningBy(
                            entry -> entry.getValue() > 1000,
                            Collectors.mapping(Map.Entry::getKey, Collectors.toSet())
                ));
    }

    private static Map<Integer, Integer> getFooToValueMap(List<Integer> list) {
        return list.stream()
                .collect(Collectors.toMap(UnaryOperator.identity(), foo -> complexEvaluation(foo)));
    }

    private static int complexEvaluation(int foo) {
        return (int) Math.signum(foo) * foo * foo;
    }

map

{false=[-100], true=[101, 102, 103]}

Just use an enum to define your 3 cases:

enum Categories {
    HIGH, LOW, NEGATIVE
}

var map = foos.stream().collect(Collectors.groupingBy(
    foo -> {
        int bar = complexEvaluation(foo);
        if (bar > 1000) return HIGH;
        if (bar < 0) return NEGATIVE;
        return LOW;
    },
    Collectors.mapping(foo -> foo.id, Collectors.toSet())
));

Then ignore or remove LOW if you don’t need it. It also has the added benefits of giving more meaning to your categories instead of just naming them true/false, and making it easier to refactor if you need more categories in the future.

Only drawback is that it builds a useless LOW set, but that’s only an issue if it is really big compared to the other sets and the complexEvaluation() operation.

If you want to avoid temporary storage, you have to implement your own collector:

var map = foos.parallelStream().collect(
    () -> Map.of(true, new HashSet<ID>(), false, new HashSet<ID>()),
    (o, foo) -> {
        int bar = complexEvaluation(foo);
        ID id = foo.id;
        if (bar > 1000) o.get(true).add(id);
        else if (bar < 0) o.get(false).add(id);
    },
    (a, b) -> { a.get(true).addAll(b.get(true)); a.get(false).addAll(b.get(false)); }
);

This example has the same behavior as partitioningBy, always creating entries for true and false.

ID is a placeholder for the type of foo.id which you didn’t include in the question.