RecyclerView库中的遗珠，原生Android开发的路该怎么走

2401_84279169

于 2024-04-11 08:17:13 发布

阅读量626

点赞数 20

分类专栏：程序员文章标签： android

本文链接：https://blog.csdn.net/2401_84279169/article/details/137622731

版权

程序员专栏收录该内容

259 篇文章 0 订阅

订阅专栏

}
}

使用起来还是很简单的，来看一下效果图：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

可以看到，我每次添加一条c字母的数据，它会自动帮我排序好，同时刷新列表。修改数据时，自动去重。比起暴力刷新，优雅多了。

2. AsyncListUtil

AsyncListUtil 在 support-v7:23就存在了。它是异步加载数据的工具，它一般用于加载数据库数据，我们无需在UI线程上查询游标，同时它可以保持UI和缓存同步，并且始终只在内存中保留有限数量的数据。使用它可以获得更好的用户体验。

注意，这个类使用单个线程来加载数据，因此它适合从磁盘、数据库加载数据，不适用于从网络加载数据。

用法如下，首先实现AsyncListUtil：

public class MyAsyncListUtil extends AsyncListUtil {

/**

一次加载数据的个数，分页数量
*/
private static final int TILE_SIZE = 20;

public MyAsyncListUtil(RecyclerView mRecyclerView) {
super(TestBean.class, TILE_SIZE, new MyDataCallback(), new MyViewCallback(mRecyclerView));

mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
// 更新当前可见范围数据
onRangeChanged();
}
});
}

