深入浅出 RecyclerView - 张涛

compile 'com.android.support:recyclerview-v7:24.0.0'

RecyclerView recyclerview = (RecyclerView)  findViewById(R.id.recyclerview);

recyclerview.setLayoutManager(new LinearLayoutManager( this, LinearLayoutManager.VERTICAL, false));

RecyclerView 将所有的显示规则交给一个叫 LayoutManager 的类去完成了。

LayoutManager是一个抽象类，系统已经为我们提供了三个默认的实现类，分别是 LinearLayoutManager 、 GridLayoutManager 、 StaggeredGridLayoutManager ，从名字我们就能看出来了，分别是，线性显示、网格显示、瀑布流显示。当然你也可以通过继承这些类来扩展实现自己的 LayougManager 。

recyclerview.setAdapter(adapter);

适配器，同 ListView 一样，用来设置每个item显示内容的。

通常，我们写 ListView 适配器，都是首先继承 BaseAdapter ，实现四个抽象方法，创建一个静态 ViewHolder ， getView() 方法中判断 convertView 是否为空，创建还是获取 viewholder 对象。

而 RecyclerView 也是类似的步骤，首先继承 RecyclerView.Adapter<VH> 类，实现三个抽象方法，创建一个静态的 ViewHolder 。不过 RecyclerView 的 ViewHolder 创建稍微有些限制，类名就是上面继承的时候泛型中声明的类名(好像反了，应该是上面泛型中的类名应该是这个holder的类名)；并且 ViewHolder 必须继承自 RecyclerView.ViewHolder 类。

public class DemoAdapter extends RecyclerView.Adapter<DemoAdapter.VH> {     private List<Data> dataList;     private Context context;      public DemoAdapter(Context context, ArrayList<Data> datas) {         this.dataList = datas;         this.context = context;     }      @Override     public VH onCreateViewHolder(ViewGroup parent, int viewType) {         return new VH(View.inflate(context, android.R.layout.simple_list_item_2, null));     }      @Override     public void onBindViewHolder(VH holder, int position) {         holder.mTextView.setText(dataList.get(position).getNum());     }      @Override     public int getItemCount() {         return dataList.size();     }      public static class VH extends RecyclerView.ViewHolder {         TextView mTextView;         public VH(View itemView) {             super(itemView);             mTextView = (TextView) itemView.findViewById(android.R.id.text1);         }     } }

前面已经介绍过， RecyclerView 实现瀑布流，可以通过一句话设置： recycler.setLayoutManager(new StaggeredGridLayoutManager(2, VERTICAL)) 就可以了。

其中 StaggeredGridLayoutManager 第一个参数表示列数，就好像 GridView 的列数一样，第二个参数表示方向，可以很方便的实现横向滚动或者纵向滚动。

使用 demo 可以查看：Github 【 RecyclerView简单使用 】

同 ListView 每次修改了数据源后，都要调用 notifyDataSetChanged() 刷新每项 item 类似，只不过 RecyclerView 还支持局部刷新 notifyItemInserted(index); 、 notifyItemRemoved(position) 、 notifyItemChanged(position) 。

在添加或删除了数据后， RecyclerView 还提供了一个默认的动画效果，来改变显示。同时，你也可以定制自己的动画效果：模仿 DefaultItemAnimator 或直接继承这个类，实现自己的动画效果，并调用 recyclerview.setItemAnimator(new DefaultItemAnimator()); 设置上自己的动画。

使用 demo 可以查看：Github 【 RecyclerView默认动画 】

findFirstVisibleItemPosition() 返回当前第一个可见 Item 的 position

findFirstCompletelyVisibleItemPosition() 返回当前第一个完全可见 Item 的 position

findLastVisibleItemPosition() 返回当前最后一个可见 Item 的 position

findLastCompletelyVisibleItemPosition() 返回当前最后一个完全可见 Item 的 position.

scrollBy() 滚动到某个位置。

其实很早之前写过一篇关于 RecyclerView 适配器的封装，所以这不再赘述了，传送门： RecyclerView的通用适配器

使用 demo 可以查看：Github 【 RecyclerView通用适配器演示 】

用习惯了 ListView 的 OnItemClickListener ， RecyclerView 你的 OnItemClickListener 呢？

Tell me where do I find, something like ListView listener ?

