深度解析：如何使用 Kotlin 打造高性能的 Android 可展开列表

2026-02-14 04:48:42 0条评论 1次阅读 0人点赞

在这篇文章中，我们将深入探讨在 Android 开发中一个非常经典且具有挑战性的 UI 场景：如何构建一个可展开的列表。如果你已经厌倦了普通的 INLINECODE5aa82770 或者简单的 INLINECODEe44ec9f8 一刀切式布局，想要实现类似手风琴那样点击展开、收起子项的效果，那么你来对地方了。我们将一起从零开始，使用 Kotlin 语言来实现这一功能。

为什么要自己实现可展开列表？

虽然 Android 原生提供过 INLINECODE65b3122f，但它的定制性较差，且性能无法与现代的 INLINECODE0264c093 相提并论。通过使用 RecyclerView 来实现可展开列表，我们可以获得以下优势：

  • 极高的灵活性：我们可以完全控制每一项的布局和动画效果。
  • 性能优化：RecyclerView 的回收机制可以确保即使数据量很大，列表依然流畅。
  • 统一的开发体验：不需要引入额外的组件，保持了代码栈的统一。

设计思路：如何"欺骗" RecyclerView

在通常情况下，INLINECODE06892234 期望展示的是一系列类型相同的对象。但在可展开列表中，我们有两种明显不同的项：父项 和 子项。为了处理这种情况，我们需要创建一个通用的数据模型，并利用 INLINECODEadd958a9 的多类型布局机制。

我们可以将列表想象成一个线性的数据流。当一个父项处于"折叠"状态时，它只占据一个位置；当它"展开"时，我们会动态地将其对应的子项数据插入到这个位置之后，从而撑开列表。这听起来很复杂，但别担心，我们将一步步拆解。

第一步：构建数据模型

我们需要两种数据模型来分别描述父项和子项。同时，为了让 RecyclerView 能够区分它们，我们需要一个统一的接口或者基类。

#### 1. 定义类型常量

首先，我们需要定义常量来标记视图类型。这是处理多类型布局的标准做法。

// Constants.kt
object Constants {
    // 标识父项视图类型
    const val PARENT = 0
    // 标识子项视图类型
    const val CHILD = 1
}

#### 2. 子项数据类

子项通常包含具体的详细数据。在这个例子中，我们用一个简单的字符串来展示。

// ChildData.kt
/**
 * 子项数据类
 * @param childTitle 子项显示的文本内容
 */
data class ChildData(
    val childTitle: String
)

#### 3. 父项数据类

父项是关键，它不仅要包含自己的信息，还需要包含它所拥有的子项列表，以及当前的展开/折叠状态。

// ParentData.kt
/**
 * 父项数据类
 * @param parentTitle 父项显示的标题
 * @param type 视图类型，默认为 PARENT
 * @param subList 该父项下包含的子项列表
 * @param isExpanded 当前是否处于展开状态，默认为 false
 */
data class ParentData(
    val parentTitle: String? = null,
    var type: Int = Constants.PARENT,
    var subList: MutableList = ArrayList(),
    var isExpanded: Boolean = false
)

这里有一个实用的见解： 我们将 isExpanded 状态直接保存在数据模型中，而不是在 ViewHolder 或 Adapter 中。这是一种数据驱动的做法，使得在配置更改（如屏幕旋转）时，状态更容易保存和恢复。

第二步：准备模拟数据

在实际开发中，你可能从数据库或 API 获取数据。为了演示方便，我们将在 Activity 中创建一些硬编码的模拟数据。让我们模拟一个"印度各邦及其城市"的列表（当然，你可以替换成任何业务场景，比如"产品分类"或"常见问题解答"）。

