RecycleView就一定比listView好用吗？(listView篇)

素颜马尾好姑娘i 2022-06-09 11:57 154阅读 0赞

# 转载自：http://www.jianshu.com/p/0ec7b56d974e #

# RecyclerView是Android 5.0系统官方推出的一个代替listView的组件，那么究竟好在哪里呢？我们来仔细分析一下这两个组件。 #

listView和RecycleView的原理大致相同，如下图

![1240][]

都是在内部维护一个缓存池，回收划出列表的item，添加给将要进入列表的item。只不过ListView内部是两级缓存，分别是mActiveViews和mScrapViews.而RecycleView内部有四级缓存。

# listView的实现原理 #

首先需要介绍一下RecycleBin 这个类。

## RecycleBin ##

RecycleBin中的变量

mRecyclerListener:  
一般会在某个item被移除屏幕的时候调用，将这个item回收到scrap heap，并回收item上相关的资源布局

mActiveViews:  
用来保存item的一个临时数组，主要是用在listView第二次onLayout()时，给ListView提供item，

mFirstActivePosition  
存储在mActiveViews中的第一个View的位置

mViewTypeCount  
view类型数量，

mScrapViews和mCurrentScrap  
mCurrentScrap是ArrayList<View> 类型  
而mScrapViews是ArrayList<View>\[\]类型

当mViewTypeCount=1，也就是listView中只有一种类型的item时(不包括header和footer)，item是存入到mCurrentScrap中的  
当mViewTypeCount>1的时候，ScrapViews数组就会有多个值，分别缓存一个类型的item

另外，adapter中getView()方法中的参数的convertView的值就是mScrapViews和mCurrentScrap传过去的。

RecycleBin中的方法

markChildrenDirty():该方法会为回收回来的每一个view调用forceLayout(),作用是在该view被复用的时候重新layout，

public void markChildrenDirty() {
        if (mViewTypeCount == 1) {
            final ArrayList<View> scrap = mCurrentScrap;
            final int scrapCount = scrap.size();
            for (int i = 0; i < scrapCount; i++) {
                scrap.get(i).forceLayout();
            }
        } else {
            final int typeCount = mViewTypeCount;
            for (int i = 0; i < typeCount; i++) {
                final ArrayList<View> scrap = mScrapViews[i];
                final int scrapCount = scrap.size();
                for (int j = 0; j < scrapCount; j++) {
                    scrap.get(j).forceLayout();
                }
            }
        }   
    }
    
    /**
     * Forces this view to be laid out during the next layout pass.
     * This method does not call requestLayout() or forceLayout()
     * on the parent.
     */
    public void forceLayout() {
        if (mMeasureCache != null) mMeasureCache.clear();
    
        mPrivateFlags |= PFLAG_FORCE_LAYOUT;
        mPrivateFlags |= PFLAG_INVALIDATED;
    }

fillActiveViews():接受两个参数，第一个是要存储view的数量，一般会是一个屏幕所见的item数量，第二个参数表示屏幕中第一个可见item的position，这个方法被调用之后，mActiveViews这个数组就会缓存相应数量的item