好吧，翻遍了 API 列表，就找到了个 OnItemTouchListener ，这特么什么鬼，我干嘛要对每个 item 监听触摸屏事件。

万万没想到，最终我还是在 Google IO 里面的介绍找到了原因。原来是 Google 的工程师分不清究竟是改给 listview 的 item 添加点击事件，还是应该给每个 item 的 view 添加点击事件，索性就不给 OnItemClickListener 了，然后在 support demo 里面，你就会发现， RecyclerView 的 item 点击事件都是写在了 adapter 的 ViewHolder 里面。

android:divider="@android:color/black" android:dividerHeight="2dp"

而在 RecyclerView 里面，想实现这两种需求，稍微复杂一点，需要自己继承 RecyclerView.ItemDecoration 来实现想要实现的方法。

虽说这样写灵活多了，但是要额外写一个类去做难免麻烦，这里大家可以看我已经实现好的一个封装，包括 显示纯色divider 、 显示图片divider 、 divider的上下左右的间距 、 宽高设置 应该可以满足基本需求了： Divider.java

使用 demo 可以查看：Github 【 自定义 Divider 使用 】

借用 Google IO 视频中的一张截图：

视频的完整地址可查看: RecyclerView ins and outs - Google I/O 2016

java.lang.Object      ↳ android.view.View           ↳ android.view.ViewGroup               ↳ android.support.v7.widget.RecyclerView

首先是适配器，适配器的作用都是类似的，用于提供每个 item 视图，并返回给 RecyclerView 作为其子布局添加到内部。

但是，与 ListView 不同的是，ListView 的适配器是直接返回一个 View，将这个 View 加入到 ListView 内部。而 RecyclerView 是返回一个 ViewHolder 并且不是直接将这个 holder 加入到视图内部，而是加入到一个缓存区域，在视图需要的时候去缓存区域找到 holder 再间接的找到 holder 包裹的 View。

还是一张截图

RecyclerView 的内部维护了一个二级缓存，滑出界面的 ViewHolder 会暂时放到 cache 结构中，而从 cache 结构中移除的 ViewHolder，则会放到一个叫做 RecycledViewPool 的循环缓存池中。

顺带一说，RecycledView 的性能并不比 ListView 要好多少，它最大的优势在于其扩展性。但是有一点，在 RecycledView 内部的这个第二级缓存池 RecycledViewPool 是可以被多个 RecyclerView 共用的，这一点比起直接缓存 View 的 ListView 就要高明了很多，但也正是因为需要被多个 RecyclerView 公用，所以我们的 ViewHolder 必须继承自同一个基类(即RecyclerView.ViewHolder)。

默认的情况下，cache 缓存 2 个 holder，RecycledViewPool 缓存 5 个 holder。对于二级缓存池中的 holder 对象，会根据 viewType 进行分类，不同类型的 viewType 之间互不影响。

既然是一个 View ,我们先从 onMeasure() 开始看。

之前我们就说了 RecyclerView 的 measure 和 layout 都是交给了 LayoutManager 去做的，来看一下为什么：

if (mLayout.mAutoMeasure) {     final int widthMode = MeasureSpec.getMode(widthSpec);     final int heightMode = MeasureSpec.getMode(heightSpec);     final boolean skipMeasure = widthMode == MeasureSpec.EXACTLY             && heightMode == MeasureSpec.EXACTLY;     mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec); } else {     mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec); }

我们挑选 LinearLayoutManager 来看

发现它并没有 onMeasure() 方法，LinearLayoutManager 直接继承自 LayoutManager，所以又回到了父类 LayoutManager 中。

