Is there performance impact of using `map() + stream()` vs `flatMapMany() + map()`?

Is there difference in performance between using map() + stream() and flatMapMany() + map()?

For example, we have a collection of some entities and we need to map it to another representation of these objects:

List<Entity> list = ... // init some collection
Mono.just(collection)
  .map(collection -> collection.stream.map(mapper::map))
  .flatMapMany(Flux::fromStream)

OR

List<Entity> list = ... // init some collection
Mono.just(collection)
  .flatMapMany(Flux::fromIterable)
  .map(mapper::map)

In my opinion, Stream.map operations are more lightweight than Flux.map and allocate fewer objects, so then the first solution is better, but I'm not quite sure.

I don't think you should choose from those two.

It depends on which task is executed by your mapper.
If there will be some blocking or long executed operation which you have wrapped with Mono - the best one will be:

List<Entity> list = ... // init some collection
Flux.fromIterable(list)
    .map(mapper::map)
    ...

Whether you worry about objects count, you can use Stream.map on list itself:

List<Entity> list = ... // init some collection
List<Entity> processedEntities = list.stream().map(mapper::map).toList();

it is on your consideration which one to choose, I can only assume that you still have to return some Mono/Flux from your method, so you will not achieve many benefits from those redundant steps.

Speaking about two examples you've provided, its looks like incorrect usage, since it makes redundant convertation from Mono to Flux