RecyclerView消息重复填充/被替换问题求助（Firebase聊天应用）

看起来你遇到的核心问题出在适配器的消息添加逻辑和Firebase数据监听的处理方式上，咱们一步步来修复：

问题根源分析 #

1. Adapter的致命错误：你的addMessageSent方法每次都会调用dataSet.clear()，这意味着每次添加新消息时，之前所有的历史消息都会被清空，最后数据集里永远只有最新的一条消息——这就是为什么接收新消息时旧消息会被替换，或者用clear后历史消息消失的原因。
2. Firebase监听的冗余处理：你分别监听了发送和接收两个节点，而且每次数据变化时都会循环调用addMessageSent，等于每次数据更新都要清空N次数据集，最后只剩最后一条消息。
3. 消息类型判断逻辑混乱：你在构造Messages对象时固定了类型，但其实应该根据消息的发送者是否是当前用户来动态判断类型。

第一步：修复MessageAdapter #

我们需要重写适配器的消息添加逻辑，去掉不必要的clear，同时保留清空整个列表的方法（只在初始化时用）：

public class MessageAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    public static final int MSG_TYPE_LEFT = 0;
    public static final int MSG_TYPE_RIGHT = 1;
    FirebaseUser firebaseUser;
    private Context ctx;
    private ArrayList<Messages> dataSet;

    public MessageAdapter(Context context) {
        this.ctx = context;
        this.dataSet = new ArrayList<>();
        firebaseUser = FirebaseAuth.getInstance().getCurrentUser();
    }

    // 新增：清空整个数据集的方法，只在需要初始化时调用
    public void clearAllMessages() {
        dataSet.clear();
        notifyDataSetChanged();
    }

    // 正确的添加单条消息方法：不清空，直接添加并通知更新
    public void addMessage(Messages messages){
        dataSet.add(messages);
        // 通知RecyclerView插入了最后一条数据，比notifyDataSetChanged更高效
        notifyItemInserted(dataSet.size() - 1);
    }

    // 批量添加消息（适合Firebase一次性获取所有历史消息）
    public void addAllMessages(List<Messages> messagesList){
        dataSet.addAll(messagesList);
        notifyDataSetChanged();
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        if (viewType == MSG_TYPE_RIGHT) { // 自己发送的消息，显示在右边
            View view = LayoutInflater.from(ctx).inflate(R.layout.message_item_right, parent, false);
            return new ViewHolderS(view);
        } else { // 接收的消息，显示在左边
            View view = LayoutInflater.from(ctx).inflate(R.layout.message_item_left, parent, false);
            return new ViewHolderR(view);
        }
    }

    @Override
    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
        Messages object = dataSet.get(position);
        if (object != null) {
            if (holder instanceof ViewHolderS) {
                ((ViewHolderS) holder).populate(object);
            } else if (holder instanceof ViewHolderR) {
                ((ViewHolderR) holder).populate(object);
            }
        }
    }

    @Override
    public int getItemCount() {
        return dataSet.size();
    }

    @Override
    public int getItemViewType(int position) {
        Messages message = dataSet.get(position);
        // 根据发送者是否是当前用户，判断消息显示在左边还是右边
        return message.getSender().equals(firebaseUser.getUid()) ? MSG_TYPE_RIGHT : MSG_TYPE_LEFT;
    }

    // 发送消息的ViewHolder
    public static class ViewHolderS extends RecyclerView.ViewHolder {
        public TextView msg, time;
        public LinearLayout layout;

        public ViewHolderS(@NonNull View itemView) {
            super(itemView);
            layout = itemView.findViewById(R.id.cont);
            msg = itemView.findViewById(R.id.send_msg);
            time = itemView.findViewById(R.id.time);
        }

        private void populate(Messages messages) {
            msg.setText(messages.getMessage());
            // 这里可以保留你的布局参数设置，或者直接在xml里配置，更简洁
            time.setText(messages.getTime());
        }
    }

    // 接收消息的ViewHolder
    private class ViewHolderR extends RecyclerView.ViewHolder {
        public TextView msg, time;
        public LinearLayout layout;

        public ViewHolderR(@NonNull View itemView) {
            super(itemView);
            layout = itemView.findViewById(R.id.cont);
            msg = itemView.findViewById(R.id.send_msg);
            time = itemView.findViewById(R.id.time);
        }

        private void populate(Messages messages) {
            msg.setText(messages.getMessage());
            time.setText(messages.getTime());
        }
    }
}