/**

获取数据回调
*/
public static class MyDataCallback extends DataCallback{

/**

总数据个数
*/
@Override
public int refreshData() {
return 200;
}

/**

填充数据（后台线程），一般为读取数据库数据
*/
@Override
public void fillData(@NonNull TestBean[] data, int startPosition, int itemCount) {
for (int i = 0; i < itemCount; i++) {
TestBean item = data[i];
if (item == null) {
item = new TestBean(startPosition, “Item：” + (startPosition + i));
data[i] = item;
}
}

try {
// 模拟加载数据中
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

/**

用于获取可见项范围和更新通知的回调
*/
public static class MyViewCallback extends ViewCallback {

private RecyclerView mRecyclerView;

public MyViewCallback(RecyclerView mRecyclerView) {
this.mRecyclerView = mRecyclerView;
}

/**

展示数据的范围
*/
@Override
public void getItemRangeInto(@NonNull int[] outRange) {
RecyclerView.LayoutManager manager = mRecyclerView.getLayoutManager();
LinearLayoutManager mgr = (LinearLayoutManager) manager;
outRange[0] = mgr.findFirstVisibleItemPosition();
outRange[1] = mgr.findLastVisibleItemPosition();
}

/**

刷新数据
*/
@Override
public void onDataRefresh() {
mRecyclerView.getAdapter().notifyDataSetChanged();
}

/**

Item更新
*/
@Override
public void onItemLoaded(int position) {
mRecyclerView.getAdapter().notifyItemChanged(position);
}
}
}

Adapter：

public class AsyncListUtilAdapter extends RecyclerView.Adapter<AsyncListUtilAdapter.ViewHolder> {

private MyAsyncListUtil mMyAsyncListUtil;

public AsyncListUtilAdapter(Context mContext, MyAsyncListUtil mMyAsyncListUtil) {
this.mMyAsyncListUtil = mMyAsyncListUtil;
}

@Override
public int getItemCount() {
return mMyAsyncListUtil.getItemCount();
}

@Override
public void onBindViewHolder(@NonNull AsyncListUtilAdapter.ViewHolder holder, final int position) {
TestBean bean = mMyAsyncListUtil.getItem(position);
// 有可能获取为空，这是可以显示加载中，等待同步数据。
if (bean == null){
holder.mTvName.setText(“加载中…”);
}else {
holder.mTvName.setText(bean.getName());
}
}
…
}

注释还是很清除的，直接上效果图：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.AsyncListDiffer

虽然SortedList、AsyncListUtil很方便了，但是大多数的列表都无需我们排序和加载本地数据，大多是获取网络数据展示。这个时候就可以使用DiffUtil了。DiffUtil是support-v7:24.2.0中的新工具类，它用来比较新旧两个数据集，寻找最小变化量，定向刷新列表。关于DiffUtil的介绍很早之前在张旭童的【Android】RecyclerView的好伴侣：详解DiffUtil 博客中就有详细介绍，我这里就不赘述了。

不过DiffUtil的问题在于计算数据差异DiffUtil.calculateDiff(mDiffCallback)时是一个耗时操作，需要我们放到子线程去处理，最后在主线程刷新。为了方便这一操作，在support-v7:27.1.0又新增了一个DiffUtil的封装类，那就是AsyncListDiffer。

首先先上效果图，一个简单的列表展示，同时增、删、改操作。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

我用AsyncListDiffer来实现这一效果。首先实现DiffUtil.ItemCallback，类似SortedList，制定规则，如何区分数据。这里和DiffUtil用法几乎一样，只是它是实现DiffUtil.Callback。

public class MyDiffUtilItemCallback extends DiffUtil.ItemCallback {

/**

是否是同一个对象
/
@Override
public boolean areItemsTheSame(@NonNull TestBean oldItem, @NonNull TestBean newItem) {
return oldItem.getId() == newItem.getId();
}
/*
是否是相同内容
*/
@Override
public boolean areContentsTheSame(@NonNull TestBean oldItem, @NonNull TestBean newItem) {
return oldItem.getName().equals(newItem.getName());
}

/**

areItemsTheSame()返回true而areContentsTheSame()返回false时调用,也就是说两个对象代表的数据是一条，但是内容更新了。此方法为定向刷新使用，可选。
*/
@Nullable
@Override
public Object getChangePayload(@NonNull TestBean oldItem, @NonNull TestBean newItem) {
Bundle payload = new Bundle();

if (!oldItem.getName().equals(newItem.getName())) {
payload.putString(“KEY_NAME”, newItem.getName());
}

if (payload.size() == 0){
//如果没有变化就传空
return null;
}
return payload;
}
}

Adapter部分有两种实现方法，一种是实现RecyclerView.Adapter，

public class AsyncListDifferAdapter extends RecyclerView.Adapter<AsyncListDifferAdapter.ViewHolder> {

private LayoutInflater mInflater;
// 数据的操作由AsyncListDiffer实现
private AsyncListDiffer mDiffer;

public AsyncListDifferAdapter(Context mContext) {
// 初始化AsyncListDiffe
mDiffer = new AsyncListDiffer<>(this, new MyDiffUtilItemCallback());
mInflater = LayoutInflater.from(mContext);
}

public void setData(TestBean mData){
List mList = new ArrayList<>();
mList.addAll(mDiffer.getCurrentList());
mList.add(mData);
mDiffer.submitList(mList);
}

public void setData(List mData){
// 由于DiffUtil是对比新旧数据，所以需要创建新的集合来存放新数据。
// 实际情况下，每次都是重新获取的新数据，所以无需这步。
List mList = new ArrayList<>();
mList.addAll(mData);
mDiffer.submitList(mList);
}

public void removeData(int index){
List mList = new ArrayList<>();
mList.addAll(mDiffer.getCurrentList());
mList.remove(index);
mDiffer.submitList(mList);
}

public void clear(){
mDiffer.submitList(null);
}

@Override
@NonNull
public AsyncListDifferAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return new ViewHolder(mInflater.inflate(R.layout.item_test, parent, false));
}

@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position, @NonNull List payloads) {
if (payloads.isEmpty()) {
onBindViewHolder(holder, position);
} else {
Bundle bundle = (Bundle) payloads.get(0);
holder.mTvName.setText(bundle.getString(“KEY_NAME”));
}
}

@Override
public void onBindViewHolder(@NonNull AsyncListDifferAdapter.ViewHolder holder, final int position) {
TestBean bean = mDiffer.getCurrentList().get(position);
holder.mTvName.setText(bean.getName());
}

@Override
public int getItemCount() {
return mDiffer.getCurrentList().size();
}

static class ViewHolder extends RecyclerView.ViewHolder {

…
}
}