void defaultOnMeasure(int widthSpec, int heightSpec) {     // calling LayoutManager here is not pretty but that API is already public and it is better     // than creating another method since this is internal.     final int width = LayoutManager.chooseSize(widthSpec,             getPaddingLeft() + getPaddingRight(),             ViewCompat.getMinimumWidth(this));     final int height = LayoutManager.chooseSize(heightSpec,             getPaddingTop() + getPaddingBottom(),             ViewCompat.getMinimumHeight(this));      setMeasuredDimension(width, height); }

public static int chooseSize(int spec, int desired, int min) {     final int mode = View.MeasureSpec.getMode(spec);     final int size = View.MeasureSpec.getSize(spec);     switch (mode) {         case View.MeasureSpec.EXACTLY:             return size;         case View.MeasureSpec.AT_MOST:             return Math.min(size, Math.max(desired, min));         case View.MeasureSpec.UNSPECIFIED:         default:             return Math.max(desired, min);     } }

然后我们来看 layout 过程. 在 onLayout() 方法中间接的调用到了这么一个方法： dispatchLayoutStep2() ，在它之中又调用到了 mLayout.onLayoutChildren(mRecycler, mState);

我们重点看这个 onLayoutChildren() 方法。

这个方法在 LayoutManager 中的实现是空的，那么想必是在子类中实现了吧。还是找 LinearLayoutManager ，跟上面 measure 过程一样，调用了 dispatchLayoutStep2() 跟进去发现这么一个方法：

fill(recycler, mLayoutState, state, false);

while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {     layoutChunk(recycler, state, layoutState, layoutChunkResult);     layoutState.mOffset += layoutChunkResult.mConsumed * layoutState.mLayoutDirection;      if (layoutState.mScrollingOffset != LayoutState.SCOLLING_OFFSET_NaN) {         layoutState.mScrollingOffset += layoutChunkResult.mConsumed;         if (layoutState.mAvailable < 0) {             layoutState.mScrollingOffset += layoutState.mAvailable;         }         recycleByLayoutState(recycler, layoutState);     } }

fill() 作用就是根据当前状态决定是应该从缓存池中取 itemview 填充 还是应该回收当前的 itemview。

其中，layoutChunk() 负责从缓存池 recycler 中取 itemview，并调用 View.addView() 将获取到的 ItemView 添加到 RecyclerView 中去，并调用 itemview 自身的 layout 方法去布局 item 位置。

同时在这里，还调用了 measureChildWithMargins() 来测绘子控件大小以及设置显示位置。这一步，我们到下面的 draw 过程还要讲。

而这全部的添加逻辑都放在一个 while 循环里面，不停的添加 itemview 到 recyclerview 里面，直到塞满所有可见区域为止。

@Override public void onDraw(Canvas c) {     super.onDraw(c);     final int count = mItemDecorations.size();     for (int i = 0; i < count; i++) {         mItemDecorations.get(i).onDraw(c, this, mState);     } }

在 onDraw() 中，除了绘制自己以外，还多调了一个 mItemDecorations 的 onDraw() 方法，这个 mItemDecorations 就是前面吐槽的分隔线的集合。

之前在讲 RecyclerView 的五虎上将的时候就讲过这个 ItemDecoration。 当时我们还重写了一个方法叫 getItemOffsets() 目的是为了不让 itemview 挡住分隔线。那他是在哪调用的呢？

还记得 layout 时说的那个 measureChildWithMargins() 吗，就是在这里：

public void measureChildWithMargins(View child, int widthUsed, int heightUsed) {     final Rect insets = mRecyclerView.getItemDecorInsetsForChild(child);     widthUsed += insets.left + insets.right;     heightUsed += insets.top + insets.bottom;      if (shouldMeasureChild(child, widthSpec, heightSpec, lp)) {         child.measure(widthSpec, heightSpec);     } }

前面我们已经完整的走完了 RecyclerView 的绘制流程。接下来我们再看看它在滚动的时候代码又是怎么调用的。

说到滚动，自然要看 onTouch() 方法的 MOVE 状态。

case MotionEvent.ACTION_MOVE: {     final int index = MotionEventCompat.findPointerIndex(e, mScrollPointerId);     final int x = (int) (MotionEventCompat.getX(e, index) + 0.5f);     final int y = (int) (MotionEventCompat.getY(e, index) + 0.5f);     int dx = mLastTouchX - x;     int dy = mLastTouchY - y;      if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {    ...     }      if (mScrollState != SCROLL_STATE_DRAGGING) {   ...         if (startScroll) {             setScrollState(SCROLL_STATE_DRAGGING);         }     }      if (mScrollState == SCROLL_STATE_DRAGGING) {         mLastTouchX = x - mScrollOffset[0];         mLastTouchY = y - mScrollOffset[1];          if (scrollByInternal(                 canScrollHorizontally ? dx : 0,                 canScrollVertically ? dy : 0,                 vtev)) {             getParent().requestDisallowInterceptTouchEvent(true);         }     } } break;

case MotionEvent.ACTION_CANCEL: {     cancelTouch(); } break;  case MotionEvent.ACTION_UP: {     mVelocityTracker.addMovement(vtev);     mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);     final float yvel = canScrollVertically ?             -VelocityTrackerCompat.getYVelocity(mVelocityTracker, mScrollPointerId) : 0;     if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {         setScrollState(SCROLL_STATE_IDLE);     }     resetTouch(); } break;

