如何根据消息的时间对聊天列表进行排序？

Question

我正在尝试根据最近的聊天（最新在顶部等）对我的users chat lists 进行排序。 我的chat fragment 看起来像这样：

这是来自chat fragment的sn-p：

 private UsersAdapter usersAdapter;
    private B_RecycleView recyclerView;
    private List<Chatlist> mChatUserList;
    private List<User> mUsers;
    private List<Chat> mChats = new ArrayList<>();
 View view = inflater.inflate(R.layout.fragment_chats, container, false);
       mEmptyView = view.findViewById(R.id.no_chats);
       recyclerView = view.findViewById(R.id.recycle_view);
       recyclerView.setHasFixedSize(true);
       recyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
       recyclerView.hideIfEmpty(recyclerView);
       recyclerView.showIfEmpty(mEmptyView);
       fUser = FirebaseAuth.getInstance().getCurrentUser();
       mChatUserList = new ArrayList<>();
       mUsers = new ArrayList<>();
       usersAdapter = new UsersAdapter(getContext(), mUsers , true);
       recyclerView.setAdapter(usersAdapter);
       reference = FirebaseDatabase.getInstance().getReference("Chatlist").child(fUser.getUid());
       reference.addValueEventListener(new ValueEventListener() {
           @Override
           public void onDataChange(@NonNull DataSnapshot snapshot) {
               mChatUserList.clear();
               for(DataSnapshot snapshot1 : snapshot.getChildren()){
                    Chatlist chatlist = snapshot1.getValue(Chatlist.class);
                   mChatUserList.add(chatlist);
                }
               chatList();
           }
           @Override
           public void onCancelled(@NonNull DatabaseError error){
           }
       });

聊天模型类：

public class Chat {
    private String sender;
    private String receiver;
    private String message;
    private String time;
    private String type;
    private boolean isseen;

    public Chat(String sender, String receiver, String message,String time, String type ,boolean isseen){
        this.sender = sender;
        this.receiver = receiver;
        this.message = message;
        this.time = time;
        this.type = type;
        this.isseen =isseen;
    }

我有这样的每条消息的时间戳：

我已经在我的 chatFragment 中尝试过这个：

  private void getChats() {
        reference = FirebaseDatabase.getInstance().getReference("Chats");
        reference.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                mChats.clear();
                if (!isAdded()) return;
                for (DataSnapshot snapshot1 : snapshot.getChildren()) {
                    Chat chat = snapshot1.getValue(Chat.class);
                    if(chat.getReceiver().equals(fUser.getUid()) || chat.getSender().equals(fUser.getUid())){
                        mChats.add(chat);
                    }
                }
                sortUsers();
            }

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

    private void sortUsers() {

    Collections.sort(mChats, new ChatTimeComparator());

    if(mChats.size() > 0 && mUsers.size() > 1){
        String lastUserRId = mChats.get(0).getReceiver();
        String lastUserSId = mChats.get(0).getSender();

        int i = 0, selId = 0;
        for(User user: mUsers){
            if(user.getId().equals(lastUserRId) || user.getId().equals(lastUserSId)){
                selId = i;
            }
            i++;
        }

        User user = mUsers.get(selId);
        List<User> tempUsers = new ArrayList<>();
        mUsers.remove(selId);
        tempUsers.addAll(mUsers);
        mUsers.clear();
        mUsers.add(0, user);
        mUsers.addAll(tempUsers);

        usersAdapter.notifyDataSetChanged();
    }
}

public class ChatTimeComparator implements Comparator<Chat>
{
    public int compare(Chat left, Chat right) {
        return right.getTime().compareTo(left.getTime());
    }
}

这仅对最近的聊天进行排序。其余的聊天是随机排序的。 如何对所有聊天进行排序？有什么帮助吗？请注意，我正在尝试对 chatlist 进行排序，而不是消息。

编辑： 根据聊天中发送的最后一条消息，我已经为每个聊天添加了时间，如下所示：

 private void lastMessage(final String userid, final TextView last_msg, final TextView timeSent){
        theLastMessage = "default";
        final FirebaseUser firebaseUser = FirebaseAuth.getInstance().getCurrentUser();
        DatabaseReference reference = FirebaseDatabase.getInstance().getReference("Chats");
        reference.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                 for(DataSnapshot snapshot1 : snapshot.getChildren()){
                     Chat chat = snapshot1.getValue(Chat.class);
                     if(chat.getReceiver().equals(firebaseUser.getUid()) && chat.getSender().equals(userid) ||
                             chat.getReceiver().equals(userid) && chat.getSender().equals(firebaseUser.getUid()))
                     {
                         long time = chat.getTime();

                         Calendar calendar = Calendar.getInstance(Locale.getDefault());
                         try {
                             calendar.setTimeInMillis(time);
                         }
                         catch (Exception ex){
                             ex.printStackTrace();
                         }
                         final String pTime = DateFormat.format("hh:mm aa", calendar).toString();
                         timeSent.setText(pTime);
                         if(chat.getType().equals("image")){
                             theLastMessage = "Sent a photo";
                         }
                         else
                         {
                             theLastMessage = chat.getMessage();
                         }
                     }

这是这个 sn-p 的结果：

如您所见，聊天是随机排序的。 那么，现在我可以根据该聊天中发送的最后一条消息的时间对聊天进行排序吗？

Answer 1

我建议不要在客户端重新排序聊天消息，而是让数据库来处理。

根据您当前的代码/数据，这需要进行以下更改：

1. 将时间戳存储为数字，而不是字符串。因此，在您的 Chat 类中更改为：private long time;，并在任何地方使用该号码。

2. 存储倒置的时间戳（也可以作为数字）。 Firebase 实时数据库只能按升序返回结果。您可以在应用程序代码中反转结果，也可以存储反转的时间戳以进行排序。所以invertedTimestamp = -1 * timestamp。

3. 使用查询以正确的顺序获取聊天消息：

    reference = FirebaseDatabase.getInstance().getReference("Chats");
    Query query = reference.orderByChild("invertedTimestamp");
    query.addListenerForSingleValueEvent(new ValueEventListener() {
        ...