Java 按LocalDate降序和LocalTime升序对列表排序_Java_List_Sorting_Date_Comparator

Java 按LocalDate降序和LocalTime升序对列表排序

java list sorting date

Java 按LocalDate降序和LocalTime升序对列表排序,java,list,sorting,date,comparator,Java,List,Sorting,Date,Comparator,我有一个包含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 应按以下顺序进行排序： 2016-12-06T06:56 2016-12-06T10

我有一个包含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 应按以下顺序进行排序：

2016-12-06T06:56 2016-12-06T10:10 2016-12-06T11:15 2016-11-06T10:34 2016-10-06T09:10 2016-10-06T10:34 请记住，我需要使用字段对对象进行排序，而不是使用LocalDateTime列表，而是使用LocalDateTime字段对对象列表进行排序

感谢您的帮助：

对象知道如何按时间顺序排序。您希望按日期降序按逆时间顺序排序，以后的日期优先，但也按时间升序按时间顺序排序，这意味着接口所需的类实现方法的内置功能无法完成此任务

常规语法对于自定义排序，请编写自己的实现。该接口需要实现一个方法：

这里的逻辑很简单：

比较日期部分。如果两个日期不同，则在该基础上反向排序，然后继续向下移动列表。如果两者的日期相同，则深入挖掘以比较它们的时间部分，按时间顺序排序。代码

ldts=[2016-10-06T09:102016-10-06T10:342016-12-06T11:152016-11-06T10:342016-12-06T10:102016-12-06T06:56]

排序=[2016-12-06T06:562016-12-06T10:102016-12-06T11:152016-11-06T10:342016-10-06T09:102016-10-06T10:34]

Lambda语法演示了如何在现代Java中使用函数lambda语法进行等效工作。这句话激励我尝试功能性方法

这里的想法是使用两个比较器对象：一个用于日期，另一个用于时间。实际上，我们可以通过调用Comparator:：ThenComparating将一个比较器嵌套在另一个比较器中。因此，我们需要建立两个比较器，然后将一个比较器馈送给另一个比较器。我们实例化一个comparatorDate，然后给它一个comparatorTime，以获得一个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:102016-10-06T10:342016-12-06T11:152016-11-06T10:342016-12-06T10:102016-12-06T06:56]

排序=[2016-12-06T06:562016-12-06T10:102016-12-06T11:152016-11-06T10:342016-10-06T09:102016-10-06T10:34]

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

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

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

运行时，我们从a-b-c-d-e-f到f-e-c-d-a-b顺序

事件=[发生{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}]

排序=[发生{description='fff'| localDateTime=2016-12-06T06:56}，发生{description='eee'| localDateTime=2016-12-06T10:10}，发生{description='fff'| 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}]

常规语法对于自定义排序，请编写自己的实现。该接口需要实现一个方法：

这里的逻辑很简单：

ldts=[2016-10-06T09:102016-10-06T10:342016-12-06T11:152016-11-06T10:342016-12-06T10:102016-12-06T06:56]

排序=[2016-12-06T06:562016-12-06T10:102016-12-06T11: 15、2016-11-06T10:342016-10-06T09:102016-10-06T10:34]

Lambda语法演示了如何在现代Java中使用函数lambda语法进行等效工作。这句话激励我尝试功能性方法

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:102016-10-06T10:342016-12-06T11:152016-11-06T10:342016-12-06T10:102016-12-06T06:56]

排序=[2016-12-06T06:562016-12-06T10:102016-12-06T11:152016-11-06T10:342016-10-06T09:102016-10-06T10:34]

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

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

运行时，我们从a-b-c-d-e-f到f-e-c-d-a-b顺序

为这个问题写一个自定义的协同学…我真的很想提供一个解决方案，但你没有表现出任何努力，只是要求…你能添加任何你试图解决这个问题的东西吗？在你问题的最后一句话中有一个I，记住我需要排序…这指向你…@OleV.V。我用常规的方法写了一个答案语法来解决这个问题。我也尝试过使用你的lambda语法方法，但无法使其发挥作用。也许你愿意自己用一个工作示例来尝试一下。我很好奇看到它的实际应用。请注意此网页上出现的以下内容：1首先，真诚地尝试自己解决问题。2询问具体的问题您现有的实现存在问题。@OleV.V.我设法使您的代码的一个变体正常工作。有没有更短或更好的方法？为此编写一个自定义的Coparator…我真的很想提供一个解决方案，但您没有付出任何努力，只是提出了一些要求…您能添加一些您试图解决这个问题的内容吗？您的代码中有一个I问题的最后一句请记住，我需要排序…这指向你…@OleV.V。我用传统语法写了一个答案来解决这个问题。我也尝试过使用你的lambda语法方法，但无法使其发挥作用。也许你愿意自己用一个工作示例来尝试一下。我很好奇看到它的实际应用请注意此网页上出现的以下内容：1首先，真诚地尝试自己解决问题。2询问您现有实现中的具体问题。@OleV.V.我设法使您的代码变体正常工作。是否有更短或更好的方法？

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

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 );

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 );

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 +
                " }";
    }
}

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 );