为什么提出来RecycleView？
RecyclerView提供了一种插拔式的体验，高度解耦，使用灵活。RecyclerView只管回收与复用View，通过设置LayoutManager，ItemDecoration , ItemAnimator实现各种特效，达到自由定制的目的，如实现ListView、GridView、瀑布流效果等。
有什么特点，适用场景？
优点：
- 标准化了ViewHolder，编写Adapter面向的是ViewHolder而不再是View了，复用的逻辑被封装了，写起来更加简单。
- 设置布局管理器以控制Item的布局方式，横向、竖向以及瀑布流方式。
- 可设置Item的间隔样式（可绘制），通过继承RecyclerView的ItemDecoration这个类，然后针对自己的业务需求去书写代码。
- 可以控制Item增删的动画，可以通过ItemAnimator这个类进行控制，当然针对增删的动画，RecyclerView有其自己默认的实现。
缺点：
- 关于Item的点击和长按事件，需要用户自己去实现。
- 使用成本相对高一些；
五大组成
RecyclerView由layoutManager，Adapter，ItemAnimator，ItemDecoration，ViewHolder五大核心组件。五个组件分别负责不同的功能，组合成为功能强大拓展性强的RecyclerView。
| 组件 | 功能 |
|---|---|
| LayoutManager | 负责测量和布局 |
| Adapter | 负责数据和视图的绑定 |
| ViewHolder | 视图的载体 |
| ItemAnimator | 负责Item View的动画（包括移除，增加，改变等） |
| ItemDecoration | 负责Item View的间距控制和装饰 |
LayoutManager（布局管理器）
LayoutManager负责RecyclerView的布局，其中包含了Item View的获取与回收。RecyclerView提供了3种布局管理器：
1）LinearLayoutManager：以垂直或者水平列表方式展示Item
2）GridLayoutManager：以网格方式展示Item
3）StaggeredGridLayoutManager：以瀑布流方式展示Item
Adapter（适配器）
1. 创建适配器的一般步骤
1） 创建Adapter
创建一个继承RecyclerView.Adapter
2）创建ViewHolder
在Adapter中创建一个继承RecyclerView.ViewHolder的静态内部类，记为VH。ViewHolder的实现和ListView的ViewHolder实现几乎一样。
3）在Adapter中实现3个方法
| 方法 | 含义 |
|---|---|
| onCreateViewHolder() | 此方法把View直接封装在ViewHolder中，在以后使用ViewHolder代替View |
| onBindViewHolder() | 方法提供viewHolder而不是原来的convertView，将数据设置到viewHolder中 |
| getItemCount() | 类似于BaseAdapter的getCount方法了，即总共有多少个条目 |
说明：可以看出，RecyclerView将ListView中getView()的功能拆分成了onCreateViewHolder()和onBindViewHolder()。
基本的Adapter实现如下：
// ① 创建Adapter
public class NormalAdapter extends RecyclerView.Adapter{
//② 创建ViewHolder
public static class VH extends RecyclerView.ViewHolder{
public final TextView title;
public VH(View v) {
super(v);
title = (TextView) v.findViewById(R.id.title);
}
}
private List mDatas;
public NormalAdapter(List data) {
this.mDatas = data;
}
//③ 在Adapter中实现3个方法
@Override
public VH onCreateViewHolder(ViewGroup parent, int viewType) {
//LayoutInflater.from指定写法
View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_1, parent, false);
return new VH(v);
}
@Override
public void onBindViewHolder(VH holder, int position) {
holder.title.setText(mDatas.get(position));
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//item 点击事件
}
});
}
@Override
public int getItemCount() {
return mDatas.size();
}
}
2. 万能适配器
为了创建一个RecyclerView的Adapter，每次我们都需要去做重复劳动，包括重写onCreateViewHolder()、onBindViewHolder()、getItemCount()，并且实现过程大同小异，因此万能适配器出现了。
我们通过public abstract class QuickAdapter
ublic abstract class QuickAdapter extends RecyclerView.Adapter{
private List mDatas;
public QuickAdapter(List datas){
this.mDatas = datas;
}
public abstract int getLayoutId(int viewType);
@Override
public VH onCreateViewHolder(ViewGroup parent, int viewType) {
return VH.get(parent,getLayoutId(viewType));
}
@Override
public void onBindViewHolder(VH holder, int position) {
convert(holder, mDatas.get(position), position);
}
@Override
public int getItemCount() {
return mDatas.size();
}
public abstract void convert(VH holder, T data, int position);
static class VH extends RecyclerView.ViewHolder{
private SparseArray mViews;
private View mConvertView;
private VH(View v){
super(v);
mConvertView = v;
mViews = new SparseArray<>();
}
public static VH get(ViewGroup parent, int layoutId){
View convertView = LayoutInflater.from(parent.getContext()).inflate(layoutId, parent, false);
return new VH(convertView);
}
public T getView(int id){
View v = mViews.get(id);
if(v == null){
v = mConvertView.findViewById(id);
mViews.put(id, v);
}
return (T)v;
}
}
}
1）万能ViewHolder
其中的关键点在于通过SparseArray
2）万能适配器
- getLayoutId(int viewType)是根据viewType返回布局ID；
- convert()做具体的bind操作；
通过万能适配器快捷创建一个Adapter：
mAdapter = new QuickAdapter(data) {
@Override
public int getLayoutId(int viewType) {
switch(viewType){
case TYPE_1:
return R.layout.item_1;
case TYPE_2:
return R.layout.item_2;
}
}
@Override
public int getItemViewType(int position) {
if(position % 2 == 0){
return TYPE_1;
} else{
return TYPE_2;
}
}
@Override
public void convert(VH holder, Model data, int position) {
int type = getItemViewType(position);
switch(type){
case TYPE_1:
holder.setText(R.id.text, data.text);
break;
case TYPE_2:
holder.setImage(R.id.image, data.image);
break;
}
}
};
ItemDecoration（间隔样式）
作用：item之间的间隔样式。
- 接口定义
public static abstract class ItemDecoration {
public void onDraw(Canvas c, RecyclerView parent, State state) {
onDraw(c, parent);
}
public void onDrawOver(Canvas c, RecyclerView parent, State state) {
onDrawOver(c, parent);
}
public void getItemOffsets(Rect outRect, View view, RecyclerView parent, State state) {
getItemOffsets(outRect, ((LayoutParams) view.getLayoutParams()).getViewLayoutPosition(), parent);
}
@Deprecated
public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
outRect.set(0, 0, 0, 0);
}
}
说明：
① onDraw方法先于drawChildren；
② onDrawOver在drawChildren之后；
③ getItemOffsets 可以通过outRect.set()为每个Item设置一定的偏移量，主要用于绘制Decorator；
说明：系统自带的间隔样式是DividerItemDecoration。
ItemAnimator（动画）
RecyclerView能够通过mRecyclerView.setItemAnimator(ItemAnimator animator)设置添加、删除、移动、改变的动画效果。
系统提供默认实现类：DefaultItemAnimator
DefaultItemAnimator继承自SimpleItemAnimator，SimpleItemAnimator继承自ItemAnimator。DefaultItemAnimator的实现过程非常复杂，如果基于SimpleItemAnimator自定义动画类非常麻烦。开源动画recyclerview-animators
recyclerview-animators提供了一系列的Animator，比如FadeInAnimator,ScaleInAnimator。自定义动画继承BaseItemAnimator，更加方便；常见问题
1）局部刷新闪屏问题解决
问题描述：当Item视图中有图片和文字，当更新文字并调用notifyItemChanged()时，文字改变的同时图片会闪一下。
这个问题的原因是当调用notifyItemChanged()时，会调用DefaultItemAnimator的animateChangeImpl()执行change动画，该动画会使得Item的透明度从0变为1，从而造成闪屏。解决方便很简单禁用change动画，在rv.setAdapter()之前调用((SimpleItemAnimator)rv.getItemAnimator()).setSupportsChangeAnimations(false)。注意事项
notifyItemInserted(position)与notifyItemRemoved(position)进行更新，否则没有动画效果。
如何使用？
使用过程
引用 --> 布局 --> 创建适配器 --> 设置RecyclerView参数 --> 增加点击事件
具体步骤介绍
- 引用
在build.gradle文件中引入该类：
compile 'com.android.support:recyclerview-v7:23.4.0'
布局
① Activity布局文件；
② Item的布局文件；创建适配器
参看上面适配内容设置RecyclerView
一般来说，需要为RecyclerView进行四大设置:
① Layout Manager(必选)
② Adapter(必选)
③ Item Decoration(可选，默认为空)
④ Item Animator(可选，默认为DefaultItemAnimator)
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this );
layoutManager.setOrientation(OrientationHelper. VERTICAL);
//设置布局管理器
recyclerView.setLayoutManager(layoutManager);
//设置Adapter
recyclerView.setAdapter(recycleAdapter);
//设置分隔线
recyclerView.addItemDecoration( new DividerGridItemDecoration(this ));
//设置增加或删除条目的动画
recyclerView.setItemAnimator( new DefaultItemAnimator());
- 点击事件
RecyclerView并没有像ListView一样暴露出Item点击事件或者长按事件处理的api，也就是说使用RecyclerView时候，需要我们自己来实现Item的点击和长按等事件的处理。
实现方法有很多：
① 监听RecyclerView的Touch事件然后判断手势做相应的处理；
② 通过在绑定ViewHolder的时候设置监听，然后通过Apater回调出去；
我们选择第二种方法，更加直观和简单，其代码如下：
public class MyAdapter extends RecyclerView.Adapter{
// 展示数据
private ArrayList mData;
// 事件回调监听
private MyAdapter.OnItemClickListener onItemClickListener;
public MyAdapter(ArrayList data) {
this.mData = data;
}
public void updateData(ArrayList data) {
this.mData = data;
notifyDataSetChanged();
}
// 添加新的Item
public void addNewItem() {
if(mData == null) {
mData = new ArrayList<>();
}
mData.add(0, "new Item");
notifyItemInserted(0);
}
// 删除Item
public void deleteItem() {
if(mData == null || mData.isEmpty()) {
return;
}
mData.remove(0);
notifyItemRemoved(0);
}
// ① 定义点击回调接口
public interface OnItemClickListener {
void onItemClick(View view, int position);
void onItemLongClick(View view, int position);
}
// ② 定义一个设置点击监听器的方法
public void setOnItemClickListener(MyAdapter.OnItemClickListener listener) {
this.onItemClickListener = listener;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
// 实例化展示的view
View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.view_rv_item, parent, false);
// 实例化viewholder
ViewHolder viewHolder = new ViewHolder(v);
return viewHolder;
}
@Override
public void onBindViewHolder(final ViewHolder holder, int position) {
// 绑定数据
holder.mTv.setText(mData.get(position));
//③ 对RecyclerView的每一个itemView设置点击事件
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(final View v) {
if(onItemClickListener != null) {
int pos = holder.getLayoutPosition();
onItemClickListener.onItemClick(holder.itemView, pos);
}
}
});
holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
@Override
public boolean onLongClick(View v) {
if(onItemClickListener != null) {
int pos = holder.getLayoutPosition();
onItemClickListener.onItemLongClick(holder.itemView, pos);
}
//表示此事件已经消费，不会触发单击事件
return true;
}
});
}
@Override
public int getItemCount() {
return mData == null ? 0 : mData.size();
}
public static class ViewHolder extends RecyclerView.ViewHolder {
TextView mTv;
public ViewHolder(View itemView) {
super(itemView);
mTv = (TextView) itemView.findViewById(R.id.item_tv);
}
}
}
设置Adapter的事件监听：
mAdapter.setOnItemClickListener(new MyAdapter.OnItemClickListener() {
@Override
public void onItemClick(View view, int position) {
Toast.makeText(MDRvActivity.this,"click " + position + " item", Toast.LENGTH_SHORT).show();
}
@Override
public void onItemLongClick(View view, int position) {
Toast.makeText(MDRvActivity.this,"long click " + position + " item", Toast.LENGTH_SHORT).show();
}
});
拓展RecyclerView
添加HeaderView和FooterView
RecyclerView默认没有提供类似addHeaderView()和addFooterView()的API，因此这里介绍如何优雅地实现这两个接口。如果你已经实现了一个Adapter，现在想为这个Adapter添加addHeaderView()和addFooterView()接口，则需要在Adapter中添加几个Item Type，然后修改getItemViewType(),onCreateViewHolder(),onBindViewHolder(),getItemCount()等方法，并添加switch语句进行判断。那么如何在不破坏原有Adapter实现的情况下完成呢？
这里引入装饰器（Decorator）设计模式，该设计模式通过组合的方式，在不破话原有类代码的情况下，对原有类的功能进行扩展。具体实现思路其实很简单，创建一个继承RecyclerView.Adapter
public class NormalAdapterWrapper extends RecyclerView.Adapter{
enum ITEM_TYPE{
HEADER,
FOOTER,
NORMAL
}
private NormalAdapter mAdapter;
private View mHeaderView;
private View mFooterView;
public NormalAdapterWrapper(NormalAdapter adapter){
mAdapter = adapter;
}
@Override
public int getItemViewType(int position) {
if(position == 0){
return ITEM_TYPE.HEADER.ordinal();
} else if(position == mAdapter.getItemCount() + 1){
return ITEM_TYPE.FOOTER.ordinal();
} else{
return ITEM_TYPE.NORMAL.ordinal();
}
}
@Override
public int getItemCount() {
return mAdapter.getItemCount() + 2;
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
if(position == 0){
return;
} else if(position == mAdapter.getItemCount() + 1){
return;
} else{
mAdapter.onBindViewHolder(((NormalAdapter.VH)holder), position - 1);
}
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if(viewType == ITEM_TYPE.HEADER.ordinal()){
return new RecyclerView.ViewHolder(mHeaderView) {};
} else if(viewType == ITEM_TYPE.FOOTER.ordinal()){
return new RecyclerView.ViewHolder(mFooterView) {};
} else{
return mAdapter.onCreateViewHolder(parent,viewType);
}
}
public void addHeaderView(View view){
this.mHeaderView = view;
}
public void addFooterView(View view){
this.mFooterView = view;
}
}
使用装饰过的适配器，如下代码所示：
NormalAdapter adapter = new NormalAdapter(data);
NormalAdapterWrapper newAdapter = new NormalAdapterWrapper(adapter);
View headerView = LayoutInflater.from(this).inflate(R.layout.item_header, mRecyclerView, false);
View footerView = LayoutInflater.from(this).inflate(R.layout.item_footer, mRecyclerView, false);
newAdapter.addFooterView(footerView);
newAdapter.addHeaderView(headerView);
mRecyclerView.setAdapter(newAdapter);
添加setEmptyView
ListView提供了setEmptyView()设置Adapter数据为空时的View视图。RecyclerView虽然没提供直接的API，但是也可以很简单地实现。
① 创建一个继承RecyclerView的类，记为EmptyRecyclerView。
② 通过getRootView().addView(emptyView)将空数据时显示的View添加到当前View的层次结构中。
③ 通过AdapterDataObserver监听RecyclerView的数据变化，如果adapter为空，那么隐藏RecyclerView，显示EmptyView。
具体实现如下：
public class EmptyRecyclerView extends RecyclerView{
private View mEmptyView;
private AdapterDataObserver mObserver = new AdapterDataObserver() {
@Override
public void onChanged() {
Adapter adapter = getAdapter();
if(adapter.getItemCount() == 0){
mEmptyView.setVisibility(VISIBLE);
EmptyRecyclerView.this.setVisibility(GONE);
} else{
mEmptyView.setVisibility(GONE);
EmptyRecyclerView.this.setVisibility(VISIBLE);
}
}
public void onItemRangeChanged(int positionStart, int itemCount) {onChanged();}
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {onChanged();}
public void onItemRangeRemoved(int positionStart, int itemCount) {onChanged();}
public void onItemRangeInserted(int positionStart, int itemCount) {onChanged();}
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {onChanged();}
};
public EmptyRecyclerView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public void setEmptyView(View view){
this.mEmptyView = view;
((ViewGroup)this.getRootView()).addView(mEmptyView); //加入主界面布局
}
public void setAdapter(RecyclerView.Adapter adapter){
super.setAdapter(adapter);
adapter.registerAdapterDataObserver(mObserver);
mObserver.onChanged();
}
}
布局
Activity中使用
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recycler_view);
mRv = (EmptyRecyclerView) findViewById(R.id.rv);
mRv.setLayoutManager(new LinearLayoutManager(this));
mData = new ArrayList<>();
mAdapter = new NormalAdapter(mData);
//View view = LayoutInflater.from(this).inflate(R.layout.empty, null);
View view = findViewById(R.id.text_empty);
mRv.setEmptyView(view);
mRv.setAdapter(mAdapter);
}
拖拽、侧滑删除
Android提供了ItemTouchHelper类，使得RecyclerView能够轻易地实现滑动和拖拽，此处我们要实现上下拖拽和侧滑删除。
- 创建ItemTouchHelper.Callback类
首先创建一个继承自ItemTouchHelper.Callback的类，并重写以下方法：
- getMovementFlags()
设置支持的拖拽和滑动的方向，此处我们支持的拖拽方向为上下，滑动方向为从左到右和从右到左，内部通过makeMovementFlags()设置。 - onMove()
拖拽时回调。 - onSwiped()
滑动时回调。 - onSelectedChanged()
状态变化时回调，一共有三个状态，分别是ACTION_STATE_IDLE(空闲状态)，ACTION_STATE_SWIPE(滑动状态)，ACTION_STATE_DRAG(拖拽状态)。此方法中可以做一些状态变化时的处理，比如拖拽的时候修改背景色。 - clearView()
用户交互结束时回调。此方法可以做一些状态的清空，比如拖拽结束后还原背景色。 - isLongPressDragEnabled()
是否支持长按拖拽，默认为true。如果不想支持长按拖拽，则重写并返回false。
具体实现如下：
public class SimpleItemTouchCallback extends ItemTouchHelper.Callback {
private NormalAdapter mAdapter;
private List mData;
public SimpleItemTouchCallback(NormalAdapter adapter, List data){
mAdapter = adapter;
mData = data;
}
//设置支持的拖拽、滑动的方向
@Override
public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
int dragFlag = ItemTouchHelper.UP | ItemTouchHelper.DOWN; //s上下拖拽
int swipeFlag = ItemTouchHelper.START | ItemTouchHelper.END; //左->右和右->左滑动
return makeMovementFlags(dragFlag,swipeFlag);
}
@Override
public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
int from = viewHolder.getAdapterPosition();
int to = target.getAdapterPosition();
Collections.swap(mData, from, to);
mAdapter.notifyItemMoved(from, to);
return true;
}
@Override
public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
int pos = viewHolder.getAdapterPosition();
mData.remove(pos);
mAdapter.notifyItemRemoved(pos);
}
//状态改变时回调
@Override
public void onSelectedChanged(RecyclerView.ViewHolder viewHolder, int actionState) {
super.onSelectedChanged(viewHolder, actionState);
if(actionState != ItemTouchHelper.ACTION_STATE_IDLE){
NormalAdapter.VH holder = (NormalAdapter.VH)viewHolder;
holder.itemView.setBackgroundColor(0xffbcbcbc); //设置拖拽和侧滑时的背景色
}
}
//拖拽或滑动完成之后调用，用来清除一些状态
@Override
public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
super.clearView(recyclerView, viewHolder);
NormalAdapter.VH holder = (NormalAdapter.VH)viewHolder;
holder.itemView.setBackgroundColor(0xffeeeeee); //背景色还原
}
}
- 设置ItemTouchHelper给RecyclerView
通过以下代码为RecyclerView设置该滑动、拖拽功能：
ItemTouchHelper helper = new ItemTouchHelper(new SimpleItemTouchCallback(adapter, data));
helper.attachToRecyclerView(recyclerview);
触摸拖拽
前面拖拽的触发方式只有长按，如果想支持触摸Item中的某个View实现拖拽，则核心方法为helper.startDrag(holder)。
完整代码如下：
public class NormalAdapter extends RecyclerView.Adapter{
private List mDatas;
private OnStartDragListener mListener;
public NormalAdapter(List data, OnStartDragListener listener) {
this.mDatas = data;
mListener = listener;
}
@Override
public void onBindViewHolder(final VH holder, int position) {
ObjectModel model = mDatas.get(position);
holder.title.setText(model.title);
holder.number.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
if(event.getAction() == MotionEvent.ACTION_DOWN){
mListener.startDrag(holder);
}
return false;
}
});
}
@Override
public int getItemCount() {
return mDatas.size();
}
@Override
public VH onCreateViewHolder(ViewGroup parent, int viewType) {
View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_3, parent, false);
return new VH(v);
}
public static class VH extends RecyclerView.ViewHolder{
public final TextView title;
public final ImageView number;
public VH(View v) {
super(v);
title = (TextView) v.findViewById(R.id.title);
number = (ImageView) v.findViewById(R.id.icon);
}
}
}
使用此触摸滑动适配器
public class Activity3 extends AppCompatActivity implements OnStartDragListener{
private RecyclerView mRv;
private NormalAdapter mAdapter;
private ItemTouchHelper mHelper;
private List mData;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_3);
mRv = (RecyclerView) findViewById(R.id.rv);
mRv.setLayoutManager(new LinearLayoutManager(this));
mAdapter = new NormalAdapter(mData = initData(), this);
mRv.setAdapter(mAdapter);
mHelper = new ItemTouchHelper(new SimpleItemTouchCallback(mAdapter, mData));
mHelper.attachToRecyclerView(mRv);
}
public ArrayList initData(){
ArrayList models = new ArrayList<>();
String[] titles = getResources().getStringArray(R.array.title_array);
for(int i=0;i 嵌套滑动机制
Android 5.0推出了嵌套滑动机制，在之前，一旦子View处理了触摸事件，父View就没有机会再处理这次的触摸事件，而嵌套滑动机制解决了这个问题，能够实现如下效果：
为了支持嵌套滑动，子View必须实现NestedScrollingChild接口，父View必须实现NestedScrollingParent接口。而RecyclerView实现了NestedScrollingChild接口，而CoordinatorLayout实现了NestedScrollingParent接口，上图是实现CoordinatorLayout嵌套RecyclerView的效果。
为了实现上图的效果，需要用到的组件有：
- CoordinatorLayout: 布局根元素。
- AppBarLayout: 包裹的内容作为应用的Bar。
- CollapsingToolbarLayout: 实现可折叠的ToolBar。
- ToolBar: 代替ActionBar。
实现中需要注意的点有：
① 我们为ToolBar的app:layout_collapseMode设置为pin，表示折叠之后固定在顶端，而为ImageView的app:layout_collapseMode设置为parallax，表示视差模式，即渐变的效果。
② 为了让RecyclerView支持嵌套滑动，还需要为它设置app:layout_behavior="@string/appbar_scrolling_view_behavior"。
③ 为CollapsingToolbarLayout设置app:layout_scrollFlags="scroll|exitUntilCollapsed"，其中scroll表示滚动出屏幕，exitUntilCollapsed表示退出后折叠。
布局：
适配器：
public abstract class QuickAdapter extends RecyclerView.Adapter{
private List mDatas;
public QuickAdapter(List datas){
this.mDatas = datas;
}
public abstract int getLayoutId(int viewType);
@Override
public VH onCreateViewHolder(ViewGroup parent, int viewType) {
return VH.get(parent,getLayoutId(viewType));
}
@Override
public void onBindViewHolder(VH holder, int position) {
convert(holder, mDatas.get(position), position);
}
@Override
public int getItemCount() {
return mDatas.size();
}
public abstract void convert(VH holder, T data, int position);
static class VH extends RecyclerView.ViewHolder{
private SparseArray mViews;
private View mConvertView;
private VH(View v){
super(v);
mConvertView = v;
mViews = new SparseArray<>();
}
public static VH get(ViewGroup parent, int layoutId){
View convertView = LayoutInflater.from(parent.getContext()).inflate(layoutId, parent, false);
return new VH(convertView);
}
public T getView(int id){
View v = mViews.get(id);
if(v == null){
v = mConvertView.findViewById(id);
mViews.put(id, v);
}
return (T)v;
}
public void setText(int id, String value){
TextView view = getView(id);
view.setText(value);
}
}
}
Activity：
public class Activity6 extends AppCompatActivity {
private RecyclerView mRv;
private QuickAdapter mAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_6);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
mRv = (RecyclerView) findViewById(R.id.rv);
mRv.setLayoutManager(new StaggeredGridLayoutManager(3, StaggeredGridLayoutManager.VERTICAL));
mAdapter = new QuickAdapter(initData()) {
@Override
public int getLayoutId(int viewType) {
return R.layout.item_6;
}
@Override
public void convert(VH holder, Integer data, int position) {
ImageView imageView = holder.getView(R.id.image);
Picasso.with(Activity6.this).load(data).into(imageView);
//holder.itemView.setOnClickListener(); 此处添加点击事件
}
@Override
public int getItemViewType(int position) {
return super.getItemViewType(position);
}
};
mAdapter.setHasStableIds(true);
((SimpleItemAnimator)mRv.getItemAnimator()).setSupportsChangeAnimations(false);
mRv.setAdapter(mAdapter);
}
public List initData(){
Integer[] images = {R.drawable.s1, R.drawable.s2, R.drawable.s3, R.drawable.s4, R.drawable.s5,
R.drawable.s6, R.drawable.s7, R.drawable.s8, R.drawable.s9, R.drawable.s10
};
ArrayList list = new ArrayList<>();
for(int i=0;i<2;i++){
for(Integer image:images){
list.add(image);
}
}
return list;
}
}
实现原理是怎样？
RecyclerView Vs ListView
RecyclerView与ListView的优缺点
| 类别 | 优点 | 缺点 |
|---|---|---|
| ListView | ①addHeaderView(), addFooterView()添加头视图和尾视图；②通过android:divider设置自定义分割线；③setOnItemClickListener()和setOnItemLongClickListener()设置点击事件和长按事件； | ①View未复用；②未实现局部刷新； |
| RecyclerView | ①默认已经实现了View的复用，不需要类似if(convertView == null)的实现，而且回收机制更加完善。②默认支持局部刷新；③容易实现添加item、删除item的动画效果；④容易实现拖拽、侧滑删除等功能； | ①没有添加头尾，点击与长按的接口，须自己实现； |
局部刷新
ListView和RecyclerView最大的区别在于数据源改变时的缓存的处理逻辑，ListView是”一锅端”，将所有的mActiveViews都移入了二级缓存mScrapViews，而RecyclerView则是更加灵活地对每个View修改标志位，区分是否重新bindView。
- ListView实现局部刷新
我们都知道ListView通过adapter.notifyDataSetChanged()实现ListView的更新，这种更新方法的缺点是全局更新，即对每个Item View都进行重绘。但事实上很多时候，我们只是更新了其中一个Item的数据，其他Item其实可以不需要重绘。
这里给出ListView实现局部更新的方法：
public void updateItemView(ListView listview, int position, Data data){
int firstPos = listview.getFirstVisiblePosition();
int lastPos = listview.getLastVisiblePosition();
if(position >= firstPos && position <= lastPos){ //可见才更新，不可见则在getView()时更新
//listview.getChildAt(i)获得的是当前可见的第i个item的view
View view = listview.getChildAt(position - firstPos);
VH vh = (VH)view.getTag();
vh.text.setText(data.text);
}
}
可以看出，我们通过ListView的getChildAt()来获得需要更新的View，然后通过getTag()获得ViewHolder，从而实现更新。
-
RecyclerView实现局部刷新
RecyclerView提供了notifyItemInserted(),notifyItemRemoved(),notifyItemChanged()等API更新单个或某个范围的Item视图。以RecyclerView中notifyItemRemoved(1)为例，最终会调用requestLayout()，使整个RecyclerView重新绘制，过程为：
onMeasure()–>onLayout()–>onDraw()，其中，onLayout()为重点，分为三步：
① dispathLayoutStep1()：记录RecyclerView刷新前列表项ItemView的各种信息，如Top、Left、Bottom、Right，用于动画的相关计算；
② dispathLayoutStep2()：真正测量布局大小，位置，核心函数为layoutChildren()；
layoutChildren()流程图.jpg
Recycler.fill流程.png
③ dispathLayoutStep3()：计算布局前后各个ItemView的状态，如Remove，Add，Move，Update等，如有必要执行相应的动画。
记录ItemView改变状态信息.png
缓存机制
ListView与RecyclerView缓存机制原理大致相似，如下图所示：
过程中，离屏的ItemView即被回收至缓存，入屏的ItemView则会优先从缓存中获取，只是ListView与RecyclerView的实现细节有差异.（这只是缓存使用的其中一个场景，还有如刷新等）
- 缓存层级不同
RecyclerView比ListView多两级缓存，支持多个离ItemView缓存，支持开发者自定义缓存处理逻辑，支持所有RecyclerView共用同一个RecyclerViewPool(缓存池)。客观来说，RecyclerView在特定场景下对ListView的缓存机制做了补强和完善。
- ListView(两级缓存)：
| 缓存类型 | 是否需要回调createView | 是否需要回调bindView | 生命周期 | 备注 |
|---|---|---|---|---|
| mActiveViews | 否 | 否 | onLayout函数周期内 | 属于屏幕内ItemView快速重用 |
| mScrapViews | 否 | 是 | 与mAdapter一直，当mAdapter被更换时，mScrapViews即被清空 |
- RecyclerView(四级缓存)：
| 缓存类型 | 是否需要回调createView | 是否需要回调bindView | 生命周期 | 备注 |
|---|---|---|---|---|
| mAttachedScrap | 否 | 否 | onLayout函数周期内 | 属于屏幕内ItemView快速重用 |
| mCacheViews | 否 | 是 | 与mAdapter一致，当mAdapter被更换时，mCacheViews即被缓存至mRecyclerPool | 默认上限为2，即缓存屏幕外2个ItemView |
| mViewCacheExtension | 不直接使用，需要用户定制，默认不实现 | |||
| mRecyclerPool | 否 | 是 | 与自身生命周期一致，不再被引用时即被释放 | 默认上限为5，技术上可以实现所有RecyclerViewPool共用同一个 |
ListView和RecyclerView缓存机制基本一致：
1）mActiveViews和mAttachedScrap功能相似，意义在于快速重用屏幕上可见的列表项ItemView，而不需要重新createView和bindView；
2）mScrapView和mCachedViews + mReyclerViewPool功能相似，意义在于缓存离开屏幕的ItemView，目的是让即将进入屏幕的ItemView重用；
3）RecyclerView的优势在于：①mCacheViews的使用，可以做到屏幕外的列表项ItemView进入屏幕内时也无须bindView快速重用；②mRecyclerPool可以供多个RecyclerView共同使用，在特定场景下，如viewpaper+多个列表页下有优势。
缓存内容不同
1）RecyclerView缓存RecyclerView.ViewHolder，抽象可理解为：View + ViewHolder(避免每次createView时调用findViewById) + flag(标识状态)；
2）ListView缓存View；-
缓存的使用流程不同
ListView获取缓存的流程：
ListView获取缓存的流程.jpg
RecyclerView获取缓存的流程：
RecyclerView获取缓存的流程.jpg
说明：
① RecyclerView中mCacheViews(屏幕外)获取缓存时，是通过匹配pos获取目标位置的缓存，这样做的好处是，当数据源数据不变的情况下，无须重新bindView。而ListView从mScrapViews(屏幕外)获取缓存时，根据pos获取相应的缓存，但是并没有直接使用，而是重新getView（即必定会重新bindView）。
② ListView中通过pos获取的是view，即pos–>view；RecyclerView中通过pos获取的是viewholder，即pos –> (view，viewHolder，flag)。从流程图中可以看出，标志flag的作用是判断view是否需要重新bindView，这也是RecyclerView实现局部刷新的一个核心。
回收机制源码
- ListView回收机制
ListView为了保证Item View的复用，实现了一套回收机制，该回收机制的实现类是RecycleBin，他实现了两级缓存：
- View[] mActiveViews: 缓存屏幕上的View，在该缓存里的View不需要调用getView()。
- ArrayList
[] mScrapViews：每个Item Type对应一个列表作为回收站，缓存由于滚动而消失的View，此处的View如果被复用，会以参数的形式传给getView()。
接下来我们通过源码分析ListView是如何与RecycleBin交互的，ListView的布局函数是layoutChildren()，实现如下：
void layoutChildren(){
//1. 如果数据被改变了，则将所有Item View回收至scrapView ，否则回收至mActiveViews
//（而RecyclerView会根据情况放入Scrap Heap或RecyclePool）
if (dataChanged) {
for (int i = 0; i < childCount; i++) {
recycleBin.addScrapView(getChildAt(i), firstPosition+i);
}
} else {
recycleBin.fillActiveViews(childCount, firstPosition);
}
//2. 填充
switch(){
case LAYOUT_XXX:
fillXxx();
break;
case LAYOUT_XXX:
fillXxx();
break;
}
//3. 回收多余的activeView
mRecycler.scrapActiveViews();
}
其中fillXxx()实现了对Item View进行填充，该方法内部调用了makeAndAddView()，实现如下：
View makeAndAddView(){
if (!mDataChanged) {
child = mRecycler.getActiveView(position);
if (child != null) {
return child;
}
}
child = obtainView(position, mIsScrap);
return child;
}
其中，getActiveView()是从mActiveViews中获取合适的View，如果获取到了，则直接返回，而不调用obtainView()，这也印证了如果从mActiveViews获取到了可复用的View，则不需要调用getView()。
obtainView()是从mScrapViews中获取合适的View，然后以参数形式传给了getView()，实现如下：
View obtainView(int position){
final View scrapView = mRecycler.getScrapView(position); //从RecycleBin中获取复用的View
final View child = mAdapter.getView(position, scrapView, this);
}
接下去我们介绍getScrapView(position)的实现，该方法通过position得到Item Type，然后根据Item Type从mScrapViews获取可复用的View，如果获取不到，则返回null，具体实现如下：
class RecycleBin{
private View[] mActiveViews; //存储屏幕上的View
private ArrayList[] mScrapViews; //每个item type对应一个ArrayList
private int mViewTypeCount; //item type的个数
private ArrayList mCurrentScrap; //mScrapViews[0]
View getScrapView(int position) {
final int whichScrap = mAdapter.getItemViewType(position);
if (whichScrap < 0) {
return null;
}
if (mViewTypeCount == 1) {
return retrieveFromScrap(mCurrentScrap, position);
} else if (whichScrap < mScrapViews.length) {
return retrieveFromScrap(mScrapViews[whichScrap], position);
}
return null;
}
private View retrieveFromScrap(ArrayList scrapViews, int position){
int size = scrapViews.size();
if(size > 0){
return scrapView.remove(scrapViews.size() - 1); //从回收列表中取出最后一个元素复用
} else{
return null;
}
}
}
- RecyclerView回收机制
RecyclerView和ListView的回收机制非常相似，但是ListView是以View作为单位进行回收，RecyclerView是以ViewHolder作为单位进行回收。
Recycler是RecyclerView回收机制的实现类，他实现了四级缓存：
①mAttachedScrap: 缓存在屏幕上的ViewHolder。
②mCachedViews: 缓存屏幕外的ViewHolder，默认为2个。ListView对于屏幕外的缓存都会调用getView()。
③mViewCacheExtensions: 需要用户定制，默认不实现。
④mRecyclerPool: 缓存池，多个RecyclerView共用。
getViewForPosition()的代码：
View getViewForPosition(int position, boolean dryRun){
if(holder == null){
//从mAttachedScrap,mCachedViews获取ViewHolder
holder = getScrapViewForPosition(position,INVALID,dryRun); //此处获得的View不需要bind
}
final int type = mAdapter.getItemViewType(offsetPosition);
if (mAdapter.hasStableIds()) { //默认为false
holder = getScrapViewForId(mAdapter.getItemId(offsetPosition), type, dryRun);
}
if(holder == null && mViewCacheExtension != null){
final View view = mViewCacheExtension.getViewForPositionAndType(this, position, type); //从
if(view != null){
holder = getChildViewHolder(view);
}
}
if(holder == null){
holder = getRecycledViewPool().getRecycledView(type);
}
if(holder == null){ //没有缓存，则创建
holder = mAdapter.createViewHolder(RecyclerView.this, type); //调用onCreateViewHolder()
}
if(!holder.isBound() || holder.needsUpdate() || holder.isInvalid()){
mAdapter.bindViewHolder(holder, offsetPosition);
}
return holder.itemView;
}
从上述实现可以看出，依次从mAttachedScrap, mCachedViews, mViewCacheExtension, mRecyclerPool寻找可复用的ViewHolder，如果是从mAttachedScrap或mCachedViews中获取的ViewHolder，则不会调用onBindViewHolder()，mAttachedScrap和mCachedViews也就是我们所说的Scrap Heap；而如果从mViewCacheExtension或mRecyclerPool中获取的ViewHolder，则会调用onBindViewHolder()。
RecyclerView局部刷新的实现原理也是基于RecyclerView的回收机制，即能直接复用的ViewHolder就不调用onBindViewHolder()。
参考链接：
[1] (https://blog.csdn.net/lmj623565791/article/details/45059587)
[2] (https://www.jianshu.com/p/4f9591291365) ★
[3] (https://segmentfault.com/a/1190000018616283)
[4] (https://blog.csdn.net/qq_15827013/article/details/97798716)
[5] (https://blog.csdn.net/wzy_1988/article/details/81569156)
[6] (https://blog.csdn.net/yuequnchen/article/details/80336162)
[7] (https://blog.csdn.net/feather_wch/article/details/79932523)
[8] (https://juejin.im/post/5b79a0b851882542b13d204b) good!
[9] (https://www.jianshu.com/p/b84bd45b4391)
[10] (https://zhuanlan.zhihu.com/p/23339185)
[11] (https://www.jianshu.com/p/88314f56545d)