// 典型示例（千萬別學?。?fun updateCart(items: List<CartItem>) {
    cartList = items
    // 全量刷新炸彈
    adapter.notifyDataSetChanged() 
}

class ProductDiffUtil : DiffUtil.ItemCallback<Product>() {
    overridefun areItemsTheSame(old: Product, new: Product) = old.skuId == new.skuId

    overridefun areContentsTheSame(old: Product, new: Product) = 
        old == new.copy( 
            // 排除實時變化字段
            lastUpdate = old.lastUpdate,
            animationState = old.animationState
        )

    // 返回多個變化的字段組合
    overridefun getChangePayload(old: Product, new: Product): Any? {
        val changes = mutableListOf<String>()
        if (old.price != new.price) changes.add("PRICE")
        if (old.stock != new.stock) changes.add("STOCK")
        if (old.promotionTags != new.promotionTags) changes.add("PROMO")
        returnif (changes.isNotEmpty()) changes elsenull
    }
}

// ViewHolder處理復合更新
overridefun onBindViewHolder(holder: ProductVH, position: Int, payloads: List<Any>) {
    when {
        payloads.isNotEmpty() -> {
            payloads.flatMap { it as List<String> }.forEach { change ->
                when (change) {
                    "PRICE" -> {
                        holder.priceView.text = newItem.getPriceText()
                        holder.startPriceChangeAnimation()
                    }
                    "STOCK" -> holder.stockBadge.updateStock(newItem.stock)
                    "PROMO" -> holder.promotionView.updateTags(newItem.promotionTags)
                }
            }
        }
        else -> super.onBindViewHolder(holder, position, payloads)
    }
}

class ChatDiffCallback : DiffUtil.ItemCallback<Message>() {
    overridefun areItemsTheSame(old: Message, new: Message): Boolean {
        // 處理消息ID變更場景（如消息重發）
        returnif (old.isRetry && new.isRetry) old.retryId == new.retryId 
               else old.msgId == new.msgId
    }

    overridefun areContentsTheSame(old: Message, new: Message): Boolean {
        // 消息狀態變更不觸發內容變化（避免氣泡重新渲染）
        return old.content == new.content && 
               old.attachments == new.attachments &&
               old.sender == new.sender
    }

    overridefun getChangePayload(old: Message, new: Message): Any? {
        returnwhen {
            old.status != new.status -> MessageStatusChange(new.status)
            old.reactions != new.reactions -> ReactionUpdate(new.reactions)
            else -> null
        }
    }
}

// 在Adapter中處理復雜更新
overridefun onBindViewHolder(holder: MessageViewHolder, position: Int, payloads: List<Any>) {
    when {
        payloads.any { it is MessageStatusChange } -> {
            holder.updateStatusIndicator(payloads.filterIsInstance<MessageStatusChange>().last().status)
        }
        payloads.any { it is ReactionUpdate } -> {
            holder.showReactionAnimation(payloads.filterIsInstance<ReactionUpdate>().last().reactions)
        }
        else -> super.onBindViewHolder(holder, position, payloads)
    }
}

class NewsPagingAdapter : PagingDataAdapter<NewsItem, NewsViewHolder>(NewsDiffUtil) {

    // 優化首次加載體驗
    overridefun onViewAttachedToWindow(holder: NewsViewHolder) {
        super.onViewAttachedToWindow(holder)
        if (holder.layoutPosition == itemCount - 3) {
            viewModel.loadNextPage()
        }
    }

    companionobject NewsDiffUtil : DiffUtil.ItemCallback<NewsItem>() {
        overridefun areItemsTheSame(old: NewsItem, new: NewsItem): Boolean {
            // 處理服務端ID沖突的特殊情況
            return"${old.source}_${old.id}" == "${new.source}_${new.id}"
        }

        overridefun areContentsTheSame(old: NewsItem, new: NewsItem): Boolean {
            // 排除閱讀狀態變化的影響
            return old.title == new.title &&
                   old.content == new.content &&
                   old.images == new.images
        }
    }
}