另一种Adapter写法可以实现ListAdapter，它的内部帮我们实现了getItemCount()、getItem()和AsyncListDiffer的初始化。

源码如下，很简单：

public abstract class ListAdapter<T, VH extends ViewHolder> extends Adapter {
private final AsyncListDiffer mHelper;

protected ListAdapter(@NonNull ItemCallback diffCallback) {
this.mHelper = new AsyncListDiffer(new AdapterListUpdateCallback(this), (new Builder(diffCallback)).build());
}

protected ListAdapter(@NonNull AsyncDifferConfig config) {
this.mHelper = new AsyncListDiffer(new AdapterListUpdateCallback(this), config);
}

public void submitList(@Nullable List list) {
this.mHelper.submitList(list);
}

protected T getItem(int position) {
return this.mHelper.getCurrentList().get(position);
}

public int getItemCount() {
return this.mHelper.getCurrentList().size();
}
}

不过有个缺点，没有提供直接获取当前集合的getCurrentList()方法。所以需要自己维护一个集合。希望以后可以添加上吧。所以现阶段我还是不推荐这种写法。。。不过我们可以去做这个封装。

public class MyListAdapter extends ListAdapter<TestBean, MyListAdapter.ViewHolder> {

private LayoutInflater mInflater;
// 自己维护的集合
private List mData = new ArrayList<>();

public MyListAdapter(Context mContext) {
super(new MyDiffUtilItemCallback());
mInflater = LayoutInflater.from(mContext);
}

public void setData(TestBean testBean){
mData.add(testBean);
List mList = new ArrayList<>();
mList.addAll(mData);
// 提交新的数据集
submitList(mList);
}

public void setData(List list){
mData.clear();
mData.addAll(list);
List mList = new ArrayList<>();
mList.addAll(mData);
submitList(mList);
}

public void removeData(int index){
mData.remove(index);
List mList = new ArrayList<>();
mList.addAll(mData);
submitList(mList);
}

public void clear(){
mData.clear();
submitList(null);
}

@Override
@NonNull
public MyListAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return new ViewHolder(mInflater.inflate(R.layout.item_test, parent, false));
}

@Override
public void onBindViewHolder(@NonNull MyListAdapter.ViewHolder holder, final int position) {
TestBean bean = getItem(position);
holder.mTvName.setText(bean.getName());
}

static class ViewHolder extends RecyclerView.ViewHolder {
…
}
}

最后就是Activity了：

public class AsyncListDifferActivity extends AppCompatActivity {

private AsyncListDifferAdapter mAsyncListDifferAdapter;
private int count = 10;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sorted_list);
RecyclerView mRecyclerView = findViewById(R.id.rv);
mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
mAsyncListDifferAdapter = new AsyncListDifferAdapter(this);
mRecyclerView.setAdapter(mAsyncListDifferAdapter);
initData();
}

private void addData() {
mAsyncListDifferAdapter.setData(new TestBean(count, "Item " + count));
count ++;
}

private List mList = new ArrayList();

private void initData() {
mList.clear();
for (int i = 0; i < 10; i++){
mList.add(new TestBean(i, "Item " + i));
}
mAsyncListDifferAdapter.setData(mList);
}

private void updateData() {
mList.clear();
for (int i = 9; i >= 0; i–){
mList.add(new TestBean(i, "Item " + i));
}
mAsyncListDifferAdapter.setData(mList);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu, menu);
return true;
}

private Random mRandom = new Random();

@Override
public boolean onOptionsItemSelected(MenuItem item) {
int i = item.getItemId();
if (i == R.id.menu_add) {
addData();
} else if (i == R.id.menu_update) {
updateData();
} else if (i == R.id.menu_delete) {
if (mAsyncListDifferAdapter.getItemCount() > 0){
mAsyncListDifferAdapter.removeData(mRandom.nextInt(mAsyncListDifferAdapter.getItemCount()));
}
}else if (i == R.id.menu_clear){
mAsyncListDifferAdapter.clear();
}
return true;
}
}