ACTION_CANCEL 里面只有一个 cancelTouch() ,那么自然是在 UP 状态里面实现的惯性滚动。

看到了一个 mVelocityTracker 对象，大概原理也就清楚了，惯性滚动多长，肯定是跟手指移动的速度有关了。

再进：

mScroller.fling(0, 0, velocityX, velocityY,                     Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);

public final class Recycler { final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>(); private ArrayList<ViewHolder> mChangedScrap = null;  final ArrayList<ViewHolder> mCachedViews = new ArrayList<ViewHolder>();  private final List<ViewHolder>         mUnmodifiableAttachedScrap = Collections.unmodifiableList(mAttachedScrap);  private RecycledViewPool mRecyclerPool;  private ViewCacheExtension mViewCacheExtension;

public static class RecycledViewPool {    // 根据 viewType 保存的被废弃的 ViewHolder 集合，以便下次使用  private SparseArray<ArrayList<ViewHolder>> mScrap = new SparseArray<ArrayList<ViewHolder>>();   /**    * 从缓存池移除并返回一个 ViewHolder    */   public ViewHolder getRecycledView(int viewType) {     final ArrayList<ViewHolder> scrapHeap = mScrap.get(viewType);     if (scrapHeap != null && !scrapHeap.isEmpty()) {       final int index = scrapHeap.size() - 1;       final ViewHolder scrap = scrapHeap.get(index);       scrapHeap.remove(index);       return scrap;     }       return null;     }     public void putRecycledView(ViewHolder scrap) {     final int viewType = scrap.getItemViewType();     final ArrayList scrapHeap = getScrapHeapForType(viewType);     if (mMaxScrap.get(viewType) <= scrapHeap.size()) {       return;     }     scrap.resetInternal();     scrapHeap.add(scrap);   }     /**    * 根据 viewType 获取对应缓存池    */   private ArrayList<ViewHolder> getScrapHeapForType(int viewType) {     ArrayList<ViewHolder> scrap = mScrap.get(viewType);       if (scrap == null) {         scrap = new ArrayList<>();         mScrap.put(viewType, scrap);           if (mMaxScrap.indexOfKey(viewType) < 0) {             mMaxScrap.put(viewType, DEFAULT_MAX_SCRAP);           }       }     return scrap;   } }

从名字来看，他是一个缓存池，实现上，是通过一个默认为 5 大小的 ArrayList 实现的。这一点，同 ListView 的 RecyclerBin 这个类一样。很奇怪为什么不用 LinkedList 来做，按理说这种不需要索引读取的缓存池，用链表是最合适的。

然后每一个 ArrayList 又都是放在一个 Map 里面的， SparseArray 这个类我们在讲性能优化的时候已经多次提到了，就是两个数组，用来替代 Map 的。

把所有的 ArrayList 放在一个 Map 里面，这也是 RecyclerView 最大的亮点，这样根据 itemType 来取不同的缓存 Holder，每一个 Holder 都有对应的缓存，而只需要为这些不同 RecyclerView 设置同一个 Pool 就可以了。

这一点我们在 Pool 的 setter 方法上可以看到注释：

/**  * Recycled view pools allow multiple RecyclerViews to share a common pool of scrap views.  * This can be useful if you have multiple RecyclerViews with adapters that use the same  * view types, for example if you have several data sets with the same kinds of item views  * displayed by a {@link android.support.v4.view.ViewPager ViewPager}.  *  * @param pool Pool to set. If this parameter is null a new pool will be created and used.  */ public void setRecycledViewPool(RecycledViewPool pool) {     mRecycler.setRecycledViewPool(pool); }

写了这么多累死我了，就这样吧，最后发一个 demo 地址： RecyclerViewDemo

和一份内部分享的 PPT 地址： RecyclerView PPT

打赏支持 :kissing_heart::kissing_heart::kissing_heart: