Java 对日期和时间值进行排序

简单地说，我有一个不同日期和时间的字符串数组。每个元素的格式如下：

2015-08-27T22:24:31.903

也就是说，YYYY-MM-DDTHH:MM:SS.MMM

我正在整理它们。是否有默认方法可用于排序此格式

---

我现在做的是在T处拆分字符串，将日期和时间转换为各自的时间戳，添加它们，然后对时间戳值进行排序。这种格式有直接解析器吗？一个更好的解决方案是最受欢迎的。

我认为那些是字符串。如果您不想做显而易见的事情（将它们转换为1并比较结果），您可以将它们作为字符串进行比较，当您使用字符串比较时，特定的日期-时间格式（几乎完整的ISO-8601时间戳，只是缺少一个时区指示符）可以正常工作

无偿的例子（）：

输出：

2001-03-25T23:41:24.234 2002-10-24T13:51:25.417 2002-11-04T06:39:55.287 2003-07-16T06:32:07.703 2005-03-20T08:28:18.440 2005-08-24T05:05:01.080 2008-10-05T04:41:56.004 2009-04-17T13:20:09.499 2013-04-10T22:14:06.852 2015-11-20T17:32:27.303 2001-03-25T23:41:24.234 2002-10-24T13:51:25.417 2002-11-04T06:39:55.287 2003-07-16T06:32:07.703 2005-03-20T08:28:18.440 2005-08-24T05:05:01.080 2008-10-05T04:41:56.004 2009-04-17T13:20:09.499 2013-04-10T22:14:06.852 2015-11-20T17:32:27.303 当然，如果您需要不同的顺序（例如反向顺序），您可以提供一个

比较器


或者，如果这些实际上是UTC日期/时间，但在解析之前需要在字符串末尾添加一个
Z
。
1）使用适当的SimpleDataFormat解析字符串：

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-ddTHH:mm:ss.SSS");
try {
    Date date = formatter.parse(dateInString);
} catch (ParseException e) {
    e.printStackTrace();
}

2） 将每个日期存储在列表中。为此，首先实例化一个新列表

ArrayList<Date> myDates = new ArrayList<Date>();

3） 使用以下方法对它们进行排序：

Collections.sort(myDates); // Ascending

或

我有一个字符串数组。每个元素的格式如下：
2015-08-27T22:24:31.903
。是否有默认方法可用于排序此格式

对。由于ISO字符串具有降序的日期字段，并且字段的宽度固定，因此可以直接使用以下命令对字符串进行简单排序：根据元素的自然顺序，将指定的对象数组按升序排序

这种格式有直接解析器吗

是的从文本字符串（如
2007-12-03T10:15:30
）获取
LocalDateTime
的实例，使用日历API对日期和时间进行排序

import java.util.ArrayList;
import java.util.Collections;

public class SortMain {

    public static void main(String[] args) {

        ArrayList<SomeObj> al= new ArrayList();

        SomeObj s1 = new SomeObj("9", "2020-02-05");
        al.add(s1);
        s1 = new SomeObj("7", "2020-02-05");
        al.add(s1);
        /*s1 = new SomeObj("15", "2019-12-25");
        al.add(s1);
        s1 = new SomeObj("6", "2019-12-25");
        al.add(s1);*/

        printArrayList(al);

        Collections.sort(al);

        System.out.println("*************");

        printArrayList(al);

    }

    private static void printArrayList(ArrayList<SomeObj> al) {
        for(SomeObj someObj: al) {
            System.out.println(someObj.getDate() + " ** " + someObj.getTime());
        }
    }
}

import java.util.ArrayList；
导入java.util.Collections；
公共类分拣机{
公共静态void main（字符串[]args）{
ArrayList al=新的ArrayList（）；
SomeObj s1=新的SomeObj（“9”、“2020-02-05”）；
al.添加（s1）；
s1=新的SomeObj（“7”，“2020-02-05”）；
al.添加（s1）；
/*s1=新的SomeObj（“15”、“2019-12-25”）；
al.添加（s1）；
s1=新SomeObj（“6”、“2019-12-25”）；
al.添加（s1）*/
打印阵列列表（al）；
集合。排序（al）；
System.out.println（“****************”）；
打印阵列列表（al）；
}
私有静态void printarylist（ArrayList al）{
for（SomeObj SomeObj:al）{
System.out.println（someObj.getDate（）+“**”+someObj.getTime（））；
}
}
}

以及