我们简单的看一下AsyncListDiffer 的 submitList源码：

public void submitList(@Nullable final List newList) {
final int runGeneration = ++this.mMaxScheduledGeneration;
if (newList != this.mList) {
if (newList == null) {
// 新数据为null时清空列表
int countRemoved = this.mList.size();
this.mList = null;
this.mReadOnlyList = Collections.emptyList();
this.mUpdateCallback.onRemoved(0, countRemoved);
} else if (this.mList == null) {
// 旧数据为null时添加数据
this.mList = newList;
this.mReadOnlyList = Collections.unmodifiableList(newList);
this.mUpdateCallback.onInserted(0, newList.size());
} else {
final List oldList = this.mList;
// 计算数据差异放在子线程
this.mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
public void run() {
final DiffResult result = DiffUtil.calculateDiff(new Callback() {
…
});
// 主线程刷新列表
AsyncListDiffer.this.mMainThreadExecutor.execute(new Runnable() {
public void run() {
if (AsyncListDiffer.this.mMaxScheduledGeneration == runGeneration) {
AsyncListDiffer.this.latchList(newList, result);
}

}
});
}
});
}
}
}

void latchList(@NonNull List newList, @NonNull DiffResult diffResult) {
this.mList = newList;
this.mReadOnlyList = Collections.unmodifiableList(newList);
// 熟悉的dispatchUpdatesTo方法
diffResult.dispatchUpdatesTo(this.mUpdateCallback);
}

AsyncListDiffer就是在这里帮我们做了线程的处理。方便我们正确规范的使用。

4.SnapHelper

SnapHelper是support-v7:24.2.0新增的，用于控制RecyclerView滑动停止后Item的对齐方式。默认提供了两种对齐方式PagerSnapHelper 与 LinearSnapHelper。PagerSnapHelper 和ViewPage效果一样，一次滑动一页。LinearSnapHelper这是Item居中对齐。使用方式非常简单：

PagerSnapHelper mPagerSnapHelper = new PagerSnapHelper();
mPagerSnapHelper.attachToRecyclerView(mRecyclerView);

效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

当然我们可以自定义SnapHelper，来实现我们想要的对齐方式，下面我们来实现一下左对齐。

public class MySnapHelper extends LinearSnapHelper{

/**

水平、垂直方向的度量
*/
@Nullable
private OrientationHelper mVerticalHelper;
@Nullable
private OrientationHelper mHorizontalHelper;

@NonNull
private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
if (mVerticalHelper == null) {
mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
}
return mVerticalHelper;
}

@NonNull
private OrientationHelper getHorizontalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
if (mHorizontalHelper == null) {
mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
}
return mHorizontalHelper;
}

/**

计算出View对齐到指定位置，所需的x、y轴上的偏移量。
*/
@Nullable
@Override
public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后我想说

为什么很多程序员做不了架构师？
1、良好健康的职业规划很重要，但大多数人都忽略了
2、学习的习惯很重要，持之以恒才是正解。
3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展
4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。

金九银十面试季，跳槽季，整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

里面包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

规划很重要，但大多数人都忽略了
2、学习的习惯很重要，持之以恒才是正解。
3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展
4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。

[外链图片转存中…(img-9JK4BnIf-1712794625747)]

里面包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84279169

关注

20
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
RecyclerView库中的遗珠，原生Android开发的路该怎么走

为什么很多程序员做不了架构师？1、良好健康的职业规划很重要，但大多数人都忽略了2、学习的习惯很重要，持之以恒才是正解。3、编程思维没能提升一个台阶，局限在了编码，业务，没考虑过选型、扩展4、身边没有好的架构师引导、培养。所处的圈子对程序员的成长影响巨大。金九银十面试季，跳槽季，整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。
复制链接

扫一扫