Is mapNotNull more efficient than filter and map?

I was writing some Kotlin code that filtered and then mapped a list (which is a pattern I have seen previously in Kotlin), but I realised it may be more efficient to just use mapNotNull. I was curious if this is true and if so what the use cases for using filter and map over mapNotNull are.

The original thing I was doing looked something like this:

myList.filterIsInstance<MyObjectType>.map { it.name }

I realised in this case the code must run through the entire collection for the filter and then must run through the filtered list again to perform the map.
So I ended up changing the code to look like this:

myList.mapNotNull { if (it is MyObjectType) it.name else null }

In this case you only need to run through the entire collection once. Unless mapNotNull is just performing a filter for not null items under the hood?

Is this correct? Is the second method more efficient?

And if that is the case, my next question is when would running a filter than a map ever be more efficient than using mapNotNull which contains a statement to map unwanted items to null. Will it not always increase the amount of iterations that run?

I have a feeling I may be missing something obvious here, so any clarification is appreciated and sorry if it is a stupid question.

Each of these operators on the Iterable produces a new List, so using two operators instead of one operator is going to take more time, assuming the logic of what you're doing is basically the same. The bulk of the extra time will be in allocating and writing to the new list, not so much the extra iteration through the whole list.

Be careful benchmarking stuff without using a benchmarking library. Your results could be way off because of you not factoring in things like warm-up, JIT optimizations that happen at runtime due to repeated operations, class loading being included in the time of your first test case, etc.