public class MyDiffCallback extends DiffUtil.ItemCallback<MyDataModel> {
    @Override
    public boolean areItemsTheSame(@NonNull MyDataModel oldItem, @NonNull MyDataModel newItem) {
        return oldItem.getId() == newItem.getId();
    }

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

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.MyViewHolder> {
    private List<MyDataModel> dataList = new ArrayList<>();

    // ... 其他方法

    public void updateDataList(List<MyDataModel> newDataList) {
        DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new MyDiffCallback(dataList, newDataList));
        dataList.clear();
        dataList.addAll(newDataList);
        diffResult.dispatchUpdatesTo(this);
    }

    // ... 其他方法
}

public class MyDiffUtilCallback extends DiffUtil.Callback {

    private List<MyItem> oldList;
    private List<MyItem> newList;

    public MyDiffUtilCallback(List<MyItem> oldList, List<MyItem> newList) {
        this.oldList = oldList;
        this.newList = newList;
    }

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

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

    @Override
    public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
        return oldList.get(oldItemPosition).getId() == newList.get(newItemPosition).getId();
    }

    @Override
    public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
        MyItem oldItem = oldList.get(oldItemPosition);
        MyItem newItem = newList.get(newItemPosition);
        return oldItem.equals(newItem);
    }

    @Nullable
    @Override
    public Object getChangePayload(int oldItemPosition, int newItemPosition) {
        // 如果areContentsTheSame返回false，則可以在這里返回具體的變化內(nèi)容，以便進(jìn)行局部刷新
        return super.getChangePayload(oldItemPosition, newItemPosition);
    }
}