void fillActiveViews(int childCount, int firstActivePosition) {  
        if (mActiveViews.length < childCount) {  
            mActiveViews = new View[childCount];  
        }  
        mFirstActivePosition = firstActivePosition;  
        final View[] activeViews = mActiveViews;  
        for (int i = 0; i < childCount; i++) {  
            View child = getChildAt(i);  
            AbsListView.LayoutParams lp = (AbsListView.LayoutParams) child.getLayoutParams();  
            // Don't put header or footer views into the scrap heap  
            if (lp != null && lp.viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {  
                // Note: We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in  
                // active views.  
                // However, we will NOT place them into scrap views.  
                activeViews[i] = child;  
            }  
        }  
    }

getActiveView(): 与fillActiveViews()相对应，获取相应位置的item，但是为什么在获取到对应的View之后，要将mActiveViews\[\]数组对应位置的数据置为空呢？那是因为mActiveViews\[\]这个数组实际上只是一个临时数组，方便listView第二次onLayout的时候提高效率，置为空就可以回收内存了。

View getActiveView(int position) {
        int index = position - mFirstActivePosition;
        final View[] activeViews = mActiveViews;
        if (index >=0 && index < activeViews.length) {
            final View match = activeViews[index];
            activeViews[index] = null;
            return match;
        }
        return null;
    }

addScrapView():首先判断是否需要回收，header和footer都是不回收的，加到忽略的list里，接着判断mViewTypeCount的数量，即item的类型有几种，mViewTypeCount==1，就加到mCurrentScrap中，>1,就加到mScrapViews\[\]中，

另mRecyclerListener.onMovedToScrapHeap(scrap);当item被回收的时候，通知监听器回收资源，这也是为什么listView能存放那么多数据而不崩溃的原因，

void addScrapView(View scrap, int position) {
            final AbsListView.LayoutParams lp = (AbsListView.LayoutParams) scrap.getLayoutParams();
            if (lp == null) {
                // Can't recycle, but we don't know anything about the view.
                // Ignore it completely.
                return;
            }
    
            lp.scrappedFromPosition = position;
    
            // Remove but don't scrap header or footer views, or views that
            // should otherwise not be recycled.
            final int viewType = lp.viewType;
            if (!shouldRecycleViewType(viewType)) {
                // Can't recycle. If it's not a header or footer, which have
                // special handling and should be ignored, then skip the scrap
                // heap and we'll fully detach the view later.
                if (viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
                    getSkippedScrap().add(scrap);
                }
                return;
            }
    
            .....
    
            // Don't scrap views that have transient state.
            final boolean scrapHasTransientState = scrap.hasTransientState();
            if (scrapHasTransientState) {
              .......
            } else {
                if (mViewTypeCount == 1) {
                    mCurrentScrap.add(scrap);
                } else {
                    mScrapViews[viewType].add(scrap);
                }
    
                if (mRecyclerListener != null) {
                    mRecyclerListener.onMovedToScrapHeap(scrap);
                }
            }
        }

getScrapView():复用item

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;
        }

retrieveFromScrap():根据position，查找对应的view，从代码来看分三种情况  
1.如果view.scrappedFromPosition==position,直接返回view  
这里的scrappedFromPosition就是在addScrapView回收时的位置。  
2.不符合1中的条件，则会返回mScrapView中的最后一个数据  
3.如果mScrapView中没有的话，则返回null，这个时候的view需要getView()来加载

情景案列:  
listView中正好有6个item，此时mScrapView为空，这个时候listView像上滑动一点，则需要展示第7个item，mScrapView中没有，只能通过getView()加载，当第7个item完全显示，则第一个item会被回收，mScrapView中便会有一个item的缓存。

这个时候如果再向上滑动，第8个item需要显示，注意，这里的第8个，实际上对于listView来说是第7个，从mScrapView查询对应下标的item，无  
果，只能返回mScrapView中最后一个item作为convert。

如果刚才不是向上滑动，而是向下滑动，第1个item需要显示，从mScrapView中查找，正好有对应下标的item，直接返回做convert。

private View retrieveFromScrap(ArrayList<View> scrapViews, int position) {
        final int size = scrapViews.size();
        if (size > 0) {
            // See if we still have a view for this position or ID.
            for (int i = 0; i < size; i++) {
                final View view = scrapViews.get(i);
                final AbsListView.LayoutParams params =
                        (AbsListView.LayoutParams) view.getLayoutParams();
                //不重写BaseAdapter的hasStableIds方法，这个if就会是false
                if (mAdapterHasStableIds) {
                    final long id = mAdapter.getItemId(position);
                    if (id == params.itemId) {
                        return scrapViews.remove(i);
                    }
                } else if (params.scrappedFromPosition == position) {
                    final View scrap = scrapViews.remove(i);
                    clearAccessibilityFromScrap(scrap);
                    return scrap;
                }
            }
            final View scrap = scrapViews.remove(size - 1);
            clearAccessibilityFromScrap(scrap);
            return scrap;
        } else {
            return null;
        }
    }

