Обновляем RecyclerView через DiffUtil

Обновляем RecyclerView через DiffUtilот ручного Callback до ListAdapter и LazyColumn

notifyDataSetChanged перерисовывает весь список и ломает анимации. Показываем, как DiffUtil считает точную разницу и почему ListAdapter делает это удобнее.

Раздел
Android
Стек
KotlinRecyclerViewDiffUtilCompose
Уровень
Средний
Опубликовано
Обновлено
Чтение
9 мин
Коротко
  • notifyDataSetChanged перепривязывает всё и убивает анимации.
  • areItemsTheSame сравнивает id, areContentsTheSame содержимое.
  • ListAdapter считает разницу в фоне и хранит список сам.
  • В Compose ту же роль играет key в LazyColumn.
Как решаем
  1. Сделайте модель неизменяемым data class с id
  2. Опишите DiffUtil.ItemCallback по id и содержимому
  3. Унаследуйте адаптер от ListAdapter
  4. Передавайте в submitList всегда новый список
  5. Для частичных обновлений верните payload

Почему notifyDataSetChanged больше не устраивает#

Самый короткий способ обновить RecyclerView после загрузки свежих данных: заменить список в адаптере и вызвать notifyDataSetChanged(). Работает, но дорого и некрасиво. Адаптер сообщает списку только то, что «изменилось всё», поэтому RecyclerView перепривязывает каждый видимый элемент, теряет анимации вставки и удаления, а пользователь видит мигание, если в строках есть картинки.

Точные методы notifyItemInserted, notifyItemRemoved, notifyItemMoved и notifyItemChanged решают проблему, но только если вы знаете, что именно поменялось. Когда новый список приходит с сервера целиком, вычислять это руками утомительно и легко ошибиться: одна неверная позиция, и приложение падает с IndexOutOfBoundsException внутри RecyclerView. Именно эту работу берёт на себя DiffUtil.

Как устроен DiffUtil#

DiffUtil сравнивает два списка и выдаёт минимальный набор операций, который превращает старый в новый. В основе лежит алгоритм Майерса, тот же, что в классическом diff для текстовых файлов. Вам остаётся объяснить ему, как сравнивать элементы. Для этого есть два вопроса, и путать их нельзя:

  • areItemsTheSame: это одна и та же сущность? Обычно сравнивают идентификаторы из базы или с сервера. Если вернуть здесь equals, любое изменение имени превратится в удаление и вставку, и анимация будет не та.
  • areContentsTheSame: изменилось ли то, что видно на экране? Вызывается только для пар, у которых первый метод вернул true. Если false, элемент будет перепривязан.
  • getChangePayload: необязательный метод. Возвращает подсказку, что именно поменялось, чтобы перерисовать часть строки, а не всю.

Порядок работы такой: посчитали разницу, обновили данные в адаптере, вызвали dispatchUpdatesTo(adapter). Результат сам разошлёт нужные notifyItem*. Если поменять местами второй и третий шаг, адаптер на мгновение отдаст списку старые данные с новыми позициями.

Вариант середины 2010-х: свой Callback#

Когда DiffUtil появился в support library, его подключали примерно так. Код рабочий и сегодня, если проект до сих пор на Java:

Java
// 2016: Java, DiffUtil вручную
class UserDiff extends DiffUtil.Callback {
    private final List<User> oldList, newList;

    UserDiff(List<User> oldList, List<User> 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 o, int n) {
        return oldList.get(o).getId() == newList.get(n).getId();
    }

    @Override public boolean areContentsTheSame(int o, int n) {
        return oldList.get(o).equals(newList.get(n));
    }
}

// в адаптере
public void setUsers(List<User> fresh) {
    DiffUtil.DiffResult result =
            DiffUtil.calculateDiff(new UserDiff(users, fresh));
    users = new ArrayList<>(fresh);
    result.dispatchUpdatesTo(this);
}

Главная проблема этого варианта не в многословности. calculateDiff выполняется в том потоке, где его вызвали, то есть обычно в главном. На списке из нескольких сотен элементов это незаметно, на нескольких тысячах с тяжёлым equals уже даёт пропущенные кадры. Документация прямо советует считать разницу в фоне, а применять результат в главном потоке. Раньше для этого городили AsyncTask или Handler и следили, чтобы два параллельных расчёта не применились в неправильном порядке.

