一、前言

之前的方法在某些情况下使用会有问题，这个新的类适配了各种情况，可以在线下布局，网格布局，垂直，水平方向上都能实现很好的分隔效果。

二、使用方法详解

  1.        val build = IntervalItemDecoration.Builder()
  2.             .divider(space)//设置每个 item 之间的间距
  3. //            .dividerHorrizontal(space)//设置 item 左右间隔
  4. //            .dividerVertical(space)//设置 item 上下间隔
  5.             .margin(space)//设置 recyclerview 四周间隔
  6. //            .horriontalMargin(space)//设置 recyclerview 左右间隔
  7. //            .verticalMargin(space * 2)//设置 recyclerview上下间隔
  8. //            .leftMargin(space)//单独设置 recyclerview 左边间隔
  9. //            .rightMargin(space)//单独设置 recyclerview 右边间隔
  10. //            .topMargin(space)//单独设置 recyclerview 上边间隔
  11. //            .bottomMargin(space)//单独设置 recyclerview 下边间隔
  12.             .build()

三、详细代码和引入地址

  1. class IntervalItemDecoration private constructor(private val builder: Builder) :
  2.     RecyclerView.ItemDecoration() {
  3.     //每个 item 上下左右两侧间隔
  4.     private var divider = 0
  6.     // 每个item左右两侧的间距
  7.     private var dividerHorrizontal = 0
  9.     // 每个item上下的间距
  10.     private var dividerVertical = 0
  12.     //整个 recyclerview 间距
  13.     private var margin = 0
  15.     //整个 recyclerview 左右间距
  16.     private var horriontalMargin = 0
  18.     //整个 recyclerview 上下间距
  19.     private var verticalMargin = 0
  21.     // 整个RecyclerView的左间距
  22.     private var leftMargin = 0
  24.     // 整个RecyclerView的顶部间距
  25.     private var topMargin = 0
  27.     // 整个RecyclerView的右间距
  28.     private var rightMargin = 0
  30.     // 整个RecyclerView的底部间距
  31.     private var bottomMargin = 0
  33.     override fun getItemOffsets(
  34.         outRect: Rect,
  35.         view: View,
  36.         parent: RecyclerView,
  37.         state: RecyclerView.State
  38.     ) {
  39.         super.getItemOffsets(outRect, view, parent, state)
  40.         // 得到当前Item在RecyclerView中的位置,从0开始
  41.         // 得到当前Item在RecyclerView中的位置,从0开始
  42.         val position = parent.getChildAdapterPosition(view)
  43.         // 得到RecyclerView中Item的总个数
  44.         // 得到RecyclerView中Item的总个数
  45.         val count = parent.adapter!!.itemCount
  46.         if (parent.layoutManager is GridLayoutManager) { // 网格布局
  47.             val gridLayoutManager =
  48.                 parent.layoutManager as GridLayoutManager?
  49.             // 得到网格布局的列数
  50.             val spanCount = gridLayoutManager!!.spanCount
  51.             // 判断该网格布局是水平还是垂直
  52.             if (LinearLayoutManager.VERTICAL == gridLayoutManager.orientation) { // 垂直
  53.                 if (spanCount == 1) { // 列数为1
  54.                     verticalColumnOne(outRect, position, count)
  55.                 } else { // 列数大于1
  56.                     verticalColumnMulti(outRect, position, count, spanCount)
  57.                 }
  58.             } else if (LinearLayoutManager.HORIZONTAL == gridLayoutManager.orientation) { // 水平
  59.                 if (spanCount == 1) { // 行数为1
  60.                     horizontalColumnOne(outRect, position, count)
  61.                 } else { // 行数大于1
  62.                     horizontalColumnMulti(outRect, position, count, spanCount)
  63.                 }
  64.             }
  65.         } else if (parent.layoutManager is LinearLayoutManager) { // 线性布局
  66.             val layoutManager =
  67.                 parent.layoutManager as LinearLayoutManager?
  68.             if (LinearLayoutManager.VERTICAL == layoutManager!!.orientation) { // 垂直
  69.                 verticalColumnOne(outRect, position, count)
  70.             } else if (LinearLayoutManager.HORIZONTAL == layoutManager.orientation) { // 水平
  71.                 horizontalColumnOne(outRect, position, count)
  72.             }
  73.         } else if (parent.layoutManager is StaggeredGridLayoutManager) { // 流布局
  74.             //TODO 瀑布流布局相关
  75.         }
  76.     }
  78.     /**
  79.      * 列表垂直且列数为1
  80.      *
  81.      * @param outRect  包括左上右下四个参数，分别控制view左上右下的margin
  82.      * @param position 当前view所处位置
  83.      * @param count    RecyclerView中Item的总个数
  84.      */
  85.     private fun verticalColumnOne(
  86.         outRect: Rect,
  87.         position: Int,
  88.         count: Int
  89.     ) {
  90.         when (position) {
  91.             0 -> { // 位置为0时(即第一个Item)，不设置底部间距
  92.                 outRect[leftMargin, topMargin, rightMargin] = 0
  93.             }
  94.             count - 1 -> { // 最后一个Item
  95.                 outRect[leftMargin, dividerVertical, rightMargin] = bottomMargin
  96.             }
  97.             else -> { // 中间的Item，不设置底部间距
  98.                 outRect[leftMargin, dividerVertical, rightMargin] = 0
  99.             }
  100.         }
  101.     }
  103.     /**
  104.      * 列表垂直且列数大于1
  105.      *
  106.      * @param outRect   包括左上右下四个参数，分别控制view左上右下的margin
  107.      * @param position  当前view所处位置
  108.      * @param count     RecyclerView中Item的总个数
  109.      * @param spanCount 布局的列数
  110.      */
  111.     private fun verticalColumnMulti(
  112.         outRect: Rect,
  113.         position: Int,
  114.         count: Int,
  115.         spanCount: Int
  116.     ) {
  117.         // 由于是网格布局，故每个item宽度是固定的，这里计算出每个item的左右边距之和
  118.         val mEachSpace: Int =
  119.             (leftMargin + rightMargin + (spanCount - 1) * dividerHorrizontal) / spanCount
  120.         // 通过计算得出总行数
  121.         val totalRow = count / spanCount + if (count % spanCount == 0) 0 else 1
  122.         // 计算得出当前view所在的行
  123.         val row = position / spanCount
  124.         val column = position % spanCount
  125.         val diff = (mEachSpace - rightMargin - leftMargin) / (spanCount - 1)
  126.         val left = (column + 1 - 1) * diff + leftMargin
  127.         val right = mEachSpace - left
  128.         when (row) {
  129.             0 -> {
  130.                 outRect[left, topMargin, right] = dividerVertical
  131.             }
  132.             totalRow - 1 -> {
  133.                 outRect[left, 0, right] = bottomMargin
  134.             }
  135.             else -> {
  136.                 outRect[left, 0, right] = dividerVertical
  137.             }
  138.         }
  139.     }
  141.     /**
  142.      * 列表水平且行数为1
  143.      *
  144.      * @param outRect  包括左上右下四个参数，分别控制view左上右下的margin
  145.      * @param position 当前view所处位置
  146.      * @param count    RecyclerView中Item的总个数
  147.      */
  148.     private fun horizontalColumnOne(
  149.         outRect: Rect,
  150.         position: Int,
  151.         count: Int
  152.     ) {
  153.         when (position) {
  154.             0 -> { // 位置为0时(即第一个Item)
  155.                 outRect[leftMargin, topMargin, dividerHorrizontal / 2] = bottomMargin
  156.             }
  157.             count - 1 -> { // 最后一个Item
  158.                 outRect[dividerHorrizontal / 2, topMargin, rightMargin] = bottomMargin
  159.             }
  160.             else -> { // 中间的Item
  161.                 outRect[dividerHorrizontal / 2, topMargin, dividerHorrizontal / 2] = bottomMargin
  162.             }
  163.         }
  164.     }
  166.     /**
  167.      * 列表水平且行数大于1
  168.      *
  169.      * @param outRect   包括左上右下四个参数，分别控制view左上右下的margin
  170.      * @param position  当前view所处位置
  171.      * @param count     RecyclerView中Item的总个数
  172.      * @param spanCount 布局的行数
  173.      */
  174.     private fun horizontalColumnMulti(
  175.         outRect: Rect,
  176.         position: Int,
  177.         count: Int,
  178.         spanCount: Int
  179.     ) {
  180.         // 通过计算得出总列数
  181.         val totalColumn = count / spanCount + if (count % spanCount == 0) 0 else 1
  182.         // 计算得出当前view所在的列
  183.         val column = position / spanCount
  184.         // 通过对position加1对spanCount取余得到row
  185.         // 保证row等于1为第一行，等于0为最后一个，其它值为中间行
  186.         val row = (position + 1) % spanCount
  187.         val mEachSpace: Int =
  188.             (topMargin + bottomMargin + (spanCount - 1) * dividerVertical) / spanCount
  189.         val diff = (mEachSpace - bottomMargin - topMargin) / (spanCount - 1)
  190.         val top = (position % spanCount + 1 - 1) * diff + topMargin
  191.         val bottom = mEachSpace - top
  192.         when (row) {
  193.             1 -> {
  194.                 outRect[if (column == 0) leftMargin else dividerHorrizontal / 2, top, if (column == totalColumn - 1) rightMargin else dividerHorrizontal / 2] =
  195.                     bottom
  196.             }
  197.             0 -> {
  198.                 outRect[if (column == 0) leftMargin else dividerHorrizontal / 2, top, if (column == totalColumn - 1) rightMargin else dividerHorrizontal / 2] =
  199.                     bottom
  200.             }
  201.             else -> {
  202.                 outRect[if (column == 0) leftMargin else dividerHorrizontal / 2, top, if (column == totalColumn - 1) rightMargin else dividerHorrizontal / 2] =
  203.                     bottom
  204.             }
  205.         }
  206.     }
  209.     class Builder {
  210.         private val iid = IntervalItemDecoration(this)
  211.         fun divider(divider: Int): Builder {
  212.             iid.divider = divider
  213.             return this
  214.         }
  216.         fun dividerHorrizontal(dividerHorrizontal: Int): Builder {
  217.             iid.dividerHorrizontal = dividerHorrizontal
  218.             return this
  219.         }
  221.         fun dividerVertical(dividerVertical: Int): Builder {
  222.             iid.dividerVertical = dividerVertical
  223.             return this
  224.         }
  226.         fun margin(margin: Int): Builder {
  227.             iid.margin = margin
  228.             return this
  229.         }
  231.         fun horriontalMargin(horriontalMargin: Int): Builder {
  232.             iid.horriontalMargin = horriontalMargin
  233.             return this
  234.         }
  236.         fun verticalMargin(verticalMargin: Int): Builder {
  237.             iid.verticalMargin = verticalMargin
  238.             return this
  239.         }
  241.         fun leftMargin(leftMargin: Int): Builder {
  242.             iid.leftMargin = leftMargin
  243.             return this
  244.         }
  246.         fun topMargin(topMargin: Int): Builder {
  247.             iid.topMargin = topMargin
  248.             return this
  249.         }
  251.         fun rightMargin(rightMargin: Int): Builder {
  252.             iid.rightMargin = rightMargin
  253.             return this
  254.         }
  256.         fun bottomMargin(bottomMargin: Int): Builder {
  257.             iid.bottomMargin = bottomMargin
  258.             return this
  259.         }
  261.         fun build(): IntervalItemDecoration {
  262.             initSet()
  263.             return iid
  264.         }
  266.         private fun initSet() {
  267.             iid.run {
  268.                 if (divider != 0) {
  269.                     dividerHorrizontal = divider
  270.                     dividerVertical = divider
  271.                 }
  272.                 if (margin != 0) {
  273.                     leftMargin = margin
  274.                     rightMargin = margin
  275.                     topMargin = margin
  276.                     bottomMargin = margin
  277.                 }
  278.                 if (verticalMargin != 0) {
  279.                     topMargin = verticalMargin
  280.                     bottomMargin = verticalMargin
  281.                 }
  282.                 if (horriontalMargin != 0) {
  283.                     leftMargin = horriontalMargin
  284.                     rightMargin = horriontalMargin
  285.                 }
  286.             }
  288.         }
  289.     }
  290. }

StickyDecration