## 进入调用流程 ##

ListView的继承关系

> Object->View->...->AbsListView->ListView

由于ListView最终还是继承自view的，所以有着View该有的属性，自然也有onMeasure(),onLayout()和onDraw()

一般情况下，如果View的子视图不为空的话，onMeasure()和onLayout()都会执行两遍。

因为最开始父视图是没有子视图的，这个时候会执行一次onMeasure()和onLayout()，然后当你往父视图里添加子视图的时候，父视图的状态会发生变化，重新执行onMeasure()和onLayout()。

listView初始化时必然要经历的过程

1.ListView.onMeasure():

2.AbsListView.onLayout():一般初始化子View的时候，都是调用父视图的onLayout()

2.1 ListView.layoutChildren()  
2.2 ListView.fillFromTop()  
2.3 ListView.fillDown()  
2.4 ListView.makeAndAddView()  
2.5 ListView.setupChild()

3.ListView.onDraw():

onMeasure()和onDraw()对于listView来说，并没有什么特殊的，所以下文着重介绍onLayout()的过程。

ListView的onLayout()方法在父类AbsListView中

onLayout(): 该方法中有个if语句，判断当数据发生变化的时候，强制子视图重绘视图。除此之外，就是一个layoutChildren的方法了，这个方法一看就知道是给子类布局的。具体的实现也在子类listView中

protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
    
        mInLayout = true;
    
        final int childCount = getChildCount();
        if (changed) {
            for (int i = 0; i < childCount; i++) {
                getChildAt(i).forceLayout();
            }
            mRecycler.markChildrenDirty();
        }
    
        layoutChildren();
        mInLayout = false;
        .....
    }

layoutChildren(): layoutChildren的代码有点多，下面的代码已经把不必要的代码省略，首先会获取子类的数量，这是childCount==0，接下来是两个if判断，判断数据是否发生变化，这里是否，所以跳过两个if，进入swich语句，mLayoutMode默认情况下是LAYOUT\_NORMAL,所以进入default，接着两个判断，childCount==0,布局顺序默认从上往下，所以会调用fillFromTop()方法，

@Override
    protected void layoutChildren() {
        final boolean blockLayoutRequests = mBlockLayoutRequests;
        if (blockLayoutRequests) {
            return;
        }
    
        mBlockLayoutRequests = true;
    
        try {
            ....
            final int childCount = getChildCount();
            ...
            boolean dataChanged = mDataChanged;
            if (dataChanged) {
                handleDataChanged();
            }
            ....
            if (dataChanged) {
                for (int i = 0; i < childCount; i++) {
                    recycleBin.addScrapView(getChildAt(i), firstPosition+i);
                }
            } else {
                recycleBin.fillActiveViews(childCount, firstPosition);
            }
    
            // Clear out old views
            detachAllViewsFromParent();
            recycleBin.removeSkippedScrap();
    
            switch (mLayoutMode) {
            case LAYOUT_SET_SELECTION:
                if (newSel != null) {
                    sel = fillFromSelection(newSel.getTop(), childrenTop, childrenBottom);
                } else {
                    sel = fillFromMiddle(childrenTop, childrenBottom);
                }
                break;
            case LAYOUT_SYNC:
                sel = fillSpecific(mSyncPosition, mSpecificTop);
                break;
            case LAYOUT_FORCE_BOTTOM:
                sel = fillUp(mItemCount - 1, childrenBottom);
                adjustViewsUpOrDown();
                break;
            case LAYOUT_FORCE_TOP:
                mFirstPosition = 0;
                sel = fillFromTop(childrenTop);
                adjustViewsUpOrDown();
                break;
            case LAYOUT_SPECIFIC:
                sel = fillSpecific(reconcileSelectedPosition(), mSpecificTop);
                break;
            case LAYOUT_MOVE_SELECTION:
                sel = moveSelection(oldSel, newSel, delta, childrenTop, childrenBottom);
                break;
            default:
                if (childCount == 0) {
                    if (!mStackFromBottom) {
                        final int position = lookForSelectablePosition(0, true);
                        setSelectedPositionInt(position);
                        sel = fillFromTop(childrenTop);
                    } else {
                        final int position = lookForSelectablePosition(mItemCount - 1, false);
                        setSelectedPositionInt(position);
                        sel = fillUp(mItemCount - 1, childrenBottom);
                    }
                } else {
                    if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
                        sel = fillSpecific(mSelectedPosition,
                                oldSel == null ? childrenTop : oldSel.getTop());
                    } else if (mFirstPosition < mItemCount) {
                        sel = fillSpecific(mFirstPosition,
                                oldFirst == null ? childrenTop : oldFirst.getTop());
                    } else {
                        sel = fillSpecific(0, childrenTop);
                    }
                }
                break;
            }
    
            ...
    }

