Android7.0 工具类：DiffUtil详解

概述一概述DiffUtil是support-v7:24.2.0中的新工具类，它用来比较两个数据集，寻找出旧数据集-》新数据集的最小变化量。

一 概述

DiffUtil是support-v7:24.2.0中的新工具类，它用来比较两个数据集，寻找出旧数据集-》新数据集的最小变化量。

说到数据集，相信大家知道它是和谁相关的了，就是我的最爱，RecyclerVIEw。

就我使用的这几天来看，它最大的用处就是在RecyclerVIEw刷新时，不再无脑mAdapter.notifyDataSetChanged()。

以前无脑mAdapter.notifyDataSetChanged()有两个缺点：

1.不会触发RecyclerVIEw的动画（删除、新增、位移、change动画）

2.性能较低，毕竟是无脑的刷新了一遍整个RecyclerVIEw,极端情况下：新老数据集一模一样，效率是最低的。

使用DiffUtil后，改为如下代码：

DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffCallBack(mDatas,newDatas),true);
diffResult.dispatchUpdatesTo(mAdapter);

它会自动计算新老数据集的差异，并根据差异情况，自动调用以下四个方法

adapter.notifyItemRangeInserted(position,count);
adapter.notifyItemRangeRemoved(position,count);
adapter.notifyItemmoved(fromposition,toposition);
adapter.notifyItemRangeChanged(position,count,payload);

显然，这个四个方法在执行时都是伴有RecyclerVIEw的动画的，且都是定向刷新方法，刷新效率蹭蹭的上升了。
老规矩，先上图，

图一是无脑mAdapter.notifyDataSetChanged()的效果图，可以看到刷新交互很生硬，Item突然的出现在某个位置：

图二是使用DiffUtils的效果图，最明显的是有插入、移动Item的动画：

转成GIF有些渣，下载文末Demo运行效果更佳哦。

本文将包含且不仅包含以下内容：

1 先介绍DiffUtil的简单用法，实现刷新时的“增量更新”效果。（“增量更新”是我自己的叫法）
2 DiffUtil的高级用法，在某项Item只有内容(data)变化，位置(position)未变化时，完成部分更新（官方称之为Partial bind，部分绑定）。
3 了解到 RecyclerVIEw.Adapter还有public voID onBindVIEwHolder(VH holder,int position,List<Object> payloads)方法，并掌握它。
4 在子线程中计算DiffResult，在主线程中刷新RecyclerVIEw。
5 少部分人不喜欢的notifyItemChanged()导致Item白光一闪的动画 如何去除。
6 DiffUtil部分类、方法 官方注释的汉化

二 DiffUtil的简单用法

前文也提到，DiffUtil是帮助我们在刷新RecyclerVIEw时，计算新老数据集的差异，并自动调用RecyclerVIEw.Adapter的刷新方法，以完成高效刷新并伴有Item动画的效果。

那么我们在学习它之前要先做一些准备工作，先写一个普通青年版，无脑notifyDataSetChanged()刷新的Demo。

1 一个普通的JavaBean，但是实现了clone方法，仅用于写Demo模拟刷新用，实际项目不需要，因为刷新时，数据都是从网络拉取的。:

