Introduction

Updating RecyclerView data is not just about replacing a list in memory. The adapter must also be told what changed so the UI can redraw correctly and animate efficiently. In modern Android code, the cleanest solution is usually ListAdapter with DiffUtil, while manual notify... calls still work for simpler adapters.

The Old Manual Pattern

A plain adapter can expose a method that replaces its backing list and then notifies the view.

1class UserAdapter : RecyclerView.Adapter<UserViewHolder>() {
2    private val items = mutableListOf<String>()
3
4    fun updateData(newItems: List<String>) {
5        items.clear()
6        items.addAll(newItems)
7        notifyDataSetChanged()
8    }
9
10    override fun getItemCount(): Int = items.size
11
12    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
13        holder.bind(items[position])
14    }
15}

This works, but notifyDataSetChanged() refreshes the entire list. It throws away the chance to animate precise item insertions, removals, and moves.

Prefer ListAdapter And DiffUtil

For most apps, ListAdapter is a better default because it computes differences between the old list and the new list.

1data class User(val id: Long, val name: String)
2
3class UserAdapter : ListAdapter<User, UserViewHolder>(DIFF_CALLBACK) {
4    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
5        holder.bind(getItem(position))
6    }
7
8    companion object {
9        val DIFF_CALLBACK = object : DiffUtil.ItemCallback<User>() {
10            override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
11                return oldItem.id == newItem.id
12            }
13
14            override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
15                return oldItem == newItem
16            }
17        }
18    }
19}

Then updating the data is just:

adapter.submitList(newUsers)

That gives you granular updates without writing manual index math.

Why Immutable Lists Help

ListAdapter works best when each update submits a new list object rather than mutating the old list in place.

val updated = currentUsers + User(4, "Dana")
adapter.submitList(updated)

If you modify and resubmit the exact same list instance, DiffUtil may not detect the change correctly because the old and new references are effectively the same object graph.

Manual Item-Level Notifications

If you are managing updates yourself, use the more specific notification methods when possible.

1fun addUser(user: String) {
2    items.add(user)
3    notifyItemInserted(items.lastIndex)
4}
5
6fun removeUser(position: Int) {
7    items.removeAt(position)
8    notifyItemRemoved(position)
9}

These methods are better than notifyDataSetChanged() when the change is local and easy to describe.

Partial Row Updates

If only one field in a visible row changes, a targeted item update is often enough.

1fun renameUser(position: Int, newName: String) {
2    items[position] = newName
3    notifyItemChanged(position)
4}

This keeps the update narrow and reduces unnecessary work compared with refreshing the entire list. It is especially useful for status badges, selection state, or inline edits.

Keep Data Ownership Outside The Adapter

A healthy architecture usually keeps the source of truth in a ViewModel or another state holder, not inside the adapter. The adapter should render data, not own business state.

That pattern makes updates easier because the UI layer can observe a stream of lists and pass them directly into submitList.

Common Pitfalls

A common mistake is changing the data list without calling any adapter notification method. In that case, the UI still shows stale rows because RecyclerView has no reason to redraw.

Another mistake is using notifyDataSetChanged() for every tiny change. It works, but it is less efficient and gives worse animations than targeted notifications or DiffUtil.

It is also easy to mutate the same list instance when using ListAdapter. Submit a fresh list value so the diff can be computed correctly.

Summary

• The adapter must be notified when its displayed data changes.
• 'notifyDataSetChanged() works, but it refreshes the whole list.'
• 'ListAdapter with DiffUtil is the modern default for cleaner updates.'
• Submit new immutable list values when using ListAdapter.
• Keep business state outside the adapter and let the adapter focus on rendering.