按 LocalDate 降序和 LocalTime 升序对列表进行排序

Question

我有一个包含LocalDateTime字段的对象列表。
我想按日期和时间对所有这些对象进行特别排序。

我解释了应该如何做：

按日期降序排序，但按时间升序排序

这是一个例子：

未排序LocalDateTime：

• 2016-10-06T09:10
• 2016-10-06T10:34
• 2016-12-06T11:15
• 2016-11-06T10:34
• 2016-12-06T10:10
• 2016-12-06T06:56

应按以下顺序排序：

1. 2016-12-06T06:56
2. 2016-12-06T10:10
3. 2016-12-06T11:15
4. 2016-11-06T10:34
5. 2016-10-06T09:10
6. 2016-10-06T10:34

请记住，我需要对带有字段的对象进行排序，而不是对 的列表进行排序LocalDateTime，而是对带有LocalDateTime字段的对象列表进行排序。

感谢你们对我的帮助 ：）

Answer 1

LocalDateTime对象知道如何按时间顺序对自己进行排序。您希望按日期降序排序（逆时间顺序，较晚的日期在前）但也按时间升序（按时间顺序）排序，这意味着类的compareTo方法实现的内置功能（Comparable接口要求）不能做这份工作。

常规语法

对于自定义排序，请编写您自己的Comparator实现。该接口需要实现一种方法：compare.

这里的逻辑很简单：

• 比较日期部分。
  • 如果两个日期不同，则在此基础上进行反向排序，然后在列表中向下移动。
  • 如果两者的日期相同，则更深入地比较它们的时间部分，按时间顺序排序。

代码。

package work.basil.example;

import java.time.LocalDateTime;
import java.util.Comparator;

public class LocalDateTimeComparator implements Comparator < LocalDateTime >
{
    @Override
    public int compare ( LocalDateTime o1 , LocalDateTime o2 )
    {
        // Compare the date portion first. If equal, then look at time-of-day.
        int result = o1.toLocalDate().compareTo( o2.toLocalDate() ); // Consider only the date portion first.
        result = ( ( - 1 ) * result ); // Flip the positive/negative sign of the int, to get ascending order. Or more simply: `= - result ;`.
        if ( 0 == result ) // If dates are equal, look at the time-of-day.
        {
            System.out.println( "reversing " );
            result = o1.toLocalTime().compareTo( o2.toLocalTime() );
        }
        return result;
    }
}

使用此比较器试用您的示例数据。

List < LocalDateTime > ldts = List.of(
        LocalDateTime.parse( "2016-10-06T09:10" ) ,
        LocalDateTime.parse( "2016-10-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T11:15" ) ,
        LocalDateTime.parse( "2016-11-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T10:10" ) ,
        LocalDateTime.parse( "2016-12-06T06:56" )
);

List < LocalDateTime > sorted = new ArrayList <>( ldts );
Comparator < LocalDateTime > comparator = new LocalDateTimeComparator();
sorted.sort(  comparator );

转储到控制台。我们看到成功。日期按 2016 年 10 月、11 月和 12 月的顺序排列，而一天中的时间

System.out.println( "ldts = " + ldts );
System.out.println( "sorted = " + sorted );

ldts = [2016-10-06T09:10, 2016-10-06T10:34, 2016-12-06T11:15, 2016-11-06T10:34, 2016-12-06T10:16-16T10:16-16-20:16-20:15 ]

排序 = [2016-12-06T06:56, 2016-12-06T10:10, 2016-12-06T11:15, 2016-11-06T10:34, 2016-10-06T09:10, 010-3016T ]

Lambda 语法

Ole VV的评论展示了如何在现代 Java 中使用函数式 lambda 语法来完成等效的工作。那条评论激励我尝试函数式方法。

这里的想法是使用两个Comparator对象：一个用于日期，一个用于一天中的时间。Comparator实际上，我们可以通过调用将一个嵌套在另一个中Comparator::thenComparing。所以我们需要建立两个比较器，然后将一个提供给另一个。我们实例化 a comparatorDate，然后喂那个 a comparatorTime，得到 a comparatorDateThenTime。我们传递comparatorDateThenTime给sort方法来实际执行排序工作。

List < LocalDateTime > ldts = List.of(
        LocalDateTime.parse( "2016-10-06T09:10" ) ,
        LocalDateTime.parse( "2016-10-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T11:15" ) ,
        LocalDateTime.parse( "2016-11-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T10:10" ) ,
        LocalDateTime.parse( "2016-12-06T06:56" )
);

List < LocalDateTime > sorted = new ArrayList <>( ldts );

Comparator < LocalDateTime > comparatorDate =
        Comparator
                .comparing( ( LocalDateTime ldt ) -> ldt.toLocalDate() )
                .reversed();

Comparator < LocalDateTime > comparatorTime =
        Comparator
                .comparing( ( LocalDateTime ldt ) -> ldt.toLocalTime() );

Comparator < LocalDateTime > comparatorDateThenTime =
        comparatorDate
                .thenComparing(
                        comparatorTime
                );

sorted.sort( comparatorDateThenTime );

// Dump to console.
System.out.println( "ldts = " + ldts );
System.out.println( "sorted = " + sorted );