// 在 Activity 中准备数据
private fun prepareData(): MutableList {
    // 初始化主列表
    val listData: MutableList = ArrayList()

    // 定义父项数据（例如：邦的名字）
    val parentData: Array = arrayOf(
        "安德拉邦",
        "特伦甘纳邦",
        "卡纳塔克邦",
        "泰米尔纳德邦"
    )

    // 定义各邦下的子项数据（城市）
    val childData1: MutableList = mutableListOf(
        ChildData("阿纳塔普尔"),
        ChildData("奇托尔"),
        ChildData("内洛尔"),
        ChildData("贡土尔")
    )

    val childData2: MutableList = mutableListOf(
        ChildData("拉贾纳·西尔西拉"),
        ChildData("卡里姆纳加尔"),
        ChildData("西迪佩特")
    )

    // 注意：这里演示有些父项没有子项的情况，这是合法的
    val childData3: MutableList = mutableListOf()

    val childData4: MutableList = mutableListOf(
        ChildData("金奈"),
        ChildData("埃罗德")
    )

    // 构建父项对象并关联子项
    val parentObj1 = ParentData(parentTitle = parentData[0], subList = childData1)
    val parentObj2 = ParentData(parentTitle = parentData[1], subList = childData2)
    val parentObj3 = ParentData(parentTitle = parentData[2], subList = childData3) // 无子项
    val parentObj4 = ParentData(parentTitle = parentData[3], subList = childData4)

    // 将所有父项添加到主列表中
    listData.add(parentObj1)
    listData.add(parentObj2)
    listData.add(parentObj3)
    listData.add(parentObj4)

    return listData
}

第三步：创建适配器 – 核心逻辑

这是最关键的部分。我们需要创建一个 RecyclerView.Adapter，它能够识别当前的项是父项还是子项，并加载相应的布局文件。

假设我们有两个 XML 布局文件：INLINECODE60bb9cf7（包含一个 TextView 和一个指示箭头的 ImageView）和 INLINECODEfa65cd3f（仅包含一个 TextView）。

// RecycleAdapter.kt
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView

class RecycleAdapter(
    var mContext: Context,
    // 传入可变列表，因为我们将动态修改它来添加/移除子项
    val list: MutableList
) : RecyclerView.Adapter() {

    // 内部类：父项的 ViewHolder
    inner class GroupViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val parentTV: TextView? = itemView.findViewById(R.id.parentTextView)
        val downIV: ImageView? = itemView.findViewById(R.id.expandCollapseImageView)
    }

    // 内部类：子项的 ViewHolder
    inner class ChildViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val childTV: TextView? = itemView.findViewById(R.id.childTextView)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        return if (viewType == Constants.PARENT) {
            // 加载父项布局
            val view = LayoutInflater.from(parent.context)
                .inflate(R.layout.parent_row, parent, false)
            GroupViewHolder(view)
        } else {
            // 加载子项布局
            val view = LayoutInflater.from(parent.context)
                .inflate(R.layout.child_row, parent, false)
            ChildViewHolder(view)
        }
    }

    override fun getItemViewType(position: Int): Int {
        // 关键逻辑：从数据模型中获取类型
        return list[position].type
    }

    override fun getItemCount(): Int = list.size

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        val dataList = list[position]

        if (dataList.type == Constants.PARENT) {
            // 绑定父项数据
            (holder as GroupViewHolder).apply {
                parentTV?.text = dataList.parentTitle
                
                // 根据展开状态改变图标方向（可选视觉优化）
                if (dataList.isExpanded) {
                    downIV?.rotation = 180f
                } else {
                    downIV?.rotation = 0f
                }

                downIV?.setOnClickListener {
                    // 点击时切换展开/折叠状态
                    expandOrCollapseParentItem(dataList, position)
                }
            }
        } else {
            // 绑定子项数据
            (holder as ChildViewHolder).apply {
                // 注意：这里我们取父对象中子列表的第一项作为展示数据
                // 实际场景下，你可能需要重构数据结构来直接存储 ChildData 对象
                val singleService = dataList.subList.first()
                childTV?.text = singleService.childTitle
            }
        }
    }

    // 处理展开和折叠的核心逻辑
    private fun expandOrCollapseParentItem(singleBoarding: ParentData, position: Int) {
        if (singleBoarding.isExpanded) {
            // 如果已展开，则折叠
            collapseParentRow(position)
        } else {
            // 如果已折叠，则展开
            expandParentRow(position)
        }
    }

    private fun expandParentRow(position: Int) {
        // 获取当前点击的父项
        val parentData = list[position]
        
        // 更新状态
        parentData.isExpanded = true
        
        // 创建临时的子项列表
        val childItems = mutableListOf()
        
        // 这里有一个技巧：我们将子项也包装成 ParentData 对象，
        // 并将其 type 设为 CHILD。这样我们就可以在同一个列表中管理它们。
        // 注意：这是一种将不同类型对象塞进同一个 List 的 Hack 写法。
        // 在生产代码中，你可能更倾向于使用 Seal class 或抽象父类。
        for (child in parentData.subList) {
            // 创建一个临时的 ParentData 对象来代表子项
            // 我们将 childTitle 临时存入 parentTitle 字段（因为结构相同）
            // 并将子数据放入 subList 中
            val tempChild = ParentData(
                parentTitle = child.childTitle, 
                type = Constants.CHILD, 
                subList = mutableListOf(child)
            )
            childItems.add(tempChild)
        }
        
        // 将子项插入到主列表的当前位置之后
        list.addAll(position + 1, childItems)
        
        // 通知适配器数据已变化
        notifyItemRangeInserted(position + 1, childItems.size)
        // 也要通知当前项改变（图标可能需要变动）
        notifyItemChanged(position)
    }

    private fun collapseParentRow(position: Int) {
        val parentData = list[position]
        parentData.isExpanded = false
        
        // 计算需要移除的子项数量
        val totalChildToDel = parentData.subList.size
        
        // 移除列表中紧跟在父项后面的子项
        for (i in 0 until totalChildToDel) {
            // 始终移除 position + 1 位置的项（因为前面的项被移后后，后面的项会前移）
            list.removeAt(position + 1)
        }
        
        // 通知适配器
        notifyItemRangeRemoved(position + 1, totalChildToDel)
        notifyItemChanged(position)
    }
}