public class DiffUtil {
    //部分代碼省略
    @NonNull
    public static DiffResult calculateDiff(@NonNull Callback cb, boolean detectMoves) {
        final int oldSize = cb.getOldListSize();
        final int newSize = cb.getNewListSize();

        final List<Snake> snakes = new ArrayList<>();

        // instead of a recursive implementation, we keep our own stack to avoid potential stack
        // overflow exceptions
        final List<Range> stack = new ArrayList<>();

        stack.add(new Range(0, oldSize, 0, newSize));

        final int max = oldSize + newSize + Math.abs(oldSize - newSize);
        // allocate forward and backward k-lines. K lines are diagonal lines in the matrix. (see the
        // paper for details)
        // These arrays lines keep the max reachable position for each k-line.
        final int[] forward = new int[max * 2];
        final int[] backward = new int[max * 2];

        // We pool the ranges to avoid allocations for each recursive call.
        final List<Range> rangePool = new ArrayList<>();
        while (!stack.isEmpty()) {
            final Range range = stack.remove(stack.size() - 1);
            final Snake snake = diffPartial(cb, range.oldListStart, range.oldListEnd,
                    range.newListStart, range.newListEnd, forward, backward, max);
            if (snake != null) {
                if (snake.size > 0) {
                    snakes.add(snake);
                }
                // offset the snake to convert its coordinates from the Range's area to global
                //使路徑點(diǎn)的偏移以將其坐標(biāo)從范圍區(qū)域轉(zhuǎn)換為全局
                snake.x += range.oldListStart;
                snake.y += range.newListStart;
                //拆分左上角和右下角進(jìn)行遞歸
                // add new ranges for left and right
                final Range left = rangePool.isEmpty() ? new Range() : rangePool.remove(
                        rangePool.size() - 1);
                //起點(diǎn)為上一次的起點(diǎn)
                left.oldListStart = range.oldListStart;
                left.newListStart = range.newListStart;
                //如果是逆向得到的中間路徑，那么左上角的終點(diǎn)為該中間路徑的起點(diǎn)
                if (snake.reverse) {
                    left.oldListEnd = snake.x;
                    left.newListEnd = snake.y;
                } else {
                    if (snake.removal) {//中間路徑是向右操作，那么終點(diǎn)的x需要退一
                        left.oldListEnd = snake.x - 1;
                        left.newListEnd = snake.y;
                    } else {//中間路徑是向下操作，那么終點(diǎn)的y需要退一
                        left.oldListEnd = snake.x;
                        left.newListEnd = snake.y - 1;
                    }
                }
                stack.add(left);
                // re-use range for right
                //noinspection UnnecessaryLocalVariable
                final Range right = range;//右下角終點(diǎn)和之前的終點(diǎn)相同
                if (snake.reverse) {
                    if (snake.removal) {//中間路徑是向右操作，那么起點(diǎn)的x需要進(jìn)一
                        right.oldListStart = snake.x + snake.size + 1;
                        right.newListStart = snake.y + snake.size;
                    } else {//中間路徑是向下操作，那么起點(diǎn)的y需要進(jìn)一
                        right.oldListStart = snake.x + snake.size;
                        right.newListStart = snake.y + snake.size + 1;
                    }
                } else {//如果是逆向得到的中間路徑，那么右下角的起點(diǎn)為該中間路徑的終點(diǎn)
                    right.oldListStart = snake.x + snake.size;
                    right.newListStart = snake.y + snake.size;
                }
                stack.add(right);
            } else {
                rangePool.add(range);
            }

        }
        // sort snakes
        Collections.sort(snakes, SNAKE_COMPARATOR);

        return new DiffResult(cb, snakes, forward, backward, detectMoves);

    }
    //diffPartial方法主要是來尋找一條snake，它的核心也就是Myers算法。
    private static Snake diffPartial(Callback cb, int startOld, int endOld,
            int startNew, int endNew, int[] forward, int[] backward, int kOffset) {
        final int oldSize = endOld - startOld;
        final int newSize = endNew - startNew;
        if (endOld - startOld < 1 || endNew - startNew < 1) {
            return null;
        }
        //差異增量
        final int delta = oldSize - newSize;
        //最雙向最長路徑
        final int dLimit = (oldSize + newSize + 1) / 2;
        //進(jìn)行初始化設(shè)置
        Arrays.fill(forward, kOffset - dLimit - 1, kOffset + dLimit + 1, 0);
        Arrays.fill(backward, kOffset - dLimit - 1 + delta, kOffset + dLimit + 1 + delta, oldSize);
        /**
         * 差異量為奇數(shù)
         * 每個(gè)差異-水平刪除或垂直插入-都是從一千行移到其相鄰行。
         * 由于增量是正向和反向算法中心之間的差異，因此我們知道需要檢查中間snack的d值。
         * 對于奇數(shù)增量，我們必須尋找差異為d的前向路徑與差異為d-1的反向路徑重疊。
         * 類似地，對于偶數(shù)增量，重疊將是當(dāng)正向和反向路徑具有相同數(shù)量的差異時(shí)
         */
        final boolean checkInFwd = delta % 2 != 0;
        for (int d = 0; d <= dLimit; d++) {
            /**
             * 這一循環(huán)是從(0,0)出發(fā)找到移動d步能達(dá)到的最遠(yuǎn)點(diǎn)
             * 引理：d和k同奇同偶，所以每次k都遞增2
             */
            for (int k = -d; k <= d; k += 2) {
                // find forward path
                // we can reach k from k - 1 or k + 1. Check which one is further in the graph
                //找到前進(jìn)路徑
                //我們可以從k-1或k + 1到達(dá)k。檢查圖中的哪個(gè)更遠(yuǎn) 
                int x;
                final boolean removal;//向下
                //bool down = ( k == -d || ( k != d && V[ k - 1 ] < V[ k + 1 ] ) );
                if (k == -d || (k != d && forward[kOffset + k - 1] < forward[kOffset + k + 1])) {
                    x = forward[kOffset + k + 1];
                    removal = false;
                } else {
                    x = forward[kOffset + k - 1] + 1;
                    removal = true;
                }
                // set y based on x
                //k = x - y
                int y = x - k;
                // move diagonal as long as items match
                //只要item匹配就移動對角線
                while (x < oldSize && y < newSize
                        && cb.areItemsTheSame(startOld + x, startNew + y)) {
                    x++;
                    y++;
                }
                forward[kOffset + k] = x;
                //如果delta為奇數(shù)，那么相連通的節(jié)點(diǎn)一定是向前移動的節(jié)點(diǎn)，也就是執(zhí)行forward操作所觸發(fā)的節(jié)點(diǎn)
                //if delta is odd and ( k >= delta - ( d - 1 ) and k <= delta + ( d - 1 ) )
                if (checkInFwd && k >= delta - d + 1 && k <= delta + d - 1) {
                    //if overlap with reverse[ d - 1 ] on line k
                    //forward'x >= backward'x，如果在k線上正向查找能到到的位置的x坐標(biāo)比反向查找達(dá)到的y坐標(biāo)小
                
                    if (forward[kOffset + k] >= backward[kOffset + k]) {
                        Snake outSnake = new Snake();
                        outSnake.x = backward[kOffset + k];
                        outSnake.y = outSnake.x - k;
                        outSnake.size = forward[kOffset + k] - backward[kOffset + k];
                        outSnake.removal = removal;
                        outSnake.reverse = false;
                        return outSnake;
                    }
                }
            }
            /**
             * 這一循環(huán)是從(m,n)出發(fā)找到移動d步能達(dá)到的最遠(yuǎn)點(diǎn)
             */
            for (int k = -d; k <= d; k += 2) {
                // find reverse path at k + delta, in reverse
                //以k + delta,找到反向路徑。backwardK相當(dāng)于反向轉(zhuǎn)化之后的正向的k
                final int backwardK = k + delta;
                int x;
                final boolean removal;
                //與k線類似
                //bool down = ( k == -d || ( k != d && V[ k - 1 ] < V[ k + 1 ] ) );
                if (backwardK == d + delta || (backwardK != -d + delta 
                        && backward[kOffset + backwardK - 1] < backward[kOffset + backwardK + 1])) {
                    x = backward[kOffset + backwardK - 1];
                    removal = false;
                } else {
                    x = backward[kOffset + backwardK + 1] - 1;
                    removal = true;
                }
                // set y based on x
                int y = x - backwardK;
                // move diagonal as long as items match
                //只要item匹配就移動對角線
                while (x > 0 && y > 0
                        && cb.areItemsTheSame(startOld + x - 1, startNew + y - 1)) {
                    x--;
                    y--;
                }
                backward[kOffset + backwardK] = x;
                //如果delta為偶數(shù)，那么相連通的節(jié)點(diǎn)一定是反向移動的節(jié)點(diǎn)，也就是執(zhí)行backward操作所觸發(fā)的節(jié)點(diǎn)
                //if delta is even and ( k >= -d - delta and k <= d - delta )
                if (!checkInFwd && k + delta >= -d && k + delta <= d) {
                    //if overlap with forward[ d ] on line k
                    //forward'x >= backward'x，判斷正向反向是否連通了
                    if (forward[kOffset + backwardK] >= backward[kOffset + backwardK]) {
                        Snake outSnake = new Snake();
                        outSnake.x = backward[kOffset + backwardK];
                        outSnake.y = outSnake.x - backwardK;
                        outSnake.size =
                                forward[kOffset + backwardK] - backward[kOffset + backwardK];
                        outSnake.removal = removal;
                        outSnake.reverse = true;
                        return outSnake;
                    }
                }
            }
        }
        throw new IllegalStateException("DiffUtil hit an unexpected case while trying to calculate"
                + " the optimal path. Please make sure your data is not changing during the"
                + " diff calculation.");
    }
    //部分代碼省略
}