ldts = [2016-10-06T09:10, 2016-10-06T10:34, 2016-12-06T11:15, 2016-11-06T10:34, 2016-12-06T10:16-16T10:16-16-20:16-20:15 ]

排序 = [2016-12-06T06:56, 2016-12-06T10:10, 2016-12-06T11:15, 2016-11-06T10:34, 2016-10-06T09:10, 010-3016T ]

我们可以使用Comparator从调用Comparator.comparing和返回的匿名对象使用单行代码将所有这些组合在一起Comparator.reversed。

List < LocalDateTime > ldts = List.of(
        LocalDateTime.parse( "2016-10-06T09:10" ) ,
        LocalDateTime.parse( "2016-10-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T11:15" ) ,
        LocalDateTime.parse( "2016-11-06T10:34" ) ,
        LocalDateTime.parse( "2016-12-06T10:10" ) ,
        LocalDateTime.parse( "2016-12-06T06:56" )
);

List < LocalDateTime > sorted = new ArrayList <>( ldts );

sorted.sort(
        Comparator
                .comparing( ( LocalDateTime ldt ) -> ldt.toLocalDate() )
                .reversed()
                .thenComparing(
                        Comparator
                                .comparing( ( LocalDateTime ldt ) -> ldt.toLocalTime() )
                )

);

// Dump to console.
System.out.println( "ldts = " + ldts );
System.out.println( "sorted = " + sorted );

ldts = [2016-10-06T09:10, 2016-10-06T10:34, 2016-12-06T11:15, 2016-11-06T10:34, 2016-12-06T10:16-16T10:16-16-20:16-20:15 ]

排序 = [2016-12-06T06:56, 2016-12-06T10:10, 2016-12-06T11:15, 2016-11-06T10:34, 2016-10-06T09:10, 010-3016T ]

我想我更愿意在生产代码中看到第一个，多行的。但我不确定。

问题中陈述的真正问题涉及 aLocalDateTime作为另一个类的成员字段。因此，让我们扩展我们的解决方案以包含该嵌套类。在这里，我们发明了一个Happening由一个描述字符串和一个LocalDateTime对象组成的类。

package work.basil.example;

import java.time.LocalDateTime;
import java.util.Objects;

public class Happening
{
    private String description;
    private LocalDateTime localDateTime;

    public Happening ( String description , LocalDateTime localDateTime )
    {
        this.description = Objects.requireNonNull( description );
        this.localDateTime = Objects.requireNonNull( localDateTime );
    }

    public String getDescription ( ) { return this.description; }

    public LocalDateTime getLocalDateTime ( ) { return this.localDateTime; }

    @Override
    public String toString ( )
    {
        return "Happening{ " +
                "description='" + description + '\'' +
                " | localDateTime=" + localDateTime +
                " }";
    }
}

让我们收集这些对象，并使用类似于上面看到的代码进行排序。我们必须多走一步，LocalDateTime从每个Happening对象中提取一个对象。

List < Happening > happenings = List.of(
        new Happening( "aaa" , LocalDateTime.parse( "2016-10-06T09:10" ) ) ,
        new Happening( "bbb" , LocalDateTime.parse( "2016-10-06T10:34" ) ) ,
        new Happening( "ccc" , LocalDateTime.parse( "2016-12-06T11:15" ) ) ,
        new Happening( "ddd" , LocalDateTime.parse( "2016-11-06T10:34" ) ) ,
        new Happening( "eee" , LocalDateTime.parse( "2016-12-06T10:10" ) ) ,
        new Happening( "fff" , LocalDateTime.parse( "2016-12-06T06:56" ) )
);

List < Happening > sorted = new ArrayList <>( happenings );

sorted.sort(
        Comparator
                .comparing( ( Happening happening ) -> happening.getLocalDateTime().toLocalDate() )
                .reversed()
                .thenComparing(
                        Comparator
                                .comparing( ( Happening happening ) -> happening.getLocalDateTime().toLocalTime() )
                )

);

// Dump to console.
System.out.println( "happenings = " + happenings );
System.out.println( "sorted = " + sorted );

运行时，我们从 abcdef 转到 fecdab 命令。

发生 = [发生{ description='aaa' | localDateTime=2016-10-06T09:10 }, 正在发生{ description='bbb' | localDateTime=2016-10-06T10:34 }, 正在发生{ description='ccc' | localDateTime=2016-12-06T11:15 }, 正在发生{ description='ddd' | localDateTime=2016-11-06T10:34 }, 正在发生{ description='eee' | localDateTime=2016-12-06T10:10 }, 正在发生{ description='fff' | localDateTime=2016-12-06T06:56 }]

sorted = [Happening{ description='fff' | localDateTime=2016-12-06T06:56 }, 正在发生{ description='eee' | localDateTime=2016-12-06T10:10 }, 正在发生{ description='ccc' | localDateTime=2016-12-06T11:15 }, 正在发生{ description='ddd' | localDateTime=2016-11-06T10:34 }, 正在发生{ description='aaa' | localDateTime=2016-10-06T09:10 }, 正在发生{ description='bbb' | localDateTime=2016-10-06T10:34 }]