// 在ViewModel中智能合并數據
fun onNewPageLoaded(news: List<NewsItem>) {
    val current = adapter.snapshot().items
    val merged = (current + news).distinctBy { "${it.source}_${it.id}" }
    adapter.submitData(lifecycle, PagingData.from(merged))
}

data classTreeNode(
    val id: String,
    val title: String,
    val children: List<TreeNode> = emptyList(),
    var isExpanded: Boolean = false
)

classTreeDiffCallback : DiffUtil.ItemCallback<TreeNode>() {
    overridefun areItemsTheSame(old: TreeNode, new: TreeNode): Boolean {
        // 考慮父節點變化的情況
        return old.id == new.id && old.parentId == new.parentId
    }

    overridefun areContentsTheSame(old: TreeNode, new: TreeNode): Boolean {
        // 排除展開狀態的影響
        return old.title == new.title && 
               old.children.size == new.children.size &&
               old.iconRes == new.iconRes
    }

    overridefun getChangePayload(old: TreeNode, new: TreeNode): Any? {
        returnwhen {
            old.isExpanded != new.isExpanded -> ExpansionChange(new.isExpanded)
            old.children != new.children -> StructureChange
            else -> null
        }
    }
}

// 處理樹形結構更新
fun toggleNode(position: Int) {
    val newList = currentList.toMutableList()
    val node = newList[position]
    newList[position] = node.copy(isExpanded = !node.isExpanded)
    
    if (node.isExpanded) {
        // 收起時移除子節點
        newList.removeAll { it.parentId == node.id }
    } else {
        // 展開時插入子節點
        val children = fetchChildren(node.id)
        newList.addAll(position + 1, children)
    }
    
    submitList(newList) {
        // 自動滾動到展開位置
        recyclerView.smoothScrollToPosition(position)
    }
}

class SafeDiffUpdater(
    privateval adapter: ListAdapter<*, *>,
    privateval scope: CoroutineScope
) {
    // 最后提交版本控制
    privatevar lastSubmitVersion = 0

    fun safeSubmitList(newList: List<Item>, isForce: Boolean = false) {
        val currentVersion = ++lastSubmitVersion
        scope.launch(Dispatchers.Default) {
            // 計算階段耗時統計
            val calcStart = System.currentTimeMillis()
            val diffResult = try {
                DiffUtil.calculateDiff(createDiffCallback(adapter.currentList, newList))
            } catch (e: Exception) {
                // 降級策略：當計算超時（>50ms）時切換為全量更新
                if (System.currentTimeMillis() - calcStart > 50) nullelsethrow e
            }

            withContext(Dispatchers.Main) {
                if (currentVersion == lastSubmitVersion) {
                    when {
                        diffResult != null -> {
                            adapter.submitList(newList) { diffResult.dispatchUpdatesTo(adapter) }
                        }
                        isForce -> adapter.submitList(emptyList()).also { 
                            adapter.submitList(newList) 
                        }
                        else -> adapter.submitList(newList)
                    }
                }
            }
        }
    }

    // 創建支持中斷的DiffCallback
    privatefun createDiffCallback(old: List<Item>, new: List<Item>): DiffUtil.Callback {
        returnobject : DiffUtil.Callback() {
            // 實現基礎比對方法...
            overridefun areContentsTheSame(oldPos: Int, newPos: Int): Boolean {
                // 每1000次比對檢查一次是否超時
                if (oldPos % 1000 == 0 && System.currentTimeMillis() - calcStart > 50) {
                    throw CancellationException("Diff計算超時")
                }
                return old[oldPos] == new[newPos]
            }
        }
    }
}

