如何按日期升序从List<Student>集合中获取元素？

Got it, let's figure out how to sort your Student list by date from earliest to latest. First, let's formalize the Student class definition (based on the constructor you provided, this will make the examples clearer):

class Student {
    private String name;
    private String dateStr;

    public Student(String name, String dateStr) {
        this.name = name;
        this.dateStr = dateStr;
    }

    // Getters are required to access the date field for sorting
    public String getName() {
        return name;
    }

    public String getDateStr() {
        return dateStr;
    }

    // Optional: Override toString to make output readable
    @Override
    public String toString() {
        return "Student{name='" + name + "', date='" + dateStr + "'}";
    }
}

Approach 1: Traditional In-Place Sort (Java 7 and Earlier) #

Since your date strings use the yyyy-MM-dd format, we can compare them directly lexicographically—this works because the format aligns perfectly with chronological order (year first, then month, then day).

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class DateSortExample {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("abc","2019-02-01"));
        list.add(new Student("bcd","2019-02-01"));
        list.add(new Student("cdf","2019-02-01"));
        list.add(new Student("fgh","2019-02-01"));
        list.add(new Student("abc","2019-02-02"));
        list.add(new Student("bcd","2019-02-02"));
        list.add(new Student("cdf","2019-02-02"));
        list.add(new Student("fgh","2019-02-02"));

        // Sort the original list in-place by date (earliest first)
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return s1.getDateStr().compareTo(s2.getDateStr());
            }
        });

        // Print the sorted results
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

Approach 2: Java 8+ Stream API (Cleaner, Non-Destructive) #

If you're using Java 8 or later, the Stream API lets you create a new sorted list without modifying the original, which is often cleaner:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamSortExample {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        // Initialize your Student list here...

        // Create a new sorted list (original list stays unchanged)
        List<Student> sortedList = list.stream()
                .sorted((s1, s2) -> s1.getDateStr().compareTo(s2.getDateStr()))
                .collect(Collectors.toList());

        // Print the sorted results
        sortedList.forEach(System.out::println);
    }
}

Approach 3: Robust Date Parsing (For Variable/Non-Standard Formats) #

If your date format might change (or isn't yyyy-MM-dd), parsing the string into a LocalDate object is the safest way to guarantee correct chronological sorting:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class RobustDateSortExample {
    // Reusable formatter matching your date pattern
    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        // Initialize your Student list here...

        // Sort by converting date strings to LocalDate objects
        list.sort(Comparator.comparing(student -> LocalDate.parse(student.getDateStr(), DATE_FORMATTER)));

        // Print the sorted results
        list.forEach(System.out::println);
    }
}

Quick Notes: #

• Direct string comparison only works for yyyy-MM-dd format. For formats like MM/dd/yyyy, this would fail—stick with the LocalDate approach in those cases.
• The list.sort() method modifies the original list, while the Stream approach creates a new one. Choose based on whether you need to preserve the original list's order.

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