fillFromTop(): 获取mFirstPosition的值，然后调用fillDown()方法

private View fillFromTop(int nextTop) {
        mFirstPosition = Math.min(mFirstPosition, mSelectedPosition);
        mFirstPosition = Math.min(mFirstPosition, mItemCount - 1);
        if (mFirstPosition < 0) {
            mFirstPosition = 0;
        }
        return fillDown(mFirstPosition, nextTop);
    }

fillDown():首先获取listView整个控件的高度end，这里用的是Botton-top-padding.bottom的方式，接下来会进入一个while循环，判断nextTop也就是item的top值是否小于end，小于表示还在屏幕内。同时还要判断pos是否小于mItemCount，mItemCount是Adapter中的item个数。满足两个条件，则往listView中添加item，用的是makeAndAddView()方法。

private View fillDown(int pos, int nextTop) {
        View selectedView = null;
    
        int end = (mBottom - mTop);
        if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
            end -= mListPadding.bottom;
        }
    
        while (nextTop < end && pos < mItemCount) {
            // is this the selected item?
            boolean selected = pos == mSelectedPosition;
            View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);
    
            nextTop = child.getBottom() + mDividerHeight;
            if (selected) {
                selectedView = child;
            }
            pos++;
        }
    
        setVisibleRangeHint(mFirstPosition, mFirstPosition + getChildCount() - 1);
        return selectedView;
    }

makeAndAddView():首先会尝试从RecycleBin获取一个view，可惜第一次是获取不到的，接下来会执行到obtainView()方法，

private View makeAndAddView(int position, int y, boolean flow, int childrenLeft,boolean selected) {
        View child;
        if (!mDataChanged) {
            // Try to use an existing view for this position
            child = mRecycler.getActiveView(position);
            if (child != null) {
                // Found it -- we're using an existing child
                // This just needs to be positioned
                setupChild(child, position, y, flow, childrenLeft, selected, true);
    
                return child;
            }
        }
    
        // Make a new view for this position, or convert an unused view if possible
        child = obtainView(position, mIsScrap);
    
        // This needs to be positioned and measured
        setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);
    
        return child;
    }

obtainView():代码第四行，尝试从RecycleBin中获取一个view，不过这时返回的结果会是null，接下来一个if语句，假设scrapView！=null，那会调用mAdapter.getView()方法，相信这个方法大家都再熟悉不过了吧！同时将scrapView当成一个参数传给getView，这里的scrapView就是getView中的convert。  
那么当scrapView==null时，同样调用mAdapter.getView()方法，只不过这个时候getView中的convert==null,这个时候的convert就需要在你自己重写的getview中初始化，通过LayoutInflater函数。不过如何，最后都会返回一个view。

