override fun subList: List =
SubList
private class SubList(
private val list: List,private val fromIndex: Int,toIndex: Int
) : List。RandomAccess {
private var _size: Int
init {
checkRangeIndexes
_size = toIndex - fromIndex
}
override fun get: E {
checkElementIndex
return list // 索引转换是关键
}
override val size: Int get = _size
}
引用而非副本：子列表只保存原始列表的引用，不会产生额外的数据拷贝。
记录偏移量和长度：fromIndex 与 _size 在创建时即确定。
索引转换在 get 中完成：子列表的相对索引加上偏移量后交给原列表读取。
因为仅生成一个包装对象并保存几个整数。subList 的创建是 O 的常数时间操作，即使原列表非常大也毫无压力。
子视图嵌套仍保持 O
override fun subList: List {
checkRangeIndexes
return SubList(list。this.fromIndex + fromIndex,this.fromIndex + toIndex)
}
val items = listOf
val sliced = items.slice
println // 输出：
Slicing 实现
public fun List.slice: List {
if ) return listOf
return this.subList(indices.start,indices.endInclusive + 1).toList
}
Lazily use subList：Pretends a view first.
.toList creates copy：The actual copy happens only once.
If you pass an Iterable。implementation falls back to a generic loop:
public fun List.slice: List {
val result = ArrayList)
for result.add)
return result
}
take / takeLast：快速获取前/后 N 条数据
Take 取得前 N TakeLast 取得后 N
val names = listOf
println) //
println) //
Take 实现要点
public fun Iterable.take: List {
require { "Requested element count $n is less than zero." }
if return emptyList
if {
if return toList
if return listOf)
}
val result = ArrayList
var count = 0
for {
result.add
if break // 提前终止
}
return result.optimizeReadOnlyList
}
# 参数校验与边界处理：N=0、N≥size、N=1
# Collection 调整：If receiver is a Collection we already know its size.
# 提前终止：The loop stops as soon as N elements are collected.
TakeLast 的特化方法
public fun List.takeLast: List {
require { "Requested element count $n is less than zero." }
if return emptyList
val size = size
if return toList
val result = ArrayList
if { // 快速随机访问方法
for result.add
} else { // 顺序访问方法
for ) result.add
}
return result
}
The function first checks wher list implements ,n chooses most efficient traversal method accordingly.
drop / dropLast：丢弃前/后 N 条并返回剩余部分
val numbers = listOf
println) //
println) //
Take vs Drop：实现思路相似却方向相反
public fun Iterable.drop: List
{
// 前置检查省略…if {
val resultSize = size - n // 知道最终容量，可直接预分配
if {
if { // 方法 A：随机访问调整
for result.add
} else { // 方法 B：顺序访问调整
for ) result.add
}
return result
}
}
// 方法 C：通用回退方案
var count = 0
for{
if result.add
}
return result
}
Droplast 简洁实现背后的技巧
public fun
List.dropLast: List{
require{…}
return take.coerceAtLeast)
}
Avoids writing a separate “remove‑from‑end” loop by reusing highly optimized take.
The . coerceAtLeast guard ensures that when 。argument passed into never becomes negative – it becomes 0 and returns an empty read‑only list.
<\/ ul>
windowed：滑动窗口抓取重叠子序列
windowed c ode> 会以固定大小和步长在集合上滑动，每一次都产生一个 “窗口”。
窗口之间可以重叠，也可以不重叠。
val seq = listOf
val windows = seq.windowed
println //，]
针对 RandomAccess 列表的
public fun Iterable . windowed(
size :Int,step :Int =1。partialWindows :Boolean=false ) : L ist>{
checkWindowSizeStep
if{
val thisSize=this.size
val capacity=thisSize/step +if0 else1
val res=ArrayL ist
var index=0
while{
v al winSize=size.coerceAtMost
i f br eak
res.add{ this })
index+=step
}
r etur n res
}…// 非 RandomAccess 或非 L ist 回退方法
}
<
/ pre>
预估结果容量 → 一次性分配内存，避免扩容。
使用L ist{ …}工厂函数直接在索引上读取，免去额外迭代器开销。
当剩余元素不足完整窗口且 partialWindows 为 false 时立即退出循环。
<\/ ul>
若对象不满足 RandomAccess+L ist 条件，则内部会走更通用且稍慢的 iterator 基础实现。这正体现了 Kotlin 标准库“先专化后通用”的设计哲学。