第二步：修复Firebase数据监听逻辑 #

我们需要统一获取所有聊天消息（发送+接收），合并后按时间排序，然后一次性交给适配器，避免重复清空和添加：

// 初始化RecyclerView的代码保持不变，调整适配器初始化
recyclerView.setHasFixedSize(true);
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(getApplicationContext());
linearLayoutManager.setStackFromEnd(true);
recyclerView.setLayoutManager(linearLayoutManager);
messageAdapter = new MessageAdapter(PersonChatActivity.this);
recyclerView.setAdapter(messageAdapter);
recyclerView.setItemAnimator(new DefaultItemAnimator());

// 获取所有聊天消息（发送+接收）
private void loadAllChatMessages() {
    DatabaseReference chatsRef = FirebaseDatabase.getInstance().getReference("Chats");
    chatsRef.keepSynced(true);

    // 同时监听两个节点：我发送给对方的，对方发送给我的
    ListenerRegistration sentListener = chatsRef.child(senderId).child(receiver).addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            mergeChatMessages();
        }

        @Override
        public void onCancelled(@NonNull DatabaseError error) {}
    });

    ListenerRegistration receivedListener = chatsRef.child(receiver).child(senderId).addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            mergeChatMessages();
        }

        @Override
        public void onCancelled(@NonNull DatabaseError error) {}
    });

    // 记得在Activity销毁时移除监听，避免内存泄漏
    // getLifecycle().addObserver(new LifecycleObserver() { ... });
}

// 合并发送和接收的消息，按时间排序后更新适配器
private void mergeChatMessages() {
    DatabaseReference chatsRef = FirebaseDatabase.getInstance().getReference("Chats");
    ArrayList<Messages> allMessages = new ArrayList<>();

    // 获取我发送的消息
    chatsRef.child(senderId).child(receiver).get().addOnCompleteListener(task -> {
        if (task.isSuccessful()) {
            DataSnapshot snapshot = task.getResult();
            for (DataSnapshot ds : snapshot.getChildren()) {
                Messages msg = ds.getValue(Messages.class);
                if (msg != null) {
                    allMessages.add(msg);
                }
            }

            // 获取对方发送的消息
            chatsRef.child(receiver).child(senderId).get().addOnCompleteListener(task2 -> {
                if (task2.isSuccessful()) {
                    DataSnapshot snapshot2 = task2.getResult();
                    for (DataSnapshot ds : snapshot2.getChildren()) {
                        Messages msg = ds.getValue(Messages.class);
                        if (msg != null) {
                            allMessages.add(msg);
                        }
                    }

                    // 按时间排序，保证消息顺序正确
                    allMessages.sort((msg1, msg2) -> Long.compare(msg1.getTimeAsLong(), msg2.getTimeAsLong()));

                    // 更新适配器：先清空旧数据，再添加所有新数据
                    messageAdapter.clearAllMessages();
                    messageAdapter.addAllMessages(allMessages);

                    // 滚动到最新消息
                    recyclerView.smoothScrollToPosition(messageAdapter.getItemCount() - 1);
                }
            });
        }
    });
}

第三步：修复Messages数据模型 #

增加一个获取原始时间戳的方法，方便排序：

public class Messages {
    private String message;
    public static final int SENT_TYPE=0;
    public static final int RECEIVED_TYPE=1;
    public static final int AUDIO_TYPE=2;
    private long time;
    private String id; // senderId
    private String receiver;

    // 构造方法、getter/setter保持不变

    // 新增：获取原始时间戳，用于排序
    public long getTimeAsLong() {
        return time;
    }

    // 原有的getTime()方法保持不变，用于显示
    public String getTime() {
        SimpleDateFormat output = new SimpleDateFormat("HH:mm", Locale.getDefault());
        return output.format(new Date(time));
    }
}

关键注意点 #

1. 不要在循环里调用addMessage：Firebase的onDataChange会返回当前节点的所有数据，所以我们应该一次性收集所有消息，排序后批量添加到适配器，而不是循环添加（否则会频繁刷新RecyclerView）。
2. 移除不必要的push()调用：push()是用来生成新的节点ID添加数据的，在监听数据时完全不需要，只会浪费资源。
3. 处理消息顺序：一定要按时间戳排序，否则消息会乱序显示。
4. 移除监听避免内存泄漏：在Activity销毁时，要移除Firebase的ValueEventListener，防止内存泄漏。

内容的提问来源于stack exchange，提问作者Patrick Kariuki