??ItemAnimator作为RecyclerView的主要组成部分之一，其重要性自然不可言喻。由于ItemAnimator的存在，所以出现了很多精彩纷呈的动画，这使得RecyclerView更加惹人喜爱。因而，学习ItemAnimator的源码是势在必行的，由于我们理解原理之后，即可以自己设置动画了，不再受人约束。
??本文参考资料：

1. recyclerview-animators
2. RecyclerView 源码分析(四) - RecyclerView的动画机制

??本文打算才如下几个部分来分析ItemAnimator的源码：

1. ItemAnimator类相关方法的分析和总结。
2. SimpleItemAnimator相关代码的分析。
3. DefaultItemAnimator相关代码的分析。
4. 自己设置一个ItemAnimator。

1. 概述

??首先我们来对ItemAnimator的整个结构做一个简单的概述，方便大家了解。
??通常来说，自己设置一个ItemAnimator的过程是：ItemAnimator ->SimpleItemAnimator -> 自己设置ItemAnimator。包括官方提供的DefaultItemAnimator也是这样来定义的，那这样来定义有好处的呢？这样定义，结构层次比较清晰，我们自己设置ItemAnimator比较方便，只要要关注动画怎样实现就行。我们来看看这三层分别干了什么：

??而我们在自己设置ItemAnimator时，只要要考虑第三层就OK，上面两层的逻辑谷歌爸爸已经帮我们实现了。自己设置过ItemAnimator的同学应该都知道，虽然只关注第三层，但是实现还是那么麻烦，介于这个问题，我会提出一个非常简单的自己设置itemAnimator的方案。

2. ItemAnimator

??我们从上往下，看看每一层都为我们做了哪些事情，首先我们来理解一下ItemAnimator。ItemAnimator总的来说比较简单，我们来看看ItemAnimator几个方法：

??在ItemAnimator中，上面4个方法非常的重要，RecyclerView就是通过这四个方法来给每个ItemView增加不同的动画。在这一层，我们需要掌握的就是，记住这4个方法的调用时机，这样我们在看SimpleItemAnimator代码时，才不会不知所措。

3. SimpleItemAnimator

??就像在上面概述所说的一样，SimpleItemAnimator处于第二层，负责实现ItemAnimator的4个笼统方法，而后又提供了四种操作需要分别调用的笼统方法，这样做就更加细化了动画执行的情况，简化了自己设置ItemAnimator的过程。
??在正式看SimpleItemAnimator的源码之前，我们先来看看SimpleItemAnimator几个方法的详情。

??我们看到到了SimpleItemAnimator这一层，每个ItemView应该做什么动画，现在已经一清二楚了，不再像第一层里面那样，一个方法里面可能涉及到多种情况，每种情况可能执行不同的动画。
&esmp;?现在我们分别来看看SimpleItemAnimator对ItemAnimator的4个笼统方法的实现，看看他是怎样来判断一个ItemView执行何种动画的。
??首先，我们来看一下animateDisappearance方法：

    @Override    public boolean animateDisappearance(@NonNull ViewHolder viewHolder,            @NonNull ItemHolderInfo preLayoutInfo, @Nullable ItemHolderInfo postLayoutInfo) {        int oldLeft = preLayoutInfo.left;        int oldTop = preLayoutInfo.top;        View disappearingItemView = viewHolder.itemView;        int newLeft = postLayoutInfo == null ? disappearingItemView.getLeft() : postLayoutInfo.left;        int newTop = postLayoutInfo == null ? disappearingItemView.getTop() : postLayoutInfo.top;        if (!viewHolder.isRemoved() && (oldLeft != newLeft || oldTop != newTop)) {            disappearingItemView.layout(newLeft, newTop,                    newLeft + disappearingItemView.getWidth(),                    newTop + disappearingItemView.getHeight());            if (DEBUG) {                Log.d(TAG, "DISAPPEARING: " + viewHolder + " with view " + disappearingItemView);            }            return animateMove(viewHolder, oldLeft, oldTop, newLeft, newTop);        } else {            if (DEBUG) {                Log.d(TAG, "REMOVED: " + viewHolder + " with view " + disappearingItemView);            }            return animateRemove(viewHolder);        }    }