View obtainView(int position, boolean[] isScrap) {  
        isScrap[0] = false;  
        View scrapView;  
        scrapView = mRecycler.getScrapView(position);  
        View child;  
        if (scrapView != null) {  
            child = mAdapter.getView(position, scrapView, this);  
            if (child != scrapView) {  
                mRecycler.addScrapView(scrapView);  
                if (mCacheColorHint != 0) {  
                    child.setDrawingCacheBackgroundColor(mCacheColorHint);  
                }  
            } else {  
                isScrap[0] = true;  
                dispatchFinishTemporaryDetach(child);  
            }  
        } else {  
            child = mAdapter.getView(position, null, this);  
            if (mCacheColorHint != 0) {  
                child.setDrawingCacheBackgroundColor(mCacheColorHint);  
            }  
        }  
        return child;  
    }

回到makeAndAddView()中，代码继续执行，调用setupChild()方法，

setupChild():改方法主要是设置子view,所以看相关方法就行了。在第二个if处，判断逻辑有点复杂，没关系，一个个来看。  
(recycled&&!p.forceAdd) recycled是一个boolean值，取自mIsScrap\[0\]，初始化的时候为false，后面那个(!p.forceAdd)表示是否添加到布局中，这时应该是没有，所以(!p.forceAdd)==true.

后面一个判断，viewType是否==header or footer，不是，所以最后会执行else，addViewInLayout()，将子视图加到listView中，再结合之前提到的一个while循环，当加载满一个屏幕或者pos大于adapter中的item的数量时跳出。  
这就算加载好了一屏的数据了。

private void setupChild(View child, int position, int y, boolean flowDown, int childrenLeft,
            boolean selected, boolean recycled) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "setupListItem");
    
        final boolean isSelected = selected && shouldShowSelector();
        final boolean updateChildSelected = isSelected != child.isSelected();
        final int mode = mTouchMode;
        final boolean isPressed = mode > TOUCH_MODE_DOWN && mode < TOUCH_MODE_SCROLL &&
                mMotionPosition == position;
        final boolean updateChildPressed = isPressed != child.isPressed();
        final boolean needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested();
    
        // Respect layout params that are already in the view. Otherwise make some up...
        // noinspection unchecked
        AbsListView.LayoutParams p = (AbsListView.LayoutParams) child.getLayoutParams();
        if (p == null) {
            p = (AbsListView.LayoutParams) generateDefaultLayoutParams();
        }
        p.viewType = mAdapter.getItemViewType(position);
    
        if ((recycled && !p.forceAdd) || (p.recycledHeaderFooter
                && p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) {
            attachViewToParent(child, flowDown ? -1 : 0, p);
        } else {
            p.forceAdd = false;
            if (p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
                p.recycledHeaderFooter = true;
            }
            addViewInLayout(child, flowDown ? -1 : 0, p, true);
        }
    
        if (updateChildSelected) {
            child.setSelected(isSelected);
        }
    
        if (updateChildPressed) {
            child.setPressed(isPressed);
        }
    
        if (mChoiceMode != CHOICE_MODE_NONE && mCheckStates != null) {
            if (child instanceof Checkable) {
                ((Checkable) child).setChecked(mCheckStates.get(position));
            } else if (getContext().getApplicationInfo().targetSdkVersion
                    >= android.os.Build.VERSION_CODES.HONEYCOMB) {
                child.setActivated(mCheckStates.get(position));
            }
        }
    
        if (needToMeasure) {
            final int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,
                    mListPadding.left + mListPadding.right, p.width);
            final int lpHeight = p.height;
            final int childHeightSpec;
            if (lpHeight > 0) {
                childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
            } else {
                childHeightSpec = MeasureSpec.makeSafeMeasureSpec(getMeasuredHeight(),
                        MeasureSpec.UNSPECIFIED);
            }
            child.measure(childWidthSpec, childHeightSpec);
        } else {
            cleanupLayoutState(child);
        }
    
        final int w = child.getMeasuredWidth();
        final int h = child.getMeasuredHeight();
        final int childTop = flowDown ? y : y - h;
    
        if (needToMeasure) {
            final int childRight = childrenLeft + w;
            final int childBottom = childTop + h;
            child.layout(childrenLeft, childTop, childRight, childBottom);
        } else {
            child.offsetLeftAndRight(childrenLeft - child.getLeft());
            child.offsetTopAndBottom(childTop - child.getTop());
        }
    
        if (mCachingStarted && !child.isDrawingCacheEnabled()) {
            child.setDrawingCacheEnabled(true);
        }
    
        if (recycled && (((AbsListView.LayoutParams)child.getLayoutParams()).scrappedFromPosition)
                != position) {
            child.jumpDrawablesToCurrentState();
        }
    
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }

走完上述的流程，第一次的onLayout()就结束了。因为数据加载进来，导致父视图发生变化，所以会执行第二次的onLayout()

## 第二次onLayout() ##

第二次onLayout()流程和第一次的流程差不多

layoutChildren():这次childCount！=0，所以下面recycleBin.fillActiveViews()方法会对数据做缓存，接下来会调用detachAllViewsFromParent()方法，将所有的view从父视图中剥离(detach),为了不在第二次layout时，重复加载数据。下面的switch方法中，会进入else语句，并满足第二条if语句，mSelectedPosition在没有选中item的时候，默认应该为-1，mFirstPosition默认为0，所以会进入第二条if语句，执行fillSpecific()方法。

fillSpecific():在fillSpecific方法中，还是调用了makeAndAddView()方法，所以再次进入到makeAndAddView().

/**
     * Put a specific item at a specific location on the screen and then build up and down from there.
     */
    private View fillSpecific(int position, int top) {
        boolean tempIsSelected = position == mSelectedPosition;
        View temp = makeAndAddView(position, top, true, mListPadding.left, tempIsSelected);
        // Possibly changed again in fillUp if we add rows above this one.
        mFirstPosition = position;
    
        View above;
        View below;
    
        final int dividerHeight = mDividerHeight;
        if (!mStackFromBottom) {
            above = fillUp(position - 1, temp.getTop() - dividerHeight);
            // This will correct for the top of the first view not touching the top of the list
            adjustViewsUpOrDown();
            below = fillDown(position + 1, temp.getBottom() + dividerHeight);
            int childCount = getChildCount();
            if (childCount > 0) {
                correctTooHigh(childCount);
            }
        } else {
            below = fillDown(position + 1, temp.getBottom() + dividerHeight);
            // This will correct for the bottom of the last view not touching the bottom of the list
            adjustViewsUpOrDown();
            above = fillUp(position - 1, temp.getTop() - dividerHeight);
            int childCount = getChildCount();
            if (childCount > 0) {
                 correctTooLow(childCount);
            }
        }
    
        if (tempIsSelected) {
            return temp;
        } else if (above != null) {
            return above;
        } else {
            return below;
        }
    }

再次进入到makeAndAddView():这次直接能从RecycleBin.getActiveView()取得Item了，取得item之后，调用setupChild()方法，注意RecycleBin.getActiveView()方法在返回一个view的同时，会把数据里对应位置的数据删除，所以当listView布局完成之后，对应的mActiveList就会被清空，之后listView滑动的时候，起作用的主要是mScrapView数组。

setupChild()：同样省略部分代码，看第二个if语句，这个时候的recycled是从makeAndAddView()中传来的值，所以recycled==true，在加上第二次layout()的时候调用了detachAllViewsFromParent()方法，解绑了所有的子view，所以(!p.forceAdd)==true,然后执行下面的attachViewToParent()方法，将子view添加到父布局中。另外，当子view被回收的时候，也会触发detach()方法，解绑，节省资源。