package com.karthik.sorting；
导入java.text.simpleDataFormat；
导入java.util.Calendar；
导入java.util.Date；
公共类SomeObj实现了可比较的{
私有字符串时间；
私有字符串日期；
公共SomeObj（字符串时间、字符串日期）{
超级（）；
这个时间=时间；
this.date=日期；
}
公共字符串getTime（）{
返回时间；
}
公共无效设置时间（字符串时间）{
这个时间=时间；
}
公共字符串getDate（）{
返回日期；
}
公共无效设置日期（字符串日期）{
this.date=日期；
}
@凌驾
公共int比较（SomeObj siteHealthGraphItem）{
字符串receivedPattern=“yyyy-MM-dd”；
SimpleDataFormat SimpleDataFormat=新的SimpleDataFormat（接收模式）；
试一试{
Date date1=simpleDateFormat.parse（getDate（）.toString（））；
Date date2=SimpleDataFormat.parse（siteHealthGraphItem.getDate（）.toString（））；
if（getTime（）==null）{
返回日期1.与（日期2）相比；
}else if（getTime（）！=null）{
Calendar cal1=Calendar.getInstance（）；
cal1.设置时间（日期1）；
cal1.set（Calendar.HOUR\u OF_DAY，Integer.parseInt（getTime（））；
Calendar cal2=Calendar.getInstance（）；
计算2.设置时间（日期2）；
cal2.set（Calendar.HOUR\u OF_DAY，Integer.parseInt（siteHealthGraphItem.getTime（））；
返回cal1.compareTo（cal2）；
}
}捕获（例外e）{
System.out.println（“数据不正确-排序不起作用…”）；
e、 printStackTrace（）；
}
System.out.println（“排序不起作用…”）；
返回0；
}
}
使用现代Java
答案是正确的。下面是一个变体，它使用了添加到Java更高版本中的新特性

使用这些数据制作一些示例。结果列表是不可修改的。因此，将不可修改列表馈送给的构造函数，以获得我们可以排序的可修改列表

List < String > strings = new ArrayList <>(
        List.of(
                "2015-08-27T22:24:31.903" ,
                "2018-08-27T22:24:31.903" ,
                "2016-08-27T22:24:31.903" ,
                "2017-08-27T22:24:31.903"
        )
);

转储到控制台

System.out.println( "strings = " + strings );

看这个

字符串=[2015-08-27T22:24:31.9032016-08-27T22:24:31.9032017-08-27T22:24:31.9032018-08-27T22:24:31.903]

按日期时间对象排序
如果您想进一步使用此输入，请将其解析为日期时间对象

现代方法使用java.time类

我们可以简化示例数据，因为我们可以直接使用由
List.of
生成的不可修改的
List

List < String > strings =
        List.of(
                "2015-08-27T22:24:31.903" ,
                "2018-08-27T22:24:31.903" ,
                "2016-08-27T22:24:31.903" ,
                "2017-08-27T22:24:31.903"
        );

通过一次解析一个输入字符串，生成
LocalDateTime
对象来填充该列表。将该对象添加到我们的列表中

请注意，java.time类默认使用ISO8601格式。因此，无需指定格式化模式

for ( String string : strings )
{
    ldts.add( LocalDateTime.parse( string ) );  // Parsing text in ISO 8601 format needs no formatting pattern to be specified.
}

排序，正如我们上面所做的。调用
列表：：排序
，传递一个
比较器

ldts.sort( Comparator.naturalOrder() ) ;

你看

溪流
我们可以
strings.sort( Comparator.naturalOrder() );

System.out.println( "strings = " + strings );

List < String > strings =
        List.of(
                "2015-08-27T22:24:31.903" ,
                "2018-08-27T22:24:31.903" ,
                "2016-08-27T22:24:31.903" ,
                "2017-08-27T22:24:31.903"
        );

List < LocalDateTime > ldts = new ArrayList <>( strings.size() );

for ( String string : strings )
{
    ldts.add( LocalDateTime.parse( string ) );  // Parsing text in ISO 8601 format needs no formatting pattern to be specified.
}

ldts.sort( Comparator.naturalOrder() ) ;

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

List < String > strings =
        List.of(
                "2015-08-27T22:24:31.903" ,
                "2018-08-27T22:24:31.903" ,
                "2016-08-27T22:24:31.903" ,
                "2017-08-27T22:24:31.903"
        );

List < LocalDateTime > ldts = 
    strings
    .stream()
    .map( s -> LocalDateTime.parse( s ) )
    .sorted()
    .collect( Collectors.toList() )
;

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