class TestBean implements Cloneable { private String name; private String desc; ....//get set方法省略 //仅写DEMO 用 实现克隆方法 @OverrIDe public TestBean clone() throws CloneNotSupportedException {  TestBean bean = null;  try {   bean = (TestBean) super.clone();  } catch (CloneNotSupportedException e) {   e.printstacktrace();  }  return bean; }

2 实现一个普普通通的RecyclerVIEw.Adapter。

public class DiffAdapter extends RecyclerVIEw.Adapter<DiffAdapter.DiffVH> { private final static String TAG = "zxt"; private List<TestBean> mDatas; private Context mContext; private LayoutInflater mInflater; public DiffAdapter(Context mContext,List<TestBean> mDatas) {  this.mContext = mContext;  this.mDatas = mDatas;  mInflater = LayoutInflater.from(mContext); } public voID setDatas(List<TestBean> mDatas) {  this.mDatas = mDatas; } @OverrIDe public DiffVH onCreateVIEwHolder(VIEwGroup parent,int vIEwType) {  return new DiffVH(mInflater.inflate(R.layout.item_diff,parent,false)); } @OverrIDe public voID onBindVIEwHolder(final DiffVH holder,final int position) {  TestBean bean = mDatas.get(position);  holder.tv1.setText(bean.getname());  holder.tv2.setText(bean.getDesc());  holder.iv.setimageResource(bean.getPic()); } @OverrIDe public int getItemCount() {  return mDatas != null ? mDatas.size() : 0; } class DiffVH extends RecyclerVIEw.VIEwHolder {  TextVIEw tv1,tv2;  ImageVIEw iv;  public DiffVH(VIEw itemVIEw) {   super(itemVIEw);   tv1 = (TextVIEw) itemVIEw.findVIEwByID(R.ID.tv1);   tv2 = (TextVIEw) itemVIEw.findVIEwByID(R.ID.tv2);   iv = (ImageVIEw) itemVIEw.findVIEwByID(R.ID.iv);  } }}

3 Activity代码：

public class MainActivity extends AppCompatActivity { private List<TestBean> mDatas; private RecyclerVIEw mRv; private DiffAdapter mAdapter; @OverrIDe protected voID onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  setContentVIEw(R.layout.activity_main);  initData();  mRv = (RecyclerVIEw) findVIEwByID(R.ID.rv);  mRv.setLayoutManager(new linearlayoutmanager(this));  mAdapter = new DiffAdapter(this,mDatas);  mRv.setAdapter(mAdapter); } private voID initData() {  mDatas = new ArrayList<>();  mDatas.add(new TestBean("张旭童1","AndroID",R.drawable.pic1));  mDatas.add(new TestBean("张旭童2","Java",R.drawable.pic2));  mDatas.add(new TestBean("张旭童3","背锅",R.drawable.pic3));  mDatas.add(new TestBean("张旭童4","手撕产品",R.drawable.pic4));  mDatas.add(new TestBean("张旭童5","手撕测试",R.drawable.pic5)); } /**  * 模拟刷新 *** 作  *  * @param vIEw  */ public voID onRefresh(VIEw vIEw) {  try {   List<TestBean> newDatas = new ArrayList<>();   for (TestBean bean : mDatas) {    newDatas.add(bean.clone());//clone一遍旧数据 ，模拟刷新 *** 作   }   newDatas.add(new TestBean("赵子龙","帅",R.drawable.pic6));//模拟新增数据   newDatas.get(0).setDesc("AndroID+");   newDatas.get(0).setPic(R.drawable.pic7);//模拟修改数据   TestBean testBean = newDatas.get(1);//模拟数据位移   newDatas.remove(testBean);   newDatas.add(testBean);   //别忘了将新数据给Adapter   mDatas = newDatas;   mAdapter.setDatas(mDatas);   mAdapter.notifyDataSetChanged();//以前我们大多数情况下只能这样  } catch (CloneNotSupportedException e) {   e.printstacktrace();  } }}

很简单，只不过在构建新数据源newDatas时，是遍历老数据源mDatas，调用每个data的clone()方法，确保新老数据源虽然数据一致，但是内存地址（指针不一致），这样在后面修改newDatas里的值时，不会牵连mDatas里的值被一起改了。

4 activity_main.xml 删掉了一些宽高代码，就是一个RecyclerVIEw和一个button用于模拟刷新。:

<?xml version="1.0" enCoding="utf-8"?><relativeLayout xmlns:androID="http://schemas.androID.com/apk/res/androID"> <androID.support.v7.Widget.RecyclerVIEw  androID:ID="@+ID/rv" /> <button  androID:ID="@+ID/btnRefresh"  androID:layout_alignParentRight="true"  androID:onClick="onRefresh"  androID:text="模拟刷新" /></relativeLayout>

以上是一个普通青年很容易写出的，无脑notifyDataSetChanged()的demo，运行效果如第一节图一。
但是我们都要争做文艺青年，so

下面开始进入正题，简单使用DiffUtil，我们需要且仅需要额外编写一个类。

想成为文艺青年，我们需要实现一个继承自DiffUtil.Callback的类，实现它的四个abstract方法。
虽然这个类叫Callback，但是把它理解成：定义了一些用来比较新老Item是否相等的契约(Contract)、规则(Rule)的类， 更合适。

DiffUtil.Callback抽象类如下：

