如何将Firebase子节点名称转换为日期时间格式并用于排序？

Hey there! Let's tackle your two main needs: converting that raw node name to a human-readable date-time format, and sorting your Firebase data by date-time. Since you already have code to read the database, we'll build directly on that.

1. Convert Raw Node Name to dd/MM/yyyy HH:mm Format #

Your raw node name follows the pattern yyyyMMdd_HHmm (or sometimes with a 3-digit time like 100 for 10:00). Here's how to parse and format it in Android:

Using SimpleDateFormat (compatible with all Android versions) #

private String formatRawNodeToDateTime(String rawNodeName) {
    // Split the node name into date and time parts
    String[] nameParts = rawNodeName.split("_");
    if (nameParts.length != 2) return rawNodeName; // Fallback if format is invalid

    String dateSegment = nameParts[0]; // e.g., "20170108"
    String timeSegment = nameParts[1]; // e.g., "100"

    // Format date from yyyyMMdd to dd/MM/yyyy
    SimpleDateFormat dateInputFormat = new SimpleDateFormat("yyyyMMdd", Locale.getDefault());
    SimpleDateFormat dateOutputFormat = new SimpleDateFormat("dd/MM/yyyy", Locale.getDefault());
    Date parsedDate = null;
    try {
        parsedDate = dateInputFormat.parse(dateSegment);
    } catch (ParseException e) {
        e.printStackTrace();
        return rawNodeName;
    }
    String formattedDate = dateOutputFormat.format(parsedDate);

    // Handle time: pad 3-digit values to 4 digits (e.g., "100" → "1000")
    String paddedTime = String.format(Locale.getDefault(), "%4s", timeSegment).replace(' ', '0');
    // Format time from HHmm to HH:mm
    SimpleDateFormat timeInputFormat = new SimpleDateFormat("HHmm", Locale.getDefault());
    SimpleDateFormat timeOutputFormat = new SimpleDateFormat("HH:mm", Locale.getDefault());
    Date parsedTime = null;
    try {
        parsedTime = timeInputFormat.parse(paddedTime);
    } catch (ParseException e) {
        e.printStackTrace();
        return formattedDate; // Fallback to just date if time parsing fails
    }
    String formattedTime = timeOutputFormat.format(parsedTime);

    return formattedDate + " " + formattedTime;
}

Using Java 8+ DateTimeFormatter (API 26+ or with ThreeTenABP) #

If you're targeting newer Android versions or using the ThreeTenABP library for backport support, this is a cleaner approach:

private String formatRawNodeToDateTime(String rawNodeName) {
    String[] nameParts = rawNodeName.split("_");
    if (nameParts.length != 2) return rawNodeName;

    String dateSegment = nameParts[0];
    String timeSegment = nameParts[1];

    // Parse and format date
    DateTimeFormatter dateInputFormatter = DateTimeFormatter.ofPattern("yyyyMMdd", Locale.getDefault());
    LocalDate localDate = LocalDate.parse(dateSegment, dateInputFormatter);
    DateTimeFormatter dateOutputFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy", Locale.getDefault());
    String formattedDate = localDate.format(dateOutputFormatter);

    // Pad time and format
    String paddedTime = String.format(Locale.getDefault(), "%4s", timeSegment).replace(' ', '0');
    DateTimeFormatter timeInputFormatter = DateTimeFormatter.ofPattern("HHmm", Locale.getDefault());
    LocalTime localTime = LocalTime.parse(paddedTime, timeInputFormatter);
    DateTimeFormatter timeOutputFormatter = DateTimeFormatter.ofPattern("HH:mm", Locale.getDefault());
    String formattedTime = localTime.format(timeOutputFormatter);

    return formattedDate + " " + formattedTime;
}

2. Sort Firebase Data by Date-Time #

You have two reliable options here—database-level sorting (recommended for performance) or client-side sorting.

Option 1: Database-Level Sorting (Best for Large Datasets) #

Firebase Realtime Database can sort results directly, which is more efficient than sorting on the client.

If you're using the node name as the key

Your node name's format (yyyyMMdd_HHmm) is lexicographically sortable—meaning the string order matches the actual time order. So you can sort directly by the node key:

DatabaseReference yourDataRef = FirebaseDatabase.getInstance().getReference("your_data_path");
// Sort in ascending order (oldest to newest)
Query sortedQuery = yourDataRef.orderByKey();

// If you want newest to oldest, use limitToLast()
// Query sortedQuery = yourDataRef.orderByKey().limitToLast(50);

// Attach listener to the sorted query
sortedQuery.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        // Iterate through the sorted snapshots
        for (DataSnapshot childSnapshot : snapshot.getChildren()) {
            String rawNodeName = childSnapshot.getKey();
            String formattedDateTime = formatRawNodeToDateTime(rawNodeName);
            // Process your data and update RecyclerView
        }
    }

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

Add a Timestamp Field for More Reliability

For absolute accuracy (especially if your node name format might change), add a timestamp field (long integer) to each node. This stores the Unix timestamp in milliseconds, which is perfectly sortable:

your_data_path
  |--- 20170108_100
        |--- your_data: "sample content"
        |--- timestamp: 1483869600000 // Corresponding to 2017-01-08 10:00

Then sort by this field:

Query sortedQuery = yourDataRef.orderByChild("timestamp");
// For descending order: yourDataRef.orderByChild("timestamp").limitToLast(50);

Option 2: Client-Side Sorting #

If you can't modify the database or need to sort after fetching, sort your data list before updating the RecyclerView:

// Assume you have a list of your data models
List<YourDataModel> dataList = new ArrayList<>();

// After fetching all data into dataList, sort it
Collections.sort(dataList, (model1, model2) -> {
    // Parse both node names to Date objects for comparison
    Date date1 = parseRawNodeToDate(model1.getRawNodeName());
    Date date2 = parseRawNodeToDate(model2.getRawNodeName());
    return date1.compareTo(date2); // Ascending order; reverse for descending
});

// Update RecyclerView adapter with the sorted list
yourAdapter.setData(dataList);
yourAdapter.notifyDataSetChanged();

// Helper method to convert raw node name to Date
private Date parseRawNodeToDate(String rawNodeName) {
    String[] nameParts = rawNodeName.split("_");
    if (nameParts.length != 2) return new Date(0);

    String dateSegment = nameParts[0];
    String paddedTime = String.format(Locale.getDefault(), "%4s", nameParts[1]).replace(' ', '0');
    String fullDateTimeStr = dateSegment + paddedTime;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmm", Locale.getDefault());
    try {
        return sdf.parse(fullDateTimeStr);
    } catch (ParseException e) {
        e.printStackTrace();
        return new Date(0);
    }
}

Final Notes #

• Always handle parsing exceptions gracefully to avoid app crashes if a node name has an unexpected format.
• Database-level sorting is preferred for large datasets because it reduces the amount of data transferred and processed on the client.

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