??animateDisappearance方法表达的意思非常简单，首先判断当前ItemView能否需要执行的是move动画，假如是，那么就调用animateMove方法；假如不是的话，那么就调用animateRemove方法用来执行remove动画。
??在这个方法里面，remove操作我们了解，但是move操作是什么意思呢？首先我们得搞清楚animateDisappearance方法的调用时机，animateDisappearance方法表示在ItemView从可见状态变为不可见状态，这里包括：remove操作和ItemView从可见区域移动到不可见区域。所以在animateDisappearance方法里面，执行move动画并不意外。
??而后，我们来看一下animateAppearance方法：

    @Override    public boolean animateAppearance(@NonNull ViewHolder viewHolder,            @Nullable ItemHolderInfo preLayoutInfo, @NonNull ItemHolderInfo postLayoutInfo) {        if (preLayoutInfo != null && (preLayoutInfo.left != postLayoutInfo.left                || preLayoutInfo.top != postLayoutInfo.top)) {            // slide items in if before/after locations differ            if (DEBUG) {                Log.d(TAG, "APPEARING: " + viewHolder + " with view " + viewHolder);            }            return animateMove(viewHolder, preLayoutInfo.left, preLayoutInfo.top,                    postLayoutInfo.left, postLayoutInfo.top);        } else {            if (DEBUG) {                Log.d(TAG, "ADDED: " + viewHolder + " with view " + viewHolder);            }            return animateAdd(viewHolder);        }    }

??animateAppearance方法表示在ItemView从不可见状态变为可见状态，所以这里包括add操作和move操作。move操作表示的意思跟animateDisappearance方法的差不多。
??而后，我们再来看看animatePersistence方法:

    public boolean animatePersistence(@NonNull ViewHolder viewHolder,            @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo) {        if (preInfo.left != postInfo.left || preInfo.top != postInfo.top) {            if (DEBUG) {                Log.d(TAG, "PERSISTENT: " + viewHolder                        + " with view " + viewHolder.itemView);            }            return animateMove(viewHolder,                    preInfo.left, preInfo.top, postInfo.left, postInfo.top);        }        dispatchMoveFinished(viewHolder);        return false;    }

??animatePersistence方法比其余方法都简单，这里只进行了move动画。当然假如不执行任何动画，这里会返回false，并且会调用dispatchMoveFinished方法，这是基本要求，当每个动画执行完毕之后，都是调用相关方法来通知动画执行结束了。
??最后，我们再来看看animateChange方法：

    @Override    public boolean animateChange(@NonNull ViewHolder oldHolder, @NonNull ViewHolder newHolder,            @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo) {        if (DEBUG) {            Log.d(TAG, "CHANGED: " + oldHolder + " with view " + oldHolder.itemView);        }        final int fromLeft = preInfo.left;        final int fromTop = preInfo.top;        final int toLeft, toTop;        if (newHolder.shouldIgnore()) {            toLeft = preInfo.left;            toTop = preInfo.top;        } else {            toLeft = postInfo.left;            toTop = postInfo.top;        }        return animateChange(oldHolder, newHolder, fromLeft, fromTop, toLeft, toTop);    }

??animateChange方法更加的简单，最后始终调用了animateChange笼统方法。

4. DefaultItemAnimator

??我们在看DefaultItemAnimator的源码之前，先来看看它有哪些成员变量：

    private static TimeInterpolator sDefaultInterpolator;    private ArrayList<ViewHolder> mPendingRemovals = new ArrayList<>();    private ArrayList<ViewHolder> mPendingAdditions = new ArrayList<>();    private ArrayList<MoveInfo> mPendingMoves = new ArrayList<>();    private ArrayList<ChangeInfo> mPendingChanges = new ArrayList<>();    ArrayList<ArrayList<ViewHolder>> mAdditionsList = new ArrayList<>();    ArrayList<ArrayList<MoveInfo>> mMovesList = new ArrayList<>();    ArrayList<ArrayList<ChangeInfo>> mChangesList = new ArrayList<>();    ArrayList<ViewHolder> mAddAnimations = new ArrayList<>();    ArrayList<ViewHolder> mMoveAnimations = new ArrayList<>();    ArrayList<ViewHolder> mRemoveAnimations = new ArrayList<>();    ArrayList<ViewHolder> mChangeAnimations = new ArrayList<>();

??在DefaultItemAnimator的内部，成员变量主要分为4个部分。这其中，sDefaultInterpolator就是给ItemView设置的一个动画插值器对象，在DefaultItemAnimator内部，这个插值器是AccelerateDecelerateInterpolator插值器；而后第二部分mPendingxxx数组，这部分就是用来存储每个ItemView需要做动画的相关信息，例如，move动画就需要移动的起始位置和终点位置，这部分的数组才是做动画的真正做动画需要的；第三部分和第四部分是mXXXList和mXXXAnimations，通常来说，都是用于结束动画的，本文后面会简单的分析他们。
??简单的理解这四部分的成员变量之后，现在我们重点看一下四个笼统方法的实现。

(1). animateRemove

    @Override    public boolean animateRemove(final ViewHolder holder) {        resetAnimation(holder);        mPendingRemovals.add(holder);        return true;    }

??animateRemove方法的实现非常简单，就是往mPendingRemovals数组里面增加一个元素。

(2). animateAdd

??而后，我们再来看一下animateAdd方法：

    @Override    public boolean animateAdd(final ViewHolder holder) {        resetAnimation(holder);        holder.itemView.setAlpha(0);        mPendingAdditions.add(holder);        return true;    }

??animateAdd方法的实现也是非常简单。这里我们看到有一个操作就是holder.itemView.setAlpha(0)，我们都知道，在DefaultItemAnimator中，add动画是一个渐现的过程，这里先将ItemView的alpha值设置0就容易了解了。

(3). animateMove

??而后，我们在来看一下animateMove方法的实现：

    @Override    public boolean animateMove(final ViewHolder holder, int fromX, int fromY,            int toX, int toY) {        final View view = holder.itemView;        fromX += (int) holder.itemView.getTranslationX();        fromY += (int) holder.itemView.getTranslationY();        resetAnimation(holder);        int deltaX = toX - fromX;        int deltaY = toY - fromY;        if (deltaX == 0 && deltaY == 0) {            dispatchMoveFinished(holder);            return false;        }        if (deltaX != 0) {            view.setTranslationX(-deltaX);        }        if (deltaY != 0) {            view.setTranslationY(-deltaY);        }        mPendingMoves.add(new MoveInfo(holder, fromX, fromY, toX, toY));        return true;    }

??相对来说，animateMove的实现比其余操作都要复杂少量，但是再怎样复杂，其实就做了两件事：

1. 根据情况，来设置View的translationX或者者translationY。
2. 向mPendingMoves数组里面增加一个MoveInfo,用于move动画使用。

(4). animateChange

??最后，我们在来看看animateChange方法的实现：

    public boolean animateChange(ViewHolder oldHolder, ViewHolder newHolder,            int fromX, int fromY, int toX, int toY) {        if (oldHolder == newHolder) {            // Don't know how to run change animations when the same view holder is re-used.            // run a move animation to handle position changes.            return animateMove(oldHolder, fromX, fromY, toX, toY);        }        final float prevTranslationX = oldHolder.itemView.getTranslationX();        final float prevTranslationY = oldHolder.itemView.getTranslationY();        final float prevAlpha = oldHolder.itemView.getAlpha();        resetAnimation(oldHolder);        int deltaX = (int) (toX - fromX - prevTranslationX);        int deltaY = (int) (toY - fromY - prevTranslationY);        // recover prev translation state after ending animation        oldHolder.itemView.setTranslationX(prevTranslationX);        oldHolder.itemView.setTranslationY(prevTranslationY);        oldHolder.itemView.setAlpha(prevAlpha);        if (newHolder != null) {            // carry over translation values            resetAnimation(newHolder);            newHolder.itemView.setTranslationX(-deltaX);            newHolder.itemView.setTranslationY(-deltaY);            newHolder.itemView.setAlpha(0);        }        mPendingChanges.add(new ChangeInfo(oldHolder, newHolder, fromX, fromY, toX, toY));        return true;    }

??而change操作比较特殊，哪里特殊呢？主要有两点：

1. 它涉及到从旧状态变成新状态，所以需要考虑两个ItemView的存在。
2. 在做change操作时，可能会做move操作。所以在这里还设置了ItemView的translation。

??这里只是简单的详情了ItemView可能同时进行change操作和move操作，待会在将动画实现时，我们来看一下DefaultItemAnimator是怎样实现两个动画同时进行的。

(5). runPendingAnimations

??我们往数组里面增加了很多需要做动画的元素，但是什么时候开始执行这些动画呢？其实我们在RecyclerView 源码分析(四) - RecyclerView的动画机制这篇文章里面已经分析了RecyclerView是怎样开始动画的。其实就是回调了ItemAnimator的一个方法--runPendingAnimations方法，之前我们增加的所有动画都在方法里面执行。我们在看runPendingAnimations方法之前，我们有几个问题，我们带着问题去看思路会更加的清晰，一共两个问题:

1. DefaultItemAnimator是怎样实现每种操作的动画呢？
2. 我们知道，在RecyclerView中，某些操作的动画是时序，比方说，必需在remove动画执行完毕之后，才会执行move动画，这个又是怎样实现呢？

??通过阅读runPendingAnimations方法的源码，我们可以将它的源码分为4个部分，分别如下：

1. remove动画的执行
2. move动画的执行
3. change动画的执行
4. add动画的执行

??我们分别来看看这四部分的代码。

A. remove动画的执行

        // First, remove stuff        for (ViewHolder holder : mPendingRemovals) {            animateRemoveImpl(holder);        }        mPendingRemovals.clear();

??通过上面的代码，我们知道，remove动画的实现关键在于animateRemoveImpl方法，我们来看看animateRemoveImpl方法的实现：

    private void animateRemoveImpl(final ViewHolder holder) {        final View view = holder.itemView;        final ViewPropertyAnimator animation = view.animate();        mRemoveAnimations.add(holder);        animation.setDuration(getRemoveDuration()).alpha(0).setListener(                new AnimatorListenerAdapter() {                    @Override                    public void onAnimationStart(Animator animator) {                        dispatchRemoveStarting(holder);                    }                    @Override                    public void onAnimationEnd(Animator animator) {                        animation.setListener(null);                        view.setAlpha(1);                        dispatchRemoveFinished(holder);                        mRemoveAnimations.remove(holder);                        dispatchFinishedWhenDone();                    }                }).start();    }

??在这里，我们知道，ItemView的remove动画是通过ViewPropertyAnimator来实现的。在这里我们需要注意几点：

1. 在动画开始之前，往mRemoveAnimations数组里面增加了一个元素，主要是用于结束动画的操作。当我们在结束动画时，发现mRemoveAnimations数组里面还有元素，表示还有remove动画没有执行完毕，所以结束它。
2. 在onAnimationEnd方法里面，我们分别调用了dispatchRemoveFinished方法和dispatchFinishedWhenDone。这两步操作是必需的，而且注意他们的时序。

??至于ViewPropertyAnimator实现动画为什么需要这样来说，这不是本文的重点，这里就不详情了，大家有兴趣可以去简单学习一下。

B. move动画

        if (movesPending) {            final ArrayList<MoveInfo> moves = new ArrayList<>();            moves.addAll(mPendingMoves);            mMovesList.add(moves);            mPendingMoves.clear();            Runnable mover = new Runnable() {                @Override                public void run() {                    for (MoveInfo moveInfo : moves) {                        animateMoveImpl(moveInfo.holder, moveInfo.fromX, moveInfo.fromY,                                moveInfo.toX, moveInfo.toY);                    }                    moves.clear();                    mMovesList.remove(moves);                }            };            if (removalsPending) {                View view = moves.get(0).holder.itemView;                ViewCompat.postOnAnimationDelayed(view, mover, getRemoveDuration());            } else {                mover.run();            }        }

??这部分的代码相对来说要复杂一点点，我们来简单的分析一下。上面的代码，我们需要注意如如下几点:

1. 将move动画相关的动画元素原封不动的增加到mMovesList数组里面。这样做的目的是，由于move动画的开始有推迟，得等待remove动画执行完毕之后才执行。所以，存在我们在结束动画时，move动画还没有开始执行的情况，所以得先增加进去，以便结束move动画。
2. 从这里我们即可以知道，DefaultItemAnimator是怎样处理动画的时序问题。这里通过ViewCompat的postOnAnimationDelayed来做一个推迟执行，保证rmove动画执行完毕才执行move动画。

??而后，我们在来看看animateMoveImpl方法是怎样实现move动画的：

    void animateMoveImpl(final ViewHolder holder, int fromX, int fromY, int toX, int toY) {        final View view = holder.itemView;        final int deltaX = toX - fromX;        final int deltaY = toY - fromY;        if (deltaX != 0) {            view.animate().translationX(0);        }        if (deltaY != 0) {            view.animate().translationY(0);        }        // TODO: make EndActions end listeners instead, since end actions aren't called when        // vpas are canceled (and can't end them. why?)        // need listener functionality in VPACompat for this. Ick.        final ViewPropertyAnimator animation = view.animate();        mMoveAnimations.add(holder);        animation.setDuration(getMoveDuration()).setListener(new AnimatorListenerAdapter() {            @Override            public void onAnimationStart(Animator animator) {                dispatchMoveStarting(holder);            }            @Override            public void onAnimationCancel(Animator animator) {                if (deltaX != 0) {                    view.setTranslationX(0);                }                if (deltaY != 0) {                    view.setTranslationY(0);                }            }            @Override            public void onAnimationEnd(Animator animator) {                animation.setListener(null);                dispatchMoveFinished(holder);                mMoveAnimations.remove(holder);                dispatchFinishedWhenDone();            }        }).start();    }

??animateMoveImpl方法实现move动画其实跟remove的实现差不多，都是通过ViewPropertyAnimator来实现的，所以这里就不再分析了。

C. change动画

??而后我们再来看看change动画的实现：

       if (changesPending) {            final ArrayList<ChangeInfo> changes = new ArrayList<>();            changes.addAll(mPendingChanges);            mChangesList.add(changes);            mPendingChanges.clear();            Runnable changer = new Runnable() {                @Override                public void run() {                    for (ChangeInfo change : changes) {                        animateChangeImpl(change);                    }                    changes.clear();                    mChangesList.remove(changes);                }            };            if (removalsPending) {                ViewHolder holder = changes.get(0).oldHolder;                ViewCompat.postOnAnimationDelayed(holder.itemView, changer, getRemoveDuration());            } else {                changer.run();            }        }

??上面的代码跟move动画那部分的实现都差不多，这里就不再分析了，我们这里重点是看animateChangeImpl方法：

    void animateChangeImpl(final ChangeInfo changeInfo) {        final ViewHolder holder = changeInfo.oldHolder;        final View view = holder == null ? null : holder.itemView;        final ViewHolder newHolder = changeInfo.newHolder;        final View newView = newHolder != null ? newHolder.itemView : null;        if (view != null) {            final ViewPropertyAnimator oldViewAnim = view.animate().setDuration(                    getChangeDuration());            mChangeAnimations.add(changeInfo.oldHolder);            oldViewAnim.translationX(changeInfo.toX - changeInfo.fromX);            oldViewAnim.translationY(changeInfo.toY - changeInfo.fromY);            oldViewAnim.alpha(0).setListener(new AnimatorListenerAdapter() {                @Override                public void onAnimationStart(Animator animator) {                    dispatchChangeStarting(changeInfo.oldHolder, true);                }                @Override                public void onAnimationEnd(Animator animator) {                    oldViewAnim.setListener(null);                    view.setAlpha(1);                    view.setTranslationX(0);                    view.setTranslationY(0);                    dispatchChangeFinished(changeInfo.oldHolder, true);                    mChangeAnimations.remove(changeInfo.oldHolder);                    dispatchFinishedWhenDone();                }            }).start();        }        if (newView != null) {            final ViewPropertyAnimator newViewAnimation = newView.animate();            mChangeAnimations.add(changeInfo.newHolder);            newViewAnimation.translationX(0).translationY(0).setDuration(getChangeDuration())                    .alpha(1).setListener(new AnimatorListenerAdapter() {                        @Override                        public void onAnimationStart(Animator animator) {                            dispatchChangeStarting(changeInfo.newHolder, false);                        }                        @Override                        public void onAnimationEnd(Animator animator) {                            newViewAnimation.setListener(null);                            newView.setAlpha(1);                            newView.setTranslationX(0);                            newView.setTranslationY(0);                            dispatchChangeFinished(changeInfo.newHolder, false);                            mChangeAnimations.remove(changeInfo.newHolder);                            dispatchFinishedWhenDone();                        }                    }).start();        }    }

??change跟其余比较起来，实现起来就复杂的多。我们来简单的分析一下：

1. 在animateChangeImpl方法里面，主要是有两个动画在执行，一个是旧的ItemView渐隐动画，一个是新的ItemView渐现动画。
2. 在change动画里面，同时包含了两部分属性的动画，一个是位置的渐变，一个是透明度的渐变。从这里，我们即可以看到，一个在做change动画的ItemView也有可能做move动画。所以，在runPendingAnimations方法里面，4个步骤独立执行，一个ViewHolder不可能同时走了其中两个或者者两个以上的步骤。

D. add动画

??这里add动画没有特殊的操作，就是简单的渐现，我们就不做多余的详情了。

5. 自己设置ItemAnimator

??大家想要自定以一个ItemAnimator，第一个想法就是先去网上搜索一下自定以ItemAnimator的基本步骤。我相信大家搜索到的都是一开始就叫我们实现很多很多的方法，又不知道这些的作用，有些可能还简单详情了一下每个方法的作用，但是根本不知道这个方法的具体实现。为什么需要这么来实现动画呢？这些都是网上大多数文章没有详情清楚的。
??这里，我提出一种自己设置ItemAnimator的处理方案，有可能是目前最简单的方案。
??通常上面的源码的学习，我们理解了DefaultItemAnimator的实现原理。所以，我们自己设置一个ItemAnimator，可以参考DefaultItemAnimator的实现。从而，我们自己设置一个ItemAnimator,需要处理如下几个问题：

1. 需要考虑动画执行的时序。
2. 需要考虑结束动画。
3. 实现每种动画的实现逻辑。

??从上面的问题中，我们发现问题1和问题2,DefaultItemAnimator已经帮我们实现了，我们只要要处理问题3就行了。所以，我的处理方案就是：将DefaultItemAnimator的拷贝出来，我们只要要改写animateRemoveImpl、animateAddImpl、animateMoveImpl和animateChangeImpl这四个方法就行了。通常来说，change动画和move动画，我们都不会改写，所以重点在于add动画和remove动画。
??现在，我来给大家看一下我自己设置的一个动画，效果如下：

    private void animateRemoveImpl(final ViewHolder holder) {        final View view = holder.itemView;        final ViewPropertyAnimator animation = view.animate();        mRemoveAnimations.add(holder);        animation.setDuration(getRemoveDuration()).translationX(view.getRootView().getWidth()).setListener(new AnimatorListenerAdapter() {            @Override            public void onAnimationStart(Animator animator) {                dispatchRemoveStarting(holder);            }            @Override            public void onAnimationEnd(Animator animator) {                animation.setListener(null);                view.setTranslationX(0);                dispatchRemoveFinished(holder);                mRemoveAnimations.remove(holder);                dispatchFinishedWhenDone();            }        }).start();    }    void animateAddImpl(final ViewHolder holder) {        final View view = holder.itemView;        final ViewPropertyAnimator animation = view.animate();        mAddAnimations.add(holder);        animation.translationX(0).setDuration(getAddDuration())                .setListener(new AnimatorListenerAdapter() {                    @Override                    public void onAnimationStart(Animator animator) {                        dispatchAddStarting(holder);                    }                    @Override                    public void onAnimationCancel(Animator animator) {                        view.setAlpha(0);                    }                    @Override                    public void onAnimationEnd(Animator animator) {                        animation.setListener(null);                        dispatchAddFinished(holder);                        mAddAnimations.remove(holder);                        dispatchFinishedWhenDone();                    }                }).start();    }

??实现的逻辑也是非常简单，就是将DefaultItemAnimator的alpha变化改为了translationX的变化。如上所示，自己设置一个ItemAnimator就是这么简单！
??假如还有不懂的同学，可以去我的github去下载Demo：ItemAnimatorDemo。

6. 总结

??关于ItemAnimator的源码分析到此就已经结束了，我在这里做一个简单的总结。

1. 了解ItemAnimator的原理之前，我们最好先理解它的三层模型，分别是ItemAnimator、SimpleItemAnimator和DefaultItemAnimator，我们需要搞清楚每一层究竟为我们做了哪些事情。
2. 自己设置ItemAnimator我们只要要拷贝DefaultItemAnimator的代码，而后根据自己的要求分别改写animateRemoveImpl、animateAddImpl、animateMoveImpl和animateChangeImpl这四个方法就行了。

??到此为止，RecyclerView源码分析系列的文章就结束了。通过这系列的文章中，我们全方位立体的理解了RecyclerView的各个方面，使得我们对RecyclerView的了解更上一层楼了。当然这个过程中一定有地方缺少了，就比方说：ItemTouchHelper或者者ItemDecoration，这部分的内容相对来说简单一点，后续我会推出一个RecyclerView的拓展系列，来补充这部分的内容。
??人非圣贤，孰能无过！各位大佬在阅读过程中假如发现错误或者者有疑惑，都可以提出来，欢迎大佬们斧正！