如何在RecyclerView中实现横向列表项均匀分配及最小间距要求？

嘿，我完全懂你现在的困扰——手动测量View、算边距还得调用requestLayout，这流程确实太繁琐了！针对你要实现的横向RecyclerView列表（屏幕内均匀分配+最小项间距X dp，超出可滚动），给你两个更简洁优雅的方案，都是基于LinearLayoutManager优化的：

方案一：自定义LinearLayoutManager（最推荐） #

咱直接把所有逻辑封装在LayoutManager里，Adapter啥额外操作都不用做，完全不用折腾requestLayout，代码复用性还高：

class UniformHorizontalLayoutManager(
    context: Context,
    private val minItemSpacingDp: Int
) : LinearLayoutManager(context, HORIZONTAL, false) {

    private val minItemSpacingPx = TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        minItemSpacingDp.toFloat(),
        context.resources.displayMetrics
    ).toInt()

    override fun onLayoutChildren(recycler: RecyclerView.Recycler?, state: RecyclerView.State?) {
        super.onLayoutChildren(recycler, state)
        if (itemCount == 0) return

        // 计算RecyclerView的可用宽度（去掉左右padding）
        val availableWidth = width - paddingLeft - paddingRight
        // 预测量所有item的原始宽度，统计总宽度
        var totalItemRawWidth = 0
        val childViews = mutableListOf<View>()
        for (i in 0 until itemCount) {
            val child = recycler?.getViewForPosition(i) ?: continue
            measureChildWithMargins(child, 0, 0)
            totalItemRawWidth += getDecoratedMeasuredWidth(child)
            childViews.add(child)
        }

        // 计算最小间距的总占用宽度
        val totalMinSpacing = (itemCount - 1) * minItemSpacingPx
        // 判断是否能在屏幕内放下所有item（含最小间距）
        val canFitAllItems = totalItemRawWidth + totalMinSpacing <= availableWidth

        if (canFitAllItems) {
            // 能完全显示：把剩余宽度平均分给每个item，实现均匀分配
            val extraWidthPerItem = (availableWidth - totalItemRawWidth - totalMinSpacing) / itemCount
            childViews.forEachIndexed { index, child ->
                val params = child.layoutParams as RecyclerView.LayoutParams
                // 给item加上额外宽度，同时拆分间距到左右（避免首尾item有多余边距）
                params.width = getDecoratedMeasuredWidth(child) + extraWidthPerItem
                params.leftMargin = if (index == 0) 0 else minItemSpacingPx / 2
                params.rightMargin = if (index == itemCount - 1) 0 else minItemSpacingPx / 2
                child.layoutParams = params
            }
        } else {
            // 不能完全显示：保持item原始宽度，只设置最小项间距
            childViews.forEachIndexed { index, child ->
                val params = child.layoutParams as RecyclerView.LayoutParams
                params.leftMargin = if (index == 0) 0 else minItemSpacingPx
                params.rightMargin = 0
                child.layoutParams = params
            }
        }

        // 重新布局子View
        recycler?.let {
            detachAndScrapAttachedViews(it)
            super.onLayoutChildren(it, state)
        }
    }
}

使用的时候超简单，直接给RecyclerView赋值就行：

// 这里的16是你要的最小项间距（单位dp）
recyclerView.layoutManager = UniformHorizontalLayoutManager(context, 16)

方案二：ItemDecoration + Adapter动态宽度计算 #

如果你不想自定义LayoutManager，这个组合方案也能搞定，比你之前的手动方法简洁不少：

第一步：写个处理间距的ItemDecoration #

class HorizontalItemSpacingDecoration(private val spacingPx: Int) : RecyclerView.ItemDecoration() {
    override fun getItemOffsets(
        outRect: Rect,
        view: View,
        parent: RecyclerView,
        state: RecyclerView.State
    ) {
        val position = parent.getChildAdapterPosition(view)
        // 给除了第一个item之外的所有item设置左边间距
        if (position != 0) {
            outRect.left = spacingPx
        }
    }
}

第二步：在Adapter里动态计算item宽度 #

class MyHorizontalAdapter(
    private val dataList: List<String>,
    private val minSpacingDp: Int
) : RecyclerView.Adapter<MyHorizontalAdapter.ViewHolder>() {

    private var recyclerViewAvailableWidth = 0
    private var minSpacingPx = 0

    override fun onAttachedToRecyclerView(recyclerView: RecyclerView) {
        super.onAttachedToRecyclerView(recyclerView)
        // 获取RecyclerView的可用宽度
        recyclerViewAvailableWidth = recyclerView.width - recyclerView.paddingLeft - recyclerView.paddingRight
        // 把dp转成px
        minSpacingPx = TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP,
            minSpacingDp.toFloat(),
            recyclerView.resources.displayMetrics
        ).toInt()
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_horizontal, parent, false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.tvContent.text = dataList[position]

        // 预测量item的原始宽度
        holder.itemView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED)
        val itemRawWidth = holder.itemView.measuredWidth

        // 计算所有item+最小间距的总宽度
        val totalRequiredWidth = itemRawWidth * itemCount + minSpacingPx * (itemCount - 1)

        if (totalRequiredWidth <= recyclerViewAvailableWidth) {
            // 能完全显示：设置均匀分配的宽度
            val targetItemWidth = (recyclerViewAvailableWidth - minSpacingPx * (itemCount - 1)) / itemCount
            holder.itemView.layoutParams.width = targetItemWidth
        } else {
            // 不能完全显示：保持item原始宽度
            holder.itemView.layoutParams.width = itemRawWidth
        }
    }

    inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val tvContent: TextView = itemView.findViewById(R.id.tv_content)
    }
}

第三步：给RecyclerView配置好 #

val adapter = MyHorizontalAdapter(yourDataList, 16)
recyclerView.apply {
    this.adapter = adapter
    addItemDecoration(HorizontalItemSpacingDecoration(adapter.minSpacingPx))
    layoutManager = LinearLayoutManager(context, LinearLayoutManager.HORIZONTAL, false)
}

补充：为什么之前用weight没效果？ #

因为横向LinearLayout的weight是强制基于父容器宽度平分空间，不管item的内容和数量——当item数量多的时候，每个item会被挤得特别小，完全不符合你"放不下就滚动、保持item自身宽度"的需求。而上面的方案会先判断是否能完全显示，再决定是平分宽度还是保留原始宽度，这才是你要的逻辑。

内容的提问来源于stack exchange，提问作者Florian Hansen