android RecycleView 局部刷新方式总结

在5.0以后大家在使用列表控件时已经逐渐的使用recycleView来代替ListView了，但是很多人并不了解recycleView的高效率的刷新方式

首先我们先介绍一下recycleView自带的刷新方式：

1.使用 Adapter.notifyDataSetChanged();

优点：简单 粗暴 直接刷新所有的Item布局

缺点：（1）刷新的太多了 影响效率 ，如果遇到复杂的逻辑容易卡顿
（2）刷新的时候无法触发 recycleView 的动画

2.自带的局部刷新

Adapter.notifyItemChanged(int)

Adapter.notifyItemInserted(int)

Adapter.notifyItemRangeChanged(int,int)

Adapter.notifyItemRangeInserted(int,int)

Adapter.notifyItemRangeRemoved(int,int)

优点：不用刷新整个列表可以局部刷新 提高效率

缺点： 每次刷新都要知道position 如果刷新单条比较好使 担当刷新条目比较多的时候需要单独计算每个条目的position不是很方便

3.使用DiffUtil android recycleView-24以后自带的比对数据的类

使用方法：
（1）正常创建adapter 注意设置数据是新建一个List 去接受数据

public void setData(List<TextModel> data) {
    this.data = new ArrayList<>(data);
}

因为在比较的时候需要oldList与新 newList 比较才能得出变化的数据

（2）创建DiffUtil.Callback

public class MyCallback extends DiffUtil.Callback {

  private List<TextModel> old_students, new_students;

  public MyCallback(List<TextModel> data, List<TextModel> students) {
    this.old_students = data;
    this.new_students = students;
  }

  @Override
  public int getOldListSize() {
    return old_students.size();
 }

  @Override
  public int getNewListSize() {
      return new_students.size();
  }

  // 判断Item是否已经存在
  @Override
  public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
    return old_students.get(oldItemPosition).getTextTitle() == new_students.get(newItemPosition).getTextTitle();
  }

// 如果Item已经存在则会调用此方法，判断Item的内容是否一致
  @Override
  public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
    return old_students.get(oldItemPosition).getTextContent().equals(new_students.get(newItemPosition).getTextContent());
  }
}

在这里面需要声明 判断Item是否已经存在 条件 和 如果Item已经存在则会调用此方法，判断Item的内容是否一致 条件。

(3)得到比较结果重新设置数据

    DiffUtil.DiffResult result = DiffUtil.calculateDiff(new MyCallback(oldList, mTextModels), true);
    myAdapter.setData(mTextModels);
    result.dispatchUpdatesTo(myAdapter);

优点：可以自定义比较两个列表中的数据并刷新

缺点：（1）DiffUtil.calculateDiff()这个方法是执行在主线程的，如果新旧数据List比较大，那么这个方法会阻塞主线程可能出现出现ANR
（2）比较完成后必须调用result.dispatchUpdatesTo(myAdapter)重新设置数据

(4)使用AsyncListDiff android recycleView-27以后自带的比对数据的类
android 在recycleView 的V27包对原来的数据比对类进行了更新 产生的一个新的数据比对类就是 AsyncListDiff

使用方法：

（1）创建adapter并在adapter中自实现DiffUtil.ItemCallback，给出item差异性计算条件

 public class MyItemCallBack extends DiffUtil.ItemCallback<TextModel> {
    @Override
    public boolean areItemsTheSame(@NonNull TextModel oldItem, @NonNull TextModel newItem) {
      return TextUtils.equals(oldItem.getTextTitle(), newItem.getTextTitle());
    }

    @Override
    public boolean areContentsTheSame(@NonNull TextModel oldItem, @NonNull TextModel newItem) {
      return TextUtils.equals(oldItem.getTextContent(), newItem.getTextContent());
    }
}

（2）将所有对数据的操作代理给AsyncListDiffer，可以看到这个Adapter是没有List数据的

public class MyDiffAdapter  extends RecyclerView.Adapter {
  private Context mContext;
  private AsyncListDiffer<TextModel> mTextDiffl;
  private DiffUtil.ItemCallback<TextModel> diffCallback = new MyItemCallBack();

  public MyDiffAdapter(Context mContext) {
      this.mContext = mContext;
      mTextDiffl = new AsyncListDiffer<>(this, diffCallback);
  }

  @NonNull
  @Override
  public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
      View itemView = LayoutInflater.from(mContext).inflate(R.layout.item_view, null);
      return new MyViewHolder(itemView);
  }

  @Override
  public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
      MyAdapter.MyViewHolder myViewHolder = (MyAdapter.MyViewHolder) holder;
      TextModel textModel = getItem(position);
      myViewHolder.tv.setText(textModel.getTextTitle() + "." + textModel.getTextContent());
  }

  @Override
  public int getItemCount() {
      return mTextDiffl.getCurrentList().size();
  }
  public void submitList(List<TextModel> data) {
    mTextDiffl.submitList(data);
  }

  public TextModel getItem(int position) {
      return mTextDiffl.getCurrentList().get(position);
  }

  class MyViewHolder extends RecyclerView.ViewHolder {
      TextView tv;

      MyViewHolder(View itemView) {
          super(itemView);
          tv = (TextView) itemView.findViewById(R.id.item_tv);
    }
  }
}

（3）使用submitList()更新数据，并刷新ui

