Android——RecyclerView——RecycledViewPool类——源码注释翻译：RecycledViewPool类的官方解释

总结：他就是一个让多个RecyclerView之间共享ViewHolder的类，如果没有多个RecyclerView，它也会自动创建一个这个类的实例给自己用。

RecycledViewPool是用来在多个RecyclerView中共享View的类。

就算你只有一个RecyclerView，它也会自动创建一个RecyclerViewPool的实例给它自己使用。

 

//默认最大废品量

private static final int DEFAULT_MAX_SCRAP= 5;

 

//静态嵌套类，用来描述所有废品的元数据。

//跟踪在pool中的ViewHolders和创建/绑定给定类型的viewHolder（？）所花时间的元数据。注意它跟踪的是所有的RecyclerViews或者间接适配器上创建/绑定所花事件的平均值。

1.这使我们可以去在多个适配器间追踪平均创建和绑定的时间。尽管创建（特别是绑定）或许表现的不同对于不同的适配器子类，共享这个池是一个强力的信号对于他们将执行类似的，每种类型。

2.如果willBindInTime（int，long，long）为一个视图返回false，它将返回对于同一截止日期的所有其他类型的视图都是错误的，这可以防止项目由GapWorker预取构造而不被绑定到较低优先级的预取。

static class ScrapData {

           ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();

           int mMaxScrap = DEFAULT_MAX_SCRAP;

           long mCreateRunningAverageNs = 0;

           long mBindRunningAverageNs = 0;

       }

SparseArray<ScrapData> mScrap = newSparseArray<>();

 

private int mAttachCount = 0;

 

public void clear() {

           for (int i = 0; i < mScrap.size(); i++) {

                ScrapData data =mScrap.valueAt(i);

                data.mScrapHeap.clear();

           }

       }

 

public void setMaxRecycledViews(intviewType, int max) {

            //通过不同的viewType取出scrapData

           ScrapData scrapData = getScrapDataForType(viewType);

           scrapData.mMaxScrap = max;

           final ArrayList<ViewHolder> scrapHeap = scrapData.mScrapHeap;

            //如果设定的最大值小于当前的数量，就删去多余的

           if (scrapHeap != null) {

                while (scrapHeap.size() >max) {

                   scrapHeap.remove(scrapHeap.size() - 1);

                }

           }

       }

 

//取得这一种类型的数量

public int getRecycledViewCount(intviewType) {

           return getScrapDataForType(viewType).mScrapHeap.size();

       }

 

public ViewHolder getRecycledView(intviewType) {

           final ScrapData scrapData = mScrap.get(viewType);

            //scrapData不为空且其中的viewholder集合不为空

           if (scrapData != null && !scrapData.mScrapHeap.isEmpty()) {

                finalArrayList<ViewHolder> scrapHeap = scrapData.mScrapHeap;

                //把当前栈顶的拿出来了

                returnscrapHeap.remove(scrapHeap.size() - 1);

           }

           return null;

       }

 

//取得所有类型的数量总和

int size() {

           int count = 0;

           for (int i = 0; i < mScrap.size(); i ++) {

                ArrayList<ViewHolder>viewHolders = mScrap.valueAt(i).mScrapHeap;

                if (viewHolders != null) {

                    count +=viewHolders.size();

                }

           }

           return count;

       }

 

public void putRecycledView(ViewHolderscrap) {

            //取得这个viewHolder的类型（这个itemType是在哪里赋值的呢？）

           final int viewType = scrap.getItemViewType();

            //取得这个类型的ScrapData，再取得这个类型的所有viewHolder

           final ArrayList scrapHeap = getScrapDataForType(viewType).mScrapHeap;

            //如果最大数量小于等于当前数量，返回

           if (mScrap.get(viewType).mMaxScrap <= scrapHeap.size()) {

                return;

           }

            //如果debug且已经包含了这个viewHolder了

           if (DEBUG && scrapHeap.contains(scrap)) {

                throw newIllegalArgumentException("this scrap item already exists");

           }

           //把这个viewHolder中所有之前添加进去的东西全部清空

           scrap.resetInternal();

           scrapHeap.add(scrap);

       }

 

(?)

long runningAverage(long oldAverage, longnewValue) {

           if (oldAverage == 0) {

                return newValue;

           }

           return (oldAverage / 4 * 3) + (newValue / 4);

       }

 

(?)

void factorInCreateTime(int viewType, longcreateTimeNs) {

           ScrapData scrapData = getScrapDataForType(viewType);

           scrapData.mCreateRunningAverageNs = runningAverage(

                   scrapData.mCreateRunningAverageNs, createTimeNs);

       }

 

(?)

void factorInBindTime(int viewType, longbindTimeNs) {

           ScrapData scrapData = getScrapDataForType(viewType);

           scrapData.mBindRunningAverageNs = runningAverage(

                   scrapData.mBindRunningAverageNs, bindTimeNs);

       }

 

//是否能及时创建

boolean willCreateInTime(int viewType, longapproxCurrentNs, long deadlineNs) {

           long expectedDurationNs =getScrapDataForType(viewType).mCreateRunningAverageNs;

            //如果创建这种viewType的预期时间为0或者当前时间+预期时间小于截止时间就能行

           return expectedDurationNs == 0 || (approxCurrentNs + expectedDurationNs< deadlineNs);

       }

 

boolean willBindInTime(int viewType, longapproxCurrentNs, long deadlineNs) {

           long expectedDurationNs =getScrapDataForType(viewType).mBindRunningAverageNs;

           return expectedDurationNs == 0 || (approxCurrentNs + expectedDurationNs< deadlineNs);

       }

 

//传进来一个参数你不用，不如不传！让我云里雾里的。还是说想让Adapter在这里被回收掉。

void attach(Adapter adapter) {

           mAttachCount++;

       }

 

void detach() {

           mAttachCount--;

       }

 

//分离旧的适配器并附加新的适配器。

RecycledViewPool将清除它的缓存，如果它只有一个适配器连接并且新的

适配器使用与旧适配器不同的ViewHolder。

void onAdapterChanged(Adapter oldAdapter,Adapter newAdapter,

                boolean compatibleWithPrevious){

           if (oldAdapter != null) {

                detach();

           }

           if (!compatibleWithPrevious && mAttachCount == 0) {

                clear();

           }

           if (newAdapter != null) {

                attach(newAdapter);

           }

       }

 

private ScrapData getScrapDataForType(intviewType) {

           ScrapData scrapData = mScrap.get(viewType);

           if (scrapData == null) {

                //sparseArray，稀疏数组，相当于map，如果没有这个type的映射，就创建一个

                scrapData = new ScrapData();

                mScrap.put(viewType,scrapData);

           }

           return scrapData;

       }