Why Stream operations is duplicated with Collectors?

Please allow me to make some complaints, maybe it is boringly but I want to describe:"Why did this question will be raised?". I have answered questions is different from others here, here and here last night.

After I get dig into it, I found there are many duplicated logic between Stream and Collector that violates Don't repeat yourself principle, e.g: Stream#map & Collectors#mapping, Stream#filter & Collectors#filtering in jdk-9 and .etc.

But it seems to reasonable since Stream abide by Tell, Don't ask principle/Law of Demeter and Collector abide by Composition over Inheritance principle.

I can only think of a few reasons why Stream operations is duplicated with Collectors as below:

1. We don't care of how the Stream is created in a big context. in this case Stream operation is more effectively and faster than Collector since it can mapping a Stream to another Stream simply, for example:

   consuming(stream.map(...));
   consuming(stream.collect(mapping(...,toList())).stream());
   
   void consuming(Stream<?> stream){...}
   

2. Collector is more powerful that can composes Collectors together to collecting elements in a stream, However, Stream only providing some useful/highly used operations. for example:

   stream.collect(groupingBy(
     ..., mapping(
           ..., collectingAndThen(reducing(...), ...)
          )
   ));
   

3. Stream operations is more expressiveness than Collector when doing some simpler working, but they are more slower than Collectors since it will creates a new stream for each operation and Stream is more heavier and abstract than Collector. for example:

   stream.map(...).collect(collector);
   stream.collect(mapping(..., collector));
   

4. Collector can't applying short-circuiting terminal operation as Stream. for example:

   stream.filter(...).findFirst();
   

Does anyone can come up with other disadvantage/advantage why Stream operations is duplicated with Collectors here? I'd like to re-understand them. Thanks in advance.