Если DiffUtil по каким-то причинам недоступен, можно хотя бы включить setHasStableIds(true) и переопределить getItemId. Тогда даже после notifyDataSetChanged() список понимает, какие строки остались прежними, и сохраняет их представления. Это смягчает мигание, но анимаций не даёт.

ListAdapter: фоновый расчёт без лишнего кода#

Позже в библиотеку добавили AsyncListDiffer и обёртку над ним ListAdapter. Они считают разницу в фоновом потоке, отбрасывают устаревшие расчёты, если новый список пришёл раньше, чем закончился предыдущий, и хранят текущий список сами. Вместо DiffUtil.Callback с индексами описывается DiffUtil.ItemCallback, который сравнивает два объекта. На Kotlin это выглядит так:

Kotlin
data class User(val id: Long, val name: String, val online: Boolean)

object UserDiff : DiffUtil.ItemCallback<User>() {
    override fun areItemsTheSame(old: User, new: User) = old.id == new.id
    override fun areContentsTheSame(old: User, new: User) = old == new
    override fun getChangePayload(old: User, new: User): Any? =
        if (old.copy(online = new.online) == new) PAYLOAD_ONLINE else null
}

const val PAYLOAD_ONLINE = "online"

class UserAdapter : ListAdapter<User, UserHolder>(UserDiff) {
    override fun onCreateViewHolder(parent: ViewGroup, type: Int) =
        UserHolder(ItemUserBinding.inflate(LayoutInflater.from(parent.context), parent, false))

    override fun onBindViewHolder(holder: UserHolder, position: Int) =
        holder.bind(getItem(position))

    override fun onBindViewHolder(holder: UserHolder, position: Int, payloads: List<Any>) {
        if (PAYLOAD_ONLINE in payloads) holder.bindOnline(getItem(position))
        else super.onBindViewHolder(holder, position, payloads)
    }
}

// во фрагменте
viewLifecycleOwner.lifecycleScope.launch {
    viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.users.collect { adapter.submitList(it) }
    }
}

Обратите внимание на перегрузку onBindViewHolder с payloads. Если поменялся только статус «в сети», строка обновит одну иконку, а аватар и имя не будут перерисованы. Вызов super в ветке по умолчанию передаёт управление в обычную привязку. Привязку представлений мы делаем через View Binding; как раньше искали дочерние элементы руками, мы показывали в заметке про поиск View по классу.

Типичные ошибки#

Почти все жалобы «submitList не работает» сводятся к одной из этих причин:

СимптомПричинаЧто делать
Список не обновилсяПередан тот же экземпляр, что уже внутри адаптераКаждый раз создавать новый список
Элементы мигают при каждом обновленииareItemsTheSame сравнивает объекты целикомСравнивать только идентификаторы
Строка не перерисовалась после правкиОбъект изменён на месте, старый и новый указывают на одно и то жеНеизменяемые data class и copy()
Список прокрутился не туда после вставкиРасчёт асинхронный, прокрутка вызвана раньшеПрокручивать в колбэке submitList(list) { … }

Первая ошибка самая частая. AsyncListDiffer сравнивает новый список со старым по ссылке и, если это один объект, ничего не делает:

Kotlin
// ошибка: тот же экземпляр списка, ListAdapter ничего не сделает
list.add(user)
adapter.submitList(list)

// правильно: каждый раз новый неизменяемый список
adapter.submitList(adapter.currentList + user)

Та же причина стоит за третьей строкой таблицы: если изменить поле у объекта, который уже лежит в старом списке, сравнивать будет нечего, обе стороны покажут новое значение.

Сколько это стоит и когда DiffUtil лишний#

Расчёт разницы не бесплатен. Время работы алгоритма Майерса растёт с размером списков и с числом изменений между ними, а при включённом поиске перемещений добавляется ещё один проход. Поэтому полезно понимать, когда он окупается, а когда проще обойтись без него:

  • Список целиком заменяется другим, например при переключении вкладки или нового поискового запроса. Общих элементов почти нет, анимация удаления сотни строк никому не нужна. Здесь честнее показать новый список без анимаций или сбросить адаптер.
  • Вы сами знаете, что изменилось: пользователь удалил одну строку свайпом. Один вызов notifyItemRemoved дешевле любого сравнения, хотя и с ListAdapter разница будет незаметна.
  • Обычный случай: периодическое обновление с сервера, где поменялись статусы, добавилась пара элементов сверху. Для этого DiffUtil и создан.

