Java 日期排序-从最新到最旧 Collections.sort（someList，newcomparator（）{ 公共int比较（最终SomeObject对象1，最终SomeObject对象2）{ return（object1.getSomeDate（））.compareTo（object2.getSomeDate（））； }} );

它会给我最新日期的对象吗？这意味着列表将包含最新日期到最早日期的对象集？

为了确保您可以使用：

Collections.sort(someList, new Comparator<SomeObject>() {
            public int compare(final SomeObject object1, final SomeObject object2) {
                return (object1.getSomeDate()).compareTo(object2.getSomeDate()); 
            }}
        );

Collections.sort（someList，newcomparator（）{
公共int比较（最终SomeObject对象1，最终SomeObject对象2）{
在（object2.getSomeDate（）之后返回object1.getSomeDate（））？1:-1；
}}
);

日期的默认顺序将把较新日期放在较旧日期之后，因此最旧日期将位于列表的开头，最新日期将位于列表的末尾<代码>比较器在我看来一直很难理解，所以我转而使用谷歌的对象来实现

比较器

。例如，您的

比较器可以这样编写：

Collections.sort(someList, new Comparator<SomeObject>() {
        public int compare(final SomeObject object1, final SomeObject object2) {
            return object1.getSomeDate().after(object2.getSomeDate()) ? 1 : -1; 
        }}
);

public static int compare(long x, long y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

通过使用，您可以以更简单易读的方式获得相同的结果，如下所示：

Ordering<SomeObject> order = Ordering.natural().reverse().onResultOf(new Function<SomeObject, Date>() {
    public Date apply(SomeObject object) {
        return object.getDate();
    }
});

比编写一个晦涩难懂的内部类要好得多，不是吗？
这很旧，但可能有人可以使用它。可以使用java8对其进行如下排序：

sort(someList, on(SomeObject.class).getSomeDate());

比较器。比较
你可以传一个给

如果希望根据日期按升序对对象进行排序：

  someList.sort(Comparator.comparing(listMember::dateProducingMethod))

或

按降序排列。
尝试以下操作：

someList.sort(Comparator.comparing(SomeObject::getSomeDate).reversed());

List List=new ArrayList（）；
//在列表中添加一些日期
Collections.sort（list，newcomparator（）{
公共整数比较（最终日期对象1，最终日期对象2）{
返回Long.compare（object1.getTime（），object2.getTime（））；
}}
);

Date.getTime（）将日期“转换”为一个长字符，这更容易比较和排序

不管怎样，窗帘后面的长条与此相比：

  List<Date> list=new ArrayList<Date>();
  //add some dates to list
  Collections.sort(list, new Comparator<Date>() {
      public int compare(final Date object1, final Date object2) {
          return Long.compare(object1.getTime(),object2.getTime());
      }}
  );

公共静态int比较（长x，长y）{
回报率（x

如果要反转排序，只需将其乘以-1，如下所示：

Collections.sort(someList, new Comparator<SomeObject>() {
        public int compare(final SomeObject object1, final SomeObject object2) {
            return object1.getSomeDate().after(object2.getSomeDate()) ? 1 : -1; 
        }}
);

public static int compare(long x, long y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

List List=new ArrayList（）；
//在列表中添加一些日期
Collections.sort（list，newcomparator（）{
公共整数比较（最终日期对象1，最终日期对象2）{
返回Long.compare（object1.getTime（），object2.getTime（））*-1；
}}
);
为什么不运行一个测试来找出答案？这不会违反关于相等元素的可比合同吗？对于两个相同日期的对象，compare（date1，date2）和compare（date2，date1）在您的实现中都将返回-1。@Jörn Horstmann：理论上是这样，但实际上我不确定是否值得再添加一个（几乎相同）验证只是为了得到相同的结果。@Kevin Bourrillion:你能给出更有意义的参数吗？@Roman Collections.sort、TreeMap等。如果违反合同，可能会抛出异常。从：Collections.sort中，如果实现检测到列表元素的自然顺序违反了可比契约，则可能会抛出一个
IllegalArgumentException-（可选）
我唯一不明白的是为什么会有“comparator”临时变量。你不使用它，也不需要它。请注意，除了集合.sort（someList，order）

之外，您还可以选择执行

List newList=order.sortedCopy（someList）

。大部分操作都清楚地表明了排序实现了Comparator，但感谢您对sortedCopy的评论，我以前没有注意到该方法。

  List<Date> list=new ArrayList<Date>();
  //add some dates to list
  Collections.sort(list, new Comparator<Date>() {
      public int compare(final Date object1, final Date object2) {
          return Long.compare(object1.getTime(),object2.getTime())*-1;
      }}
  );