关于Java Streams中Collector和Function参数排序问题

Question

So I'm looking into Java Streams and I have some questions about the meaning of the order of certain parameters.

Some of the context:

public static List<Person> createPeople() {
    return List.of(new Person("Sara", 20), 
                   new Person("Sara", 22), 
                   new Person("Bob", 20), 
                   new Person("Paula",32), 
                   new Person("Paul", 32), 
                   new Person("Jack", 3), 
                   new Person("Jack", 72), 
                   new Person("Jill", 11));
    }
    

List<Person> people = Section.createPeople();

Consider the following code:

Map<String, Integer> countByName3 = people.stream()
                                          .collect(groupingBy(Person::getName,
                                                              collectingAndThen(counting(), Long::intValue)));

The point of this code is to output a key value pair where the key is the name of the person and the value is the count of people with that particular name.

Now where I am at in my understanding is that the collect method is taking Collector objects that are generated by functions in the Collectors class such as groupingBy as its argument.

I also understand that there is a Function in the parameter of some of these methods. Something that interests me is the role that the order of the Function and the Collector in the method that generates a Collector object plays.

For instance, groupingBy() takes its arguments in the order (Function, Collector), while collectingAndThen() takes its arguments in the order (Collector, Function). Both return Collectors if I am not mistaken.

Thus, what is the meaning of the reversed order, is it indicative of how something is processed under the hood? And if there is a difference/meaning behind the order, can I get an explanation for that?

Thanks very much.

Answer 1

There's nothing magic happening here. Collectors is just a class. Like any other. It has static methods. You can invoke them and there is absolutely no magic here. You can make your own class with static methods returning instances of the Collector type if you want.

Given that they are just methods, there is absolutely nothing inherent in the language about the order of parameters. The author of the collectingAndThen method respectively the groupingBy method made a decision. That's all.

If you want an explanation for why these authors decided to put the arguments in these orders, you'd have to ask them - that's not an appropriate question for Stack Overflow so I'll give you the benefit of the doubt and assume you knew that and are asking for folks to opine as to the why. That's not really appropriate for SO either. But, to indulge you:

It makes sense to me. collectingAndThen is in the same order as the very name of that method: "Make a new collector that operates by first applying THIS collector (first argument), but applying THIS finishing transformation after collecting (second argument)".

The arguments are in the order one would explain what it does.

groupingBy, does the exact same thing: Create a collector by grouping by a certain key; to derive this key, toss all things in the stream through THIS transforming function. Then, actually collect it all by applying this key value using THIS collector.

Both are in this 'in the order you mention the parameters if you would explain what it does' order. The fact that groupingBy 's first 'thing' happens to be a Function and its second 'thing' happens to be a Collector , whereas for collectingAndThen having its first 'thing' be a Collector and its second 'thing' be a Function is total coincidence.