Sequence vs List benchmark

code.kt

import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking
import org.openjdk.jmh.annotations.Benchmark
import org.openjdk.jmh.annotations.Fork
import org.openjdk.jmh.annotations.Measurement
import org.openjdk.jmh.annotations.Scope
import org.openjdk.jmh.annotations.State
import org.openjdk.jmh.annotations.Warmup
import java.util.concurrent.TimeUnit

@State(Scope.Benchmark)
@Fork(1)
@Warmup(iterations = 2)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
class SequenceBenchmark {
  @Benchmark
  fun list() {
    DataRepository.getItemsList()
  }

  @Benchmark
  fun sequence() {
    DataRepository.getItemsListUsingSequence()
  }

  @Benchmark
  fun flow() {
    DataRepository.getItemsListUsingFlow()
  }
}

private const val ITEM_SIZE = 100

object Db {
  fun getItems(): List<DbModel> {
    return (0 until ITEM_SIZE).map { index ->
      DbModel(
        id = index,
        rank = ITEM_SIZE - index, // reverse
        isEnabled = index.mod(2) == 0,
      )
    }
  }
}

object DataRepository {
  fun getItemsList(): List<UiModel> {
    return Db.getItems()
      .filter { it.isEnabled }
      .map { UiModel(it.id) }
  }

  fun getItemsListUsingSequence(): List<UiModel> {
    return Db.getItems()
      .asSequence()
      .filter { it.isEnabled }
      .map { UiModel(it.id) }
      .toList()
  }

  fun getItemsListUsingFlow(): List<UiModel> = runBlocking {
    Db.getItems()
      .asFlow()
      .filter { it.isEnabled }
      .map { UiModel(it.id) }
      .toList()
  }
}

data class DbModel(val id: Int, val rank: Int, val isEnabled: Boolean)

data class UiModel(val id: Int)