Can I do this declaratively using groupingBy?

Here is the solution step-by-step:

1. You can use flatMap to get all the "role-name" possible pairs (Map.Entry<String, String>).
2. Collect using Collectors.groupingBy into the Map structure using an additional Collectors.mapping downstream collector to extract the name of the flatmapped "role-name" pairs. It needs another one to packthese names into a List.

Map<String, List<String>> map = Employee.listOfStaff().stream()
        .flatMap(employee -> employee.getRoles()
                .stream()
                .map(role -> new AbstractMap.SimpleEntry<>(role, employee.getName())))
        .collect(Collectors.groupingBy(
                Entry::getKey,
                Collectors.mapping(Entry::getValue, Collectors.toList())));

map.forEach((k,v) -> System.out.println(k + ":" + v));

I see you use java-8. If you later switch to a newer Java, you can use Map.entry(..) as of Java 9 instead of new AbstractMap.SimpleEntry(...).

Edit: If you don't want to use java-stream, to fix your current iterative code, you need to either fix List insertion/update to the Map (both snippets work the same):

Map<String, List<String>> roleAndNames = new HashMap<>();
for (Employee employee: Employee.listOfStaff()) {
    for (String role: employee.getRoles()) {
        List<String> names = new ArrayList<>();
        if (roleAndNames.containsKey(role)) {
            names = roleAndNames.get(role);
        }
        names.add(employee.getName());
        roleAndNames.put(role, names);
    }
}

Map<String, List<String>> roleAndNames = new HashMap<>();
for (Employee employee: Employee.listOfStaff()) {
    for (String role: employee.getRoles()) {
        List<String> names = roleAndNames.getOrDefault(role, new ArrayList<>());
        names.add(employee.getName());
        roleAndNames.put(role, names);
    }
}

... or better use Map#computeIfAbsent which creates a new entry if there is not any AND always returns the value (which is a List, either an empty one OR with some names). So, you always use it to add the name in it with each iteration.

Map<String, List<String>> roleAndNames = new HashMap<>();
for (Employee employee: Employee.listOfStaff()) {
    for (String role: employee.getRoles()) {
        roleAndNames.computeIfAbsent(role, roleKey -> new ArrayList<>())
                    .add(employee.getName());
    }
}

That's all :) I love this method and its return type. It is very handy!

The trick is to first 'explode' your input into the cross product: You want 1 entry in your stream for each person/role combination. Once you have that, you can collapse this back into a map keyed on Role by using the groupingBy operation. Think databases and SQL if you're familiar with that.

Employee.listOfStaff().stream()
   .flatMap(employee -> employee.getRoles().stream());

This gets you the crosscut (flatMap 'maps' 1 entry in a stream into 0-x entries, by providing it a new stream. All the streams produced by flatMap are concatenated into a single new stream which is what you're operating on when you write .foo() after the flatMap operation.

From here you can do a fairly basic Collectors.groupingBy to get at the desired result.

Just FYI, this:

public enum Sex {
   MALE, FEMALE
}

is not a good idea. It's 2021, not 1970. Don't ask for sex unless there is no other way. For example, if you're gathering this because you want that info to be available so you can put 'Mr' or 'Mrs' at the top of letters, then get rid of the enum and the field and instead have a 'honorific'. Make an enum if you prefer. I'd just go with a String. Various government entities flat out can't use your software, or will at least be quite resistant to it. They have directives to adhere to that say to stop asking when it isn't needed, and it is rarely needed.