public void change1() {
    for(int i = 0; i<10;i++){
        TextModel textModel= new TextModel("aa"+i,"bb"+i%3);
        mTextModels.add(textModel);
    }
    myDiffAdapter.submitList(mTextModels);
}

对比之前DiffUtil 优点：（1）不用创来那个两个List比较
（2）将比较放在了子线程中 不再中主线程中比较减少刷新造成的卡顿
下面解析一下 AsyncListDiffer的源码

public class AsyncListDiffer<T> {
  private final ListUpdateCallback mUpdateCallback;
  final AsyncDifferConfig<T> mConfig;
  final Executor mMainThreadExecutor;
  private static final Executor sMainThreadExecutor = new AsyncListDiffer.MainThreadExecutor();
  @Nullable
  private List<T> mList;
  @NonNull
  private List<T> mReadOnlyList;
  int mMaxScheduledGeneration;

  public AsyncListDiffer(@NonNull Adapter adapter, @NonNull ItemCallback<T> diffCallback) {
      this((ListUpdateCallback)(new AdapterListUpdateCallback(adapter)), (AsyncDifferConfig)(new Builder(diffCallback)).build());
  }

  public AsyncListDiffer(@NonNull ListUpdateCallback listUpdateCallback, @NonNull AsyncDifferConfig<T> config) {
      this.mReadOnlyList = Collections.emptyList();
      this.mUpdateCallback = listUpdateCallback;
      this.mConfig = config;
      if (config.getMainThreadExecutor() != null) {
          this.mMainThreadExecutor = config.getMainThreadExecutor();
      } else {
          this.mMainThreadExecutor = sMainThreadExecutor;
      }

  }

  @NonNull
  public List<T> getCurrentList() {
      return this.mReadOnlyList;
  }

  public void submitList(@Nullable final List<T> newList) {
      // 用于控制计算线程，防止在上一次submitList未完成时，
      // 又多次调用submitList，这里只返回最后一个计算的DiffResult
      final int runGeneration = ++this.mMaxScheduledGeneration;
      if (newList != this.mList) {
          if (newList == null) {
              int countRemoved = this.mList.size();
              this.mList = null;
              this.mReadOnlyList = Collections.emptyList();
              this.mUpdateCallback.onRemoved(0, countRemoved);
          } else if (this.mList == null) {
              this.mList = newList;
              this.mReadOnlyList = Collections.unmodifiableList(newList);
              this.mUpdateCallback.onInserted(0, newList.size());
          } else {
              final List<T> oldList = this.mList;
              this.mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
                  public void run() {
                      final DiffResult result = DiffUtil.calculateDiff(new Callback() {
                          public int getOldListSize() {
                              return oldList.size();
                          }

                          public int getNewListSize() {
                              return newList.size();
                          }

                          public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
                              T oldItem = oldList.get(oldItemPosition);
                              T newItem = newList.get(newItemPosition);
                              if (oldItem != null && newItem != null) {
                                  return AsyncListDiffer.this.mConfig.getDiffCallback().areItemsTheSame(oldItem, newItem);
                              } else {
                                  return oldItem == null && newItem == null;
                              }
                        }

                          public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
                              T oldItem = oldList.get(oldItemPosition);
                              T newItem = newList.get(newItemPosition);
                              if (oldItem != null && newItem != null) {
                                  return AsyncListDiffer.this.mConfig.getDiffCallback().areContentsTheSame(oldItem, newItem);
                              } else if (oldItem == null && newItem == null) {
                                  return true;
                              } else {
                                  throw new AssertionError();
                              }
                          }

                          @Nullable
                          public Object getChangePayload(int oldItemPosition, int newItemPosition) {
                              T oldItem = oldList.get(oldItemPosition);
                              T newItem = newList.get(newItemPosition);
                              if (oldItem != null && newItem != null) {
                                  return AsyncListDiffer.this.mConfig.getDiffCallback().getChangePayload(oldItem, newItem);
                              } else {
                                  throw new AssertionError();
                              }
                          }
                      });
                      AsyncListDiffer.this.mMainThreadExecutor.execute(new Runnable() {
                          public void run() {
                              if (AsyncListDiffer.this.mMaxScheduledGeneration == runGeneration) {
                                 AsyncListDiffer.this.latchList(newList, result);
                              }

                          }
                      });
                  }
              });
          }
      }
  }

  void latchList(@NonNull List<T> newList, @NonNull DiffResult diffResult) {
      this.mList = newList;
      this.mReadOnlyList = Collections.unmodifiableList(newList);
      diffResult.dispatchUpdatesTo(this.mUpdateCallback);
  }

  private static class MainThreadExecutor implements Executor {
      final Handler mHandler = new Handler(Looper.getMainLooper());

      MainThreadExecutor() {
      }

      public void execute(@NonNull Runnable command) {
          this.mHandler.post(command);
      }
  }
}

他其实就是google自己对DiffUtil进行的一次封装
（1）首先在构造方法中创建线程池进行管理
（2）submitList时候先判断数组的内存地址是否相同
（3）判空
（4）开启子线程使用DiffUtil.calculateDiff进行数据比较
（5）回调

demo github地址：https://github.com/525642022/localRefresh

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,088评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,715评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,361评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,099评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 60,987评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,063评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,486评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,175评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,440评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,518评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,305评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,190评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,550评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,880评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,152评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,451评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,637评论 2赞 335