private void setupChild(View child, int position, int y, boolean flowDown, int childrenLeft,
            boolean selected, boolean recycled) {
        ...
        if (p == null) {
            p = (AbsListView.LayoutParams) generateDefaultLayoutParams();
        }
        p.viewType = mAdapter.getItemViewType(position);
    
        if ((recycled && !p.forceAdd) || (p.recycledHeaderFooter
                && p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) {
            attachViewToParent(child, flowDown ? -1 : 0, p);
        } else {
            p.forceAdd = false;
            if (p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
                p.recycledHeaderFooter = true;
            }
            addViewInLayout(child, flowDown ? -1 : 0, p, true);
        }
    
      ...
    }

再回到fillSpecific()方法:将第一个item布局好之后，接下来会根据布局模式，从上往下，或者从下往上布局，来调用fillUp和fillDown，通过while循环，将其他的item布局到listView上，直至填满屏幕，或者遍历mAdapter的itemCount。

private View fillSpecific(int position, int top) {
        boolean tempIsSelected = position == mSelectedPosition;
        View temp = makeAndAddView(position, top, true, mListPadding.left, tempIsSelected);
        // Possibly changed again in fillUp if we add rows above this one.
        mFirstPosition = position;
    
        View above;
        View below;
    
        final int dividerHeight = mDividerHeight;
        if (!mStackFromBottom) {
            above = fillUp(position - 1, temp.getTop() - dividerHeight);
            // This will correct for the top of the first view not touching the top of the list
            adjustViewsUpOrDown();
            below = fillDown(position + 1, temp.getBottom() + dividerHeight);
            int childCount = getChildCount();
            if (childCount > 0) {
                correctTooHigh(childCount);
            }
        } else {
            below = fillDown(position + 1, temp.getBottom() + dividerHeight);
            // This will correct for the bottom of the last view not touching the bottom of the list
            adjustViewsUpOrDown();
            above = fillUp(position - 1, temp.getTop() - dividerHeight);
            int childCount = getChildCount();
            if (childCount > 0) {
                 correctTooLow(childCount);
            }
        }
    
        if (tempIsSelected) {
            return temp;
        } else if (above != null) {
            return above;
        } else {
            return below;
        }
    }

至此，第二个onLayout也结束，最后就是onDraw()的事情了。

总结一下:  
1.在第一次布局的时候调用我们写的getView()的逻辑代码来加载第一次的数据，  
2.因为需要二次布局的原因，将第一次加载的item放到一个临时数组mActiveViews中,用于在第二次makeAndAddView()时复用，  
3.通过while循环和makeAndAddView()填满可见屏幕  
4.接下来的listView中item的复用主要通过mScrapViews来解决。

> 下篇将会分析一下recycleView的实现原理。

参考博客:

[http://blog.csdn.net/chunqiuwei/article/details/48765007][http_blog.csdn.net_chunqiuwei_article_details_48765007]  
[http://blog.csdn.net/linghu\_java/article/details/39496921][http_blog.csdn.net_linghu_java_article_details_39496921]  
[http://blog.csdn.net/guolin\_blog/article/details/44996879][http_blog.csdn.net_guolin_blog_article_details_44996879]

本人也只是Android开发路上一只稍大一点的菜鸟，如果各位读者中发现文章中有误之处，请帮忙指出，你的批评和鼓励都是我前进的动力。

> 写在文末：如果读者朋友有什么问题或者意见可以在评论里指出.
> 
>   
>

[1240]: /images/20220609/923cb496090b4ea6817448f275f65794.png
[http_blog.csdn.net_chunqiuwei_article_details_48765007]: http://blog.csdn.net/chunqiuwei/article/details/48765007
[http_blog.csdn.net_linghu_java_article_details_39496921]: http://blog.csdn.net/linghu_java/article/details/39496921
[http_blog.csdn.net_guolin_blog_article_details_44996879]: http://blog.csdn.net/guolin_blog/article/details/44996879