第四步：实际应用中的考量与优化

上面的代码已经能够工作了，但作为专业开发者，我们还需要考虑更多细节。

#### 1. 关于数据结构的进一步思考

在前面的代码中，你可能注意到了一个略显别扭的地方：为了复用 INLINECODE575ef4d4 这个列表，我们将子项也强行包装成了 INLINECODE3f77567f 对象。虽然在 Kotlin 中这完全可行，但在大型项目中，这可能会导致代码难以维护。

更优雅的做法是使用密封类 或接口。让我们快速看一个更高级的数据结构示例：

// 定义一个可展开项的接口
interface ExpandableItem {
    val type: Int
}

// 父项实现
data class Section(
    val title: String,
    var isExpanded: Boolean = false,
    val items: List = emptyList()
) : ExpandableItem {
    override val type = Constants.PARENT
}

// 子项实现
data class DetailItem(
    val name: String
) : ExpandableItem {
    override val type = Constants.CHILD
}

// 那么适配器中的列表就可以写成：
// val items: MutableList = mutableListOf()

这样，你的 onBindViewHolder 就更清晰了，不需要做奇怪的强制类型转换来获取子项的标题。

#### 2. 性能优化：DiffUtil

当我们在列表中频繁插入和删除子项时，直接调用 notifyDataSetChanged() 虽然简单，但会导致整个列表重新绘制，不仅性能差，还会丢失列表滚动的位置和动画。

在我们的示例中，使用了 INLINECODE0bc440cd 和 INLINECODE8550c10a，这已经是很好的做法了。但如果你处理的是极其复杂的数据变化，强烈建议使用 DiffUtil。它会自动计算旧数据集和新数据集的最小差异，并生成相应的更新动画。这对于提升用户体验至关重要。

#### 3. 常见错误排查

  • IndexOutOfBoundsException（索引越界）：这是在实现可展开列表时最容易遇到的错误。通常发生在折叠逻辑中。例如，如果你点击了 "A" 展开了子项，然后程序异步更新了数据，接着你又点击折叠，此时 position 可能已经不准确了。确保你的数据更新操作是线程安全的，并且在 Adapter 更新期间不要并发修改列表。
  • 图标状态不更新：记得在 INLINECODE8a9c0b9c 中不仅设置文本，还要根据 INLINECODEb8c19757 字段更新指示箭头的旋转状态。

总结

在这篇文章中，我们一起学习了如何利用 Kotlin 强大的语言特性和 RecyclerView 的灵活性，构建一个高性能的可展开列表。我们从基础的模型设计讲起，深入到了 Adapter 中的核心逻辑，并探讨了数据结构优化和性能最佳实践。

虽然市面上有许多开源库可以一步到位地解决这个问题，但理解其背后的实现原理对于每一个 Android 开发者来说都是必不可少的。希望这篇文章能帮助你在未来的开发中游刃有余地处理各种复杂的列表需求。如果你正在准备构建一个包含复杂分类的商城应用、邮件客户端或者设置页面，现在你已经掌握了核心的工具。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/48119.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年