LiveData中单个列表项增删的常见实践及实现方案咨询

嘿，关于LiveData里单个列表项的增删操作，我有几个实用的实践方法，能帮你避免每次全量刷新列表，提升性能和用户体验：

方法一：结合ObservableList自动通知变化 #

这是最省心的方式，利用Android自带的ObservableArrayList（它实现了ObservableList接口，内部会自动监听元素增删并通知适配器）：

1. 先把LiveData的泛型改成ObservableArrayList<Animal>：

private MutableLiveData<ObservableArrayList<Animal>> animalListLiveData = new MutableLiveData<>();

// 初始化时给一个空的ObservableArrayList
animalListLiveData.setValue(new ObservableArrayList<>());

2. 观察LiveData的时候，首次加载直接把这个列表传给适配器，之后就不用再重新设置适配器了：

animalListLiveData.observe(this, animalList -> {
    if (listView.getAdapter() == null) {
        ArrayAdapter<Animal> adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, animalList);
        listView.setAdapter(adapter);
    }
});

3. 当需要增删单个项时，直接操作LiveData里的ObservableArrayList，适配器会自动感知并刷新对应位置：

// 插入单个项
animalListLiveData.getValue().add(newAnimal);
// 在指定位置插入
animalListLiveData.getValue().add(position, newAnimal);
// 删除单个项
animalListLiveData.getValue().remove(animalToDelete);
// 删除指定位置的项
animalListLiveData.getValue().remove(position);

这种方式不用手动调用适配器的刷新方法，代码简洁，而且只会刷新变化的项，不会全量刷新列表。

方法二：用DiffUtil计算差异实现局部更新 #

如果更倾向于使用不可变的List（避免并发修改问题），可以用DiffUtil来对比新旧列表的差异，然后只刷新变化的部分。这种方式更适合RecyclerView（也可以适配ListView）：

1. 保持原有的LiveData<List<Animal>>，但每次更新都生成新的不可变列表：

private MutableLiveData<List<Animal>> animalListLiveData = new MutableLiveData<>();

// 插入单个项的示例
List<Animal> currentList = animalListLiveData.getValue();
if (currentList != null) {
    List<Animal> newList = new ArrayList<>(currentList);
    newList.add(position, newAnimal); 
    animalListLiveData.setValue(newList);
}

// 删除单个项的示例
List<Animal> currentList = animalListLiveData.getValue();
if (currentList != null) {
    List<Animal> newList = new ArrayList<>(currentList);
    newList.remove(position); 
    animalListLiveData.setValue(newList);
}

2. 在观察者中，用DiffUtil计算新旧列表的差异，然后通知适配器局部刷新：

animalListLiveData.observe(this, newAnimalList -> {
    ArrayAdapter<Animal> adapter = (ArrayAdapter<Animal>) listView.getAdapter();
    if (adapter == null) {
        adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, newAnimalList);
        listView.setAdapter(adapter);
    } else {
        // 计算新旧列表的差异
        DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffUtil.Callback() {
            @Override
            public int getOldListSize() {
                return adapter.getCount();
            }

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

            @Override
            public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
                // 根据Animal的唯一标识判断是否是同一个项，比如id
                Animal oldAnimal = adapter.getItem(oldItemPosition);
                Animal newAnimal = newAnimalList.get(newItemPosition);
                return oldAnimal.getId() == newAnimal.getId();
            }

            @Override
            public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
                // 判断项的内容是否相同，比如equals方法
                Animal oldAnimal = adapter.getItem(oldItemPosition);
                Animal newAnimal = newAnimalList.get(newItemPosition);
                return oldAnimal.equals(newAnimal);
            }
        });

        // 更新适配器的数据并刷新差异部分
        adapter.clear();
        adapter.addAll(newAnimalList);
        diffResult.dispatchUpdatesTo(adapter);
    }
});

这种方式的好处是保证了数据的不可变性，避免并发问题，同时能精准地刷新变化的项，适合数据比较复杂的场景。

方法三：自定义事件类传递单个更新操作 #

如果想更灵活地控制每个增删操作，可以定义一个专门的事件类，让LiveData传递具体的操作类型和数据，观察者根据事件直接操作适配器：

1. 先定义一个事件类：

public sealed class ListUpdateEvent {
    public static class InsertEvent extends ListUpdateEvent {
        public final int position;
        public final Animal animal;

        public InsertEvent(int position, Animal animal) {
            this.position = position;
            this.animal = animal;
        }
    }

    public static class DeleteEvent extends ListUpdateEvent {
        public final int position;

        public DeleteEvent(int position) {
            this.position = position;
        }
    }
}

2. 把LiveData的泛型改成这个事件类：

private MutableLiveData<ListUpdateEvent> listUpdateEventLiveData = new MutableLiveData<>();

3. 同时维护一个本地列表，用于适配器的数据来源：

private List<Animal> animalList = new ArrayList<>();

4. 发送增删事件：

// 发送插入事件
listUpdateEventLiveData.setValue(new ListUpdateEvent.InsertEvent(position, newAnimal));
// 发送删除事件
listUpdateEventLiveData.setValue(new ListUpdateEvent.DeleteEvent(position));

5. 观察事件并操作适配器：

listUpdateEventLiveData.observe(this, event -> {
    ArrayAdapter<Animal> adapter = (ArrayAdapter<Animal>) listView.getAdapter();
    if (adapter == null) {
        adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, animalList);
        listView.setAdapter(adapter);
    }

    if (event instanceof ListUpdateEvent.InsertEvent) {
        ListUpdateEvent.InsertEvent insertEvent = (ListUpdateEvent.InsertEvent) event;
        animalList.add(insertEvent.position, insertEvent.animal);
        adapter.notifyDataSetChanged(); // 若使用RecyclerView适配器可替换为notifyItemInserted
    } else if (event instanceof ListUpdateEvent.DeleteEvent) {
        ListUpdateEvent.DeleteEvent deleteEvent = (ListUpdateEvent.DeleteEvent) event;
        animalList.remove(deleteEvent.position);
        adapter.notifyDataSetChanged(); // 若使用RecyclerView适配器可替换为notifyItemRemoved
    }
});

这种方式灵活性最高，适合需要对增删操作做额外逻辑处理的场景，比如插入时添加动画、删除时提示确认等。

给你的小提醒 #

你当前的做法如果每次都重新创建适配器或者调用notifyDataSetChanged，会导致整个列表重新渲染，不仅性能差，还会丢失当前的滚动位置，用户体验不好。上面的几种方法都能避免这个问题，根据你的场景选最合适的就行~

内容的提问来源于stack exchange，提问作者Cheok Yan Cheng