 public abstract static class Callback {  public abstract int getoldListSize();//老数据集size  public abstract int getNewListSize();//新数据集size  public abstract boolean areItemsTheSame(int oldItemposition,int newItemposition);//新老数据集在同一个postion的Item是否是一个对象？（可能内容不同，如果这里返回true，会调用下面的方法）  public abstract boolean areContentsTheSame(int oldItemposition,int newItemposition);//这个方法仅仅是上面方法返回ture才会调用，我的理解是只有notifyItemRangeChanged()才会调用，判断item的内容是否有变化  //该方法在DiffUtil高级用法中用到 ，暂且不提  @Nullable  public Object getChangePayload(int oldItemposition,int newItemposition) {   return null;  } }

  本Demo如下实现DiffUtil.Callback，核心方法配有中英双语注释（说人话就是，翻译了官方的英文注释，方便大家更好理解）。

/** * 介绍：核心类 用来判断 新旧Item是否相等 * 作者：zhangxutong * 邮箱：zhangxutong@imcoming.com * 时间： 2016/9/12. */public class DiffCallBack extends DiffUtil.Callback { private List<TestBean> moldDatas,mNewDatas;//看名字 public DiffCallBack(List<TestBean> moldDatas,List<TestBean> mNewDatas) {  this.moldDatas = moldDatas;  this.mNewDatas = mNewDatas; } //老数据集size @OverrIDe public int getoldListSize() {  return moldDatas != null ? moldDatas.size() : 0; } //新数据集size @OverrIDe public int getNewListSize() {  return mNewDatas != null ? mNewDatas.size() : 0; } /**  * Called by the DiffUtil to decIDe whether two object represent the same Item.  * 被DiffUtil调用，用来判断 两个对象是否是相同的Item。  * For example,if your items have unique IDs,this method should check their ID equality.  * 例如，如果你的Item有唯一的ID字段，这个方法就 判断ID是否相等。  * 本例判断name字段是否一致  *  * @param oldItemposition The position of the item in the old List  * @param newItemposition The position of the item in the new List  * @return True if the two items represent the same object or false if they are different.  */ @OverrIDe public boolean areItemsTheSame(int oldItemposition,int newItemposition) {  return moldDatas.get(oldItemposition).getname().equals(mNewDatas.get(newItemposition).getname()); } /**  * Called by the DiffUtil when it wants to check whether two items have the same data.  * 被DiffUtil调用，用来检查 两个item是否含有相同的数据  * DiffUtil uses this information to detect if the contents of an item has changed.  * DiffUtil用返回的信息（true false）来检测当前item的内容是否发生了变化  * DiffUtil uses this method to check equality instead of {@link Object#equals(Object)}  * DiffUtil 用这个方法替代equals方法去检查是否相等。  * so that you can change its behavior depending on your UI.  * 所以你可以根据你的UI去改变它的返回值  * For example,if you are using DiffUtil with a  * {@link androID.support.v7.Widget.RecyclerVIEw.Adapter RecyclerVIEw.Adapter},you should  * return whether the items‘ visual representations are the same.  * 例如，如果你用RecyclerVIEw.Adapter 配合DiffUtil使用，你需要返回Item的视觉表现是否相同。  * This method is called only if {@link #areItemsTheSame(int,int)} returns  * {@code true} for these items.  * 这个方法仅仅在areItemsTheSame()返回true时，才调用。  * @param oldItemposition The position of the item in the old List  * @param newItemposition The position of the item in the new List which replaces the  *      oldItem  * @return True if the contents of the items are the same or false if they are different.  */ @OverrIDe public boolean areContentsTheSame(int oldItemposition,int newItemposition) {  TestBean beanold = moldDatas.get(oldItemposition);  TestBean beanNew = mNewDatas.get(newItemposition);  if (!beanold.getDesc().equals(beanNew.getDesc())) {   return false;//如果有内容不同，就返回false  }  if (beanold.getPic() != beanNew.getPic()) {   return false;//如果有内容不同，就返回false  }  return true; //默认两个data内容是相同的 }

注释张写了这么详细的注释+简单的代码，相信一眼可懂。

然后在使用时，注释掉你以前写的notifyDatasetChanged()方法吧，替换成以下代码：

//文艺青年新宠//利用DiffUtil.calculateDiff()方法，传入一个规则DiffUtil.Callback对象，和是否检测移动item的 boolean变量，得到DiffUtil.DiffResult 的对象DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffCallBack(mDatas,true);//利用DiffUtil.DiffResult对象的dispatchUpdatesTo（）方法，传入RecyclerVIEw的Adapter，轻松成为文艺青年diffResult.dispatchUpdatesTo(mAdapter);//别忘了将新数据给AdaptermDatas = newDatas;mAdapter.setDatas(mDatas);

讲解：

步骤一

在将newDatas 设置给Adapter之前，先调用DiffUtil.calculateDiff()方法，计算出新老数据集转化的最小更新集，就是

DiffUtil.DiffResult对象。
DiffUtil.calculateDiff()方法定义如下：
第一个参数是DiffUtil.Callback对象，
第二个参数代表是否检测Item的移动，改为false算法效率更高，按需设置，我们这里是true。

public static DiffResult calculateDiff(Callback cb,boolean detectMoves)

步骤二

然后利用DiffUtil.DiffResult对象的dispatchUpdatesTo（）方法，传入RecyclerVIEw的Adapter，替代普通青年才用的mAdapter.notifyDataSetChanged()方法。

查看源码可知，该方法内部，就是根据情况调用了adapter的四大定向刷新方法。

 public voID dispatchUpdatesTo(final RecyclerVIEw.Adapter adapter) {   dispatchUpdatesTo(new ListUpdateCallback() {    @OverrIDe    public voID onInserted(int position,int count) {     adapter.notifyItemRangeInserted(position,count);    }    @OverrIDe    public voID onRemoved(int position,int count) {     adapter.notifyItemRangeRemoved(position,count);    }    @OverrIDe    public voID onMoved(int fromposition,int toposition) {     adapter.notifyItemmoved(fromposition,toposition);    }    @OverrIDe    public voID onChanged(int position,int count,Object payload) {     adapter.notifyItemRangeChanged(position,payload);    }   });  }

小结：

所以说，DiffUtil不仅仅只能和RecyclerVIEw配合，我们也可以自己实现ListUpdateCallback接口的四个方法去做一些事情。（我暂时不负责任随便一项想，想到可以配合自己项目里的九宫格控件？或者优化我上篇文章写的nestFullListVIEw？小安利，见 ListVIEw、RecyclerVIEw、ScrollVIEw里嵌套ListVIEw 相对优雅的解决方案:http://blog.csdn.net/zxt0601/article/details/52494665）

至此，我们已进化成文艺青年，运行效果和第一节图二基本一致，

唯一不同的是此时adapter.notifyItemRangeChanged()会有Item白光一闪的更新动画 （本文Demo的postion为0的item）。 这个Item一闪的动画有人喜欢有人恨，不过都不重要了，

因为当我们学会了第三节的DiffUtil搞基用法，你爱不爱这个ItemChange动画，它都将随风而去。（不知道是不是官方BUG）
效果就是第一节的图二，我们的item0其实图片和文字都变化了，但是这个改变并没有伴随任何动画。

让我们迈向 文艺青年中的文艺青年 之路。

三 DiffUtil的高级用法

理论：

高级用法只涉及到两个方法，
我们需要分别实现DiffUtil.Callback的
public Object getChangePayload(int oldItemposition,int newItemposition)方法，
返回的Object就是表示Item改变了哪些内容。

再配合RecyclerVIEw.Adapter的
public voID onBindVIEwHolder(VH holder,List<Object> payloads)方法，
完成定向刷新。（成为文青中的文青，文青青。）
敲黑板，这是一个新方法，注意它有三个参数，前两个我们熟，第三个参数就包含了我们在getChangePayload（）返回的Object。

好吧，那我们就先看看这个方法是何方神圣：

在v7-24.2.0的源码里，它长这个样子：

 /**   * Called by RecyclerVIEw to display the data at the specifIEd position. This method   * should update the contents of the {@link VIEwHolder#itemVIEw} to reflect the item at   * the given position.   * <p>   * Note that unlike {@link androID.Widget.ListVIEw},RecyclerVIEw will not call this method   * again if the position of the item changes in the data set unless the item itself is   * invalIDated or the new position cannot be determined. For this reason,you should only   * use the <code>position</code> parameter while acquiring the related data item insIDe   * this method and should not keep a copy of it. If you need the position of an item later   * on (e.g. in a click Listener),use {@link VIEwHolder#getAdapterposition()} which will   * have the updated adapter position.   * <p>   * Partial bind vs full bind:   * <p>   * The payloads parameter is a merge List from {@link #notifyItemChanged(int,Object)} or   * {@link #notifyItemRangeChanged(int,int,Object)}. If the payloads List is not empty,* the VIEwHolder is currently bound to old data and Adapter may run an efficIEnt partial   * update using the payload info. If the payload is empty,Adapter must run a full bind.   * Adapter should not assume that the payload passed in notify methods will be received by   * onBindVIEwHolder(). For example when the vIEw is not attached to the screen,the   * payload in notifyItemChange() will be simply dropped.   *   * @param holder The VIEwHolder which should be updated to represent the contents of the   *    item at the given position in the data set.   * @param position The position of the item within the adapter‘s data set.   * @param payloads A non-null List of merged payloads. Can be empty List if requires full   *     update.   */  public voID onBindVIEwHolder(VH holder,List<Object> payloads) {   onBindVIEwHolder(holder,position);  }

原来它内部就仅仅调用了两个参数的onBindVIEwHolder(holder,position) ，（题外话，哎哟喂，我的nestFullListVIEw 的Adapter也有几分神似这种写法，看来我离Google大神又近了一步）

看到这我才明白，其实onBind的入口，就是这个方法，它才是和onCreateVIEwHolder对应的方法，
源码往下翻几行可以看到有个public final voID bindVIEwHolder(VH holder,int position)，它内部调用了三参的onBindVIEwHolder。
关于RecyclerVIEw.Adapter 也不是三言两句说的清楚的。（其实我只掌握到这里）
好了不再跑题，回到我们的三参数的onBindVIEwHolder(VH holder,List<Object> payloads)，这个方法头部有一大堆英文注释，我一直觉得阅读这些英文注释对理解方法很有用处，于是我翻译了一下，

翻译：

由RecyclerVIEw调用 用来在在指定的位置显示数据。
这个方法应该更新VIEwHolder里的ItemVIEw的内容，以反映在给定的位置 Item（的变化）。
请注意，不像ListVIEw，如果给定位置的item的数据集变化了，RecyclerVIEw不会再次调用这个方法，除非item本身失效了（invalIDated ） 或者新的位置不能确定。
出于这个原因,在这个方法里，你应该只使用 postion参数 去获取相关的数据item，而且不应该去保持 这个数据item的副本。
如果你稍后需要这个item的position，例如设置clickListener。应该使用 VIEwHolder.getAdapterposition()，它能提供 更新后的位置。
（二笔的我看到这里发现 这是在讲解两参的onbindVIEwHolder方法
下面是这个三参方法的独特部分：）
**部分(partial)绑定**vs完整(full)绑定
payloads 参数 是一个从（notifyItemChanged(int,Object)或notifyItemRangeChanged(int,Object)）里得到的合并List。
如果payloads List 不为空，那么当前绑定了旧数据的VIEwHolder 和Adapter， 可以使用 payload的数据进行一次 高效的部分更新。
如果payload 是空的，Adapter必须进行一次完整绑定（调用两参方法）。
Adapter不应该假定（想当然的认为） 在那些notifyxxxx通知方法传递过来的payload， 一定会在 onBindVIEwHolder()方法里收到。（这一句翻译不好 QAQ 看举例就好）
举例来说，当VIEw没有attached 在屏幕上时，这个来自notifyItemChange()的payload 就简单的丢掉好了。
payloads对象不会为null，但是它可能是空（empty），这时候需要完整绑定(所以我们在方法里只要判断isEmpty就好，不用重复判空)。
作者语：这方法是一个高效的方法。 我是个低效的翻译者，我看了40+分钟。才终于明白，重要的部分已经加粗显示。

实战:

说了这么多话，其实用起来超级简单：
先看如何使用getChangePayload（）方法，又附带了中英双语注释

  

 /**  * When {@link #areItemsTheSame(int,int)} returns {@code true} for two items and  * {@link #areContentsTheSame(int,int)} returns false for them,DiffUtil  * calls this method to get a payload about the change.  *   * 当{@link #areItemsTheSame(int,int)} 返回true，且{@link #areContentsTheSame(int,int)} 返回false时，DiffUtils会回调此方法，  * 去得到这个Item（有哪些）改变的payload。  *   * For example,if you are using DiffUtil with {@link RecyclerVIEw},you can return the  * particular fIEld that changed in the item and your  * {@link androID.support.v7.Widget.RecyclerVIEw.ItemAnimator ItemAnimator} can use that  * information to run the correct animation.  *   * 例如，如果你用RecyclerVIEw配合DiffUtils，你可以返回 这个Item改变的那些字段，  * {@link androID.support.v7.Widget.RecyclerVIEw.ItemAnimator ItemAnimator} 可以用那些信息去执行正确的动画  *   * Default implementation returns {@code null}.  * 默认的实现是返回null  *  * @param oldItemposition The position of the item in the old List  * @param newItemposition The position of the item in the new List  * @return A payload object that represents the change between the two items.  * 返回 一个 代表着新老item的改变内容的 payload对象，  */ @Nullable @OverrIDe public Object getChangePayload(int oldItemposition,int newItemposition) {  //实现这个方法 就能成为文艺青年中的文艺青年  // 定向刷新中的部分更新  // 效率最高  //只是没有了ItemChange的白光一闪动画，（反正我也觉得不太重要）  TestBean oldBean = moldDatas.get(oldItemposition);  TestBean newBean = mNewDatas.get(newItemposition);  //这里就不用比较核心字段了,一定相等  Bundle payload = new Bundle();  if (!oldBean.getDesc().equals(newBean.getDesc())) {   payload.putString("KEY_DESC",newBean.getDesc());  }  if (oldBean.getPic() != newBean.getPic()) {   payload.putInt("KEY_PIC",newBean.getPic());  }  if (payload.size() == 0)//如果没有变化 就传空   return null;  return payload;// }

简单的说，这个方法返回一个Object类型的payload，它包含了某个item的变化了的那些内容。
我们这里使用Bundle保存这些变化。

在Adapter里如下重写三参的onBindVIEwHolder：

 @OverrIDe public voID onBindVIEwHolder(DiffVH holder,List<Object> payloads) {  if (payloads.isEmpty()) {   onBindVIEwHolder(holder,position);  } else {   //文艺青年中的文青   Bundle payload = (Bundle) payloads.get(0);   TestBean bean = mDatas.get(position);   for (String key : payload.keySet()) {    switch (key) {     case "KEY_DESC":      //这里可以用payload里的数据，不过data也是新的 也可以用      holder.tv2.setText(bean.getDesc());      break;     case "KEY_PIC":      holder.iv.setimageResource(payload.getInt(key));      break;     default:      break;    }   }  } }

这里传递过来的payloads是一个List，由注释可知，一定不为null，所以我们判断是否是empty，
如果是empty，就调用两参的函数，进行一次Full Bind。
如果不是empty，就进行partial bind，
通过下标0取出我们在getChangePayload方法里返回的payload，然后遍历payload的key，根据key检索，如果payload里携带有相应的改变，就取出来 然后更新在ItemVIEw上。
（这里，通过mDatas获得的也是最新数据源的数据，所以用payload的数据或者新数据的数据 进行更新都可以）

至此，我们已经掌握了刷新RecyclerVIEw，文艺青年中最文艺的那种写法。

四 在子线程中使用DiffUtil

在DiffUtil的源码头部注释中介绍了DiffUtil的相关信息，
DiffUtil内部采用的Eugene W. Myers's difference 算法，但该算法不能检测移动的item，所以Google在其基础上改进支持检测移动项目，但是检测移动项目，会更耗性能。
在有1000项数据，200处改动时，这个算法的耗时：
打开了移动检测时：平均值：27.07ms，中位数：26.92ms。
关闭了移动检测时：平均值：13.54ms，中位数：13.36ms。
有兴趣可以自行去源码头部阅读注释，对我们比较有用的是其中一段提到，
如果我们的List过大，这个计算出DiffResult的时间还是蛮久的，所以我们应该将获取DiffResult的过程放到子线程中，并在主线程中更新RecyclerVIEw。

这里我采用Handler配合DiffUtil使用：

代码如下：

 private static final int H_CODE_UPDATE = 1; private List<TestBean> mNewDatas;//增加一个变量暂存newList private Handler mHandler = new Handler() {  @OverrIDe  public voID handleMessage(Message msg) {   switch (msg.what) {    case H_CODE_UPDATE:     //取出Result     DiffUtil.DiffResult diffResult = (DiffUtil.DiffResult) msg.obj;     diffResult.dispatchUpdatesTo(mAdapter);     //别忘了将新数据给Adapter     mDatas = mNewDatas;     mAdapter.setDatas(mDatas);     break;   }  } };   new Thread(new Runnable() {    @OverrIDe    public voID run() {     //放在子线程中计算DiffResult     DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffCallBack(mDatas,mNewDatas),true);     Message message = mHandler.obtainMessage(H_CODE_UPDATE);     message.obj = diffResult;//obj存放DiffResult     message.sendToTarget();    }   }).start();

就是简单的Handler使用，不再赘述。

五总结和其他

1 其实本文代码量很少，可下载Demo查看，一共就四个类。
但是不知不觉又被我写的这么长，主要涉及到了一些源码的注释的翻译，方便大家更好的理解。

2 DiffUtil很适合下拉刷新这种场景，
更新的效率提高了，而且带动画，而且~还不用你动脑子算了。
不过若是就做个删除 点赞这种，完全不用DiffUtils。自己记好postion，判断一下postion在不在屏幕里，调用那几个定向刷新的方法即可。

3 其实DiffUtil不是只能和RecyclerVIEw.Adapter配合使用，
我们可以自己实现 ListUpdateCallback接口，利用DIffUtil帮我们找到新旧数据集的最小差异集 来做更多的事情。

4 注意 写DEMO的时候，用于比较的新老数据集，不仅ArrayList不同，里面每个data也要不同。 否则changed 无法触发。
实际项目中遇不到，因为新数据往往是网络来的。

5 今天是中秋节的最后一天，我们公司居然就开始上班了！！！气愤之余，我怒码一篇DiffUtil，我都不需要用DiffUtil，也能轻易比较出我们公司和其他公司的差异。QAQ，而且今天状态不佳，居然写了8个小时才完工。本以为这篇文章是可以入选微作文集的，没想到也是蛮长的。没有耐心的其实可以下载DEMO看看，代码量没多少，使用起来还是很轻松的。

github传送门：
https://github.com/mcxtzhang/DiffUtils

以上就是对Android7.0 工具类DiffUtil 的资料整理，后续继续补充相关资料，谢谢大家对本站的支持！

总结

以上是内存溢出为你收集整理的Android7.0 工具类：DiffUtil详解全部内容，希望文章能够帮你解决Android7.0 工具类：DiffUtil详解所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。