Если перемещения элементов вам не важны, их поиск можно отключить вторым аргументом calculateDiff(callback, false); тогда перестановка будет показана как удаление и вставка, зато расчёт быстрее. Тяжёлые сравнения в areContentsTheSame тоже стоит упростить: сгенерированный equals у data class сравнивает все поля, и если среди них большой вложенный список, сравнение каждый раз пройдёт и по нему.

Что изменилось к 2026 году#

Для экранов на View стандартом стал ListAdapter с DiffUtil.ItemCallback, а данные приходят из Flow во ViewModel. Ручной DiffUtil.Callback остался для особых случаев, например когда нужно сравнить два массива в тесте или посчитать разницу без адаптера. Для бесконечных лент есть Paging 3: его PagingDataAdapter принимает тот же ItemCallback, так что код сравнения переносится без изменений.

Удобнее всего эта схема работает в связке с Room: запрос, возвращающий Flow<List<User>>, присылает новый неизменяемый список после каждого изменения таблицы, а ListAdapter сам решает, какие строки обновить. Ручных вызовов notifyItem* в таком коде нет совсем, а значит, нет и падений из-за неверной позиции. Если же данные собираются из нескольких источников, объединяйте их во ViewModel оператором combine и отдавайте адаптеру готовый результат, а не правьте список в нескольких местах.

Новые экраны всё чаще пишут на Jetpack Compose, и там вопроса «как уведомить адаптер» нет вовсе. LazyColumn сама сравнивает состояние, а роль стабильных идентификаторов играет параметр key:

Kotlin
LazyColumn {
    items(users, key = { it.id }) { user ->
        UserRow(user, modifier = Modifier.animateItem())
    }
}

Без key состояние строки привязано к позиции, и после вставки сверху раскрытая карточка «переедет» на соседний элемент. Правило то же, что у areItemsTheSame: ключ должен быть стабильным и уникальным. Модификатор animateItem() в свежих версиях Compose заменил прежний animateItemPlacement(), проверьте, какой доступен в вашей версии библиотеки.

Другие рецепты по платформе собраны в разделе Android; например, в заметке о размерах изображения из ресурсов разобрано, как не тормозить список тяжёлыми картинками, а для видео в ленте пригодится разбор ExoPlayer и media3.

3метода ItemCallback, один необязательный
Майерсалгоритм поиска разницы в DiffUtil
keyаналог стабильных id в LazyColumn

«DiffUtil отвечает на два вопроса: тот же ли это элемент и изменился ли он. Путать их нельзя.»

Главный вывод заметки

Вопросы и ответы

Вопросы и ответы

Нужно ли вызывать calculateDiff в фоновом потоке?
Для больших списков да: расчёт идёт в том потоке, где его вызвали, и в главном может давать пропущенные кадры. ListAdapter и AsyncListDiffer уже считают разницу в фоне и применяют результат в главном потоке, поэтому с ними об этом думать не нужно.
Почему submitList не обновляет список?
Чаще всего в адаптер передан тот же экземпляр списка, который уже внутри. AsyncListDiffer сравнивает списки по ссылке и пропускает такой вызов. Создавайте новый список, например через оператор плюс или toList, а модели держите неизменяемыми.
Чем отличается areItemsTheSame от areContentsTheSame?
Первый метод отвечает, одна ли это сущность, и обычно сравнивает идентификаторы. Второй вызывается только для совпавших сущностей и проверяет, изменилось ли видимое содержимое. Если в первом сравнивать объекты целиком, правки превращаются в удаление и вставку.
Нужен ли DiffUtil в Jetpack Compose?
Нет. LazyColumn сама следит за изменениями состояния. Вместо стабильных идентификаторов передайте параметр key в items, иначе состояние строк будет привязано к позициям и после вставки сместится на соседние элементы.
Заметка обновлена 12 ноября 2026: код проверен на актуальных версиях, добавлены современные варианты.

Читайте также