你只需要跟踪上一个值。类似这样的东西应该可以工作：

fun Iterable<Item>.getActiveItems(start: Instant, end: Instant): List<Item> {
    require(end >= start)
    var prev: Item? = null
    val result = mutableListOf<Item>()
    for (item in this) {
        if (item.created <= start) prev = item else {
            prev?.let(result::add)
            prev = null
            result += item.takeIf { it.created <= end } ?: break
        }
    }
    return result
}

假设：

• 列表按created排序
• 包含start处的created项，但不包含之前的任何项
• 包含end处的项目created，但不包含之后的任何项目

这是一个基于索引迭代的解决方案，但与@Ruckus T-Boom的答案的一般原理相同。

fun List<Item>.getItems(from: Instant, to: Instant): List<Item> {
    var startIndex: Int? = null
    var endIndex: Int? = null
    run loop@ {
        this.forEachIndexed { i, item ->
            if (startIndex == null) {
                when {
                    item.created > from -> startIndex = i - 1
                    item.created == from -> startIndex = i
                }   
            }
            if (endIndex == null) {
                when {
                    item.created > to -> endIndex = i - 1
                    item.created == to -> endIndex = i
                }
            }
            if (startIndex != null && endIndex != null) {
                return@loop
            }
        }
    }
    if (startIndex == null) {
        return emptyList()
    }
    if (endIndex == null) {
        endIndex = this.size - 1
    }
    return this.subList(startIndex!!, endIndex!! + 1)
}

这并没有涵盖所有可能的边缘情况，但是很好地处理了您的示例中的情况以及其他一些情况（您可以自己检查here）