class IncrementalUpdateEngine {
    // 內存優化型差異計算
    fun calculateDelta(
        old: List<Item>,
        new: List<Item>,
        batchSize: Int = 500
    ): List<ChangeSet> {
        return sequence {
            var oldIndex = 0
            var newIndex = 0
            while (oldIndex < old.size || newIndex < new.size) {
                // 批量處理避免OOM 分片處理（500項/批）
                val oldBatch = old.subList(oldIndex, min(oldIndex + batchSize, old.size))
                val newBatch = new.subList(newIndex, min(newIndex + batchSize, new.size))

                // 使用位運算快速比對
                val changes = mutableListOf<ChangeSet>()
                for (i in oldBatch.indices) {
                    val oldItem = oldBatch[i]
                    val newItem = newBatch.getOrNull(i) ?: break
                    if (oldItem.id != newItem.id) {
                        changes.add(ChangeSet.Delete(oldIndex + i))
                        changes.add(ChangeSet.Insert(newIndex + i, newItem))
                    } elseif (oldItem != newItem) {
                        changes.add(ChangeSet.Update(newIndex + i, newItem))
                    }
                }
                yieldAll(changes)

                oldIndex += batchSize
                newIndex += batchSize
            }
        }.toList()
    }

    // 使用示例
    fun applyDelta(changes: List<ChangeSet>) {
        val newList = currentList.toMutableList()
        changes.forEach { change ->
            when (change) {
                is ChangeSet.Insert -> newList.add(change.index, change.item)
                is ChangeSet.Delete -> newList.removeAt(change.index)
                is ChangeSet.Update -> newList[change.index] = change.item
            }
        }
        adapter.submitList(newList)
    }
}

class SmartPreloader(
    privateval recyclerView: RecyclerView,
    privateval prefetchDistance: Int = 3
) : RecyclerView.OnScrollListener() {

    // 分級緩存策略
    privateenumclassCacheLevel { HOT, WARM, COLD }
    privateval cache = mutableMapOf<CacheLevel, List<Item>>()

    overridefun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
        val layoutManager = recyclerView.layoutManager as LinearLayoutManager
        val firstVisible = layoutManager.findFirstVisibleItemPosition()
        val lastVisible = layoutManager.findLastVisibleItemPosition()

        // 預加載觸發邏輯
        if (lastVisible + prefetchDistance >= adapter.itemCount - 1) {
            loadNextPage() // 常規分頁加載
        }

        // 緩存預熱策略
        val preheatRange = (firstVisible - prefetchDistance).coerceAtLeast(0).. 
                          (lastVisible + prefetchDistance).coerceAtMost(adapter.itemCount - 1)
        preheatCache(preheatRange)
    }

    privatefun preheatCache(range: IntRange) {
        // 三級緩存策略
        cache[CacheLevel.HOT] = currentList.subList(range.first, range.last + 1)
        cache[CacheLevel.WARM] = currentList.subList(
            (range.first - 50).coerceAtLeast(0), 
            (range.last + 50).coerceAtMost(currentList.size)
        )
        cache[CacheLevel.COLD] = currentList
    }

    // 內存優化型數據更新
    fun updateWithCache(newItems: List<Item>) {
        val merged = cache[CacheLevel.HOT]?.let { hot ->
            newItems.map { newItem ->
                hot.find { it.id == newItem.id } ?: newItem
            }
        } ?: newItems
        
        adapter.submitList(merged)
    }
}

object RecyclerViewPoolManager {
    // 全局共享對象池
    privateval viewPool = RecyclerView.RecycledViewPool().apply {
        setMaxRecycledViews(VIEW_TYPE_ITEM, 20)
    }

    // 內存復用控制器
    classItemHolderManager {
        privateval itemCache = object : LruCache<Int, ItemHolder>(10) {
            overridefun create(key: Int): ItemHolder = ItemHolder()
        }

        fun bind(position: Int, item: Item) {
            val holder = itemCache.get(position % 10)
            holder.bind(item)
        }
    }

    // 數據壓縮策略
    fun compressListData(items: List<Item>): ByteArray {
        val output = ByteArrayOutputStream()
        ObjectOutputStream(output).use {
            it.writeInt(items.size)
            items.forEach { item ->
                it.writeLong(item.id)      // 8 bytes
                it.writeUTF(item.title)    // 2 + length
                it.writeFloat(item.price)  // 4 bytes
            }
        }
        return output.toByteArray()
    }
}

// 使用示例
recyclerView.setRecycledViewPool(RecyclerViewPoolManager.viewPool)
val compressedData = RecyclerViewPoolManager.compressListData(hugeList)
val parsedList = RecyclerViewPoolManager.parseCompressedData(compressedData)