如何在Java中对自定义ArrayList排序？

我已声明ArrayList如下：

ArrayList<HashMap<String, String>> oslist = new ArrayList<HashMap<String, String>>();

ArrayList oslist=new ArrayList（）；

oslist的每个元素包含5个哈希映射：

            HashMap<String, String> map = new HashMap<String, String>();
            map.put(string, string);
map.put(string, string);
map.put(string, string);
map.put(string, string);
map.put(string, string);

HashMap map=newhashmap（）；
map.put（字符串，字符串）；
map.put（字符串，字符串）；
map.put（字符串，字符串）；
map.put（字符串，字符串）；
map.put（字符串，字符串）；

其中之一是以下格式的日期：“yyyy-MM-dd'T'HH:MM:ss.SSS'Z'”

现在我已经编写了这个类，它对这个日期格式进行排序。类及其用法如下所示：

ArrayList<HashMap<String, String>> oslist = new ArrayList<HashMap<String, String>>();

DateObject.java

package com.test;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class DateObject implements Comparable<Object> {

    private String date;
    private String time;

    public DateObject(String dates) {
        try {
            Date date_for = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
                    Locale.ENGLISH).parse(dates);
            String date_upd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH)
            .format(date_for);
            //System.out.println(date_upd);
            String[] parts = date_upd.split(" ");
            this.date = parts[0]; 
            this.time = parts[1];
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public int compareTo(Object o) {

        DateFormat formatter;
        Date date1 = null;
        Date date2 = null;
        formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            date1 = (Date) formatter.parse(this.date + " " + this.time);
            DateObject other = (DateObject) o;
            date2 = (Date) formatter.parse(other.date + " " + other.time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        catch(NullPointerException npe){
            System.out.println("Exception thrown "+npe.getMessage()+" date1 is "+date1+" date2 is "+date2);
        }

        return date2.compareTo(date1);

    }

    @Override
    public String toString(){       
        return this.date+" "+this.time;
    }

}

package.com.test；
导入java.text.DateFormat；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入java.util.Locale；
公共类DateObject实现了可比较的{
私有字符串日期；
私有字符串时间；
公共日期对象（字符串日期）{
试一试{
日期日期=新的简化格式（“yyyy-MM-dd'T'HH:MM:ss.SSS'Z'，
解析（日期）；
字符串日期\ upd=新的SimpleDataFormat（“yyyy-MM-dd HH:MM:ss”，Locale.ENGLISH）
.格式（日期）；
//系统输出打印LN（更新日期）；
String[]parts=date\u upd.split（“”）；
this.date=零件[0]；
此时间=零件[1]；
}捕获（解析异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
公共整数比较对象（对象o）{
数据格式格式化程序；
Date date1=null；
日期2=空；
格式化程序=新的SimpleDataFormat（“yyyy-MM-dd HH:MM:ss”）；
试一试{
date1=（Date）formatter.parse（this.Date+“”+this.time）；
DateObject other=（DateObject）o；
date2=（Date）格式化程序.parse（other.Date+“”+other.time）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
捕获（NullPointerException npe）{
System.out.println（“抛出异常”+npe.getMessage（）+“date1是”+date1+“date2是”+date2）；
}
返回日期2.与（日期1）相比；
}
@凌驾
公共字符串toString（）{
返回此.date+“”+此.time；
}
}

Test.java

package com.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

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


    public class Test {

        public static void main(String[] args) {

               List<DateObject> list = new ArrayList<DateObject>();
    ;

                DateObject d1 = new DateObject("2012-12-05T11:20:19.111Z");
                list.add(d1);

                d1 = new DateObject("2012-12-05T11:20:19.111Z");
                list.add(d1);

                d1 = new DateObject("2012-12-04T10:20:19.111Z");
                list.add(d1);

                d1 = new DateObject("2010-12-07T13:20:19.111Z");
                list.add(d1);

                d1 = new DateObject("2012-12-05T11:20:19.111Z");
                list.add(d1);
                Collections.sort(list);

                for(DateObject d : list){
                    System.out.println(d);
                }

        }
    //  "yyyy-MM-dd HH:mm:ss
    }

package.com.test；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入java.util.Locale；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公开课考试{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
;
DateObject d1=新的DateObject（“2012-12-05T11:20:19.111Z”）；
列表。添加（d1）；
d1=新的日期对象（“2012-12-05T11:20:19.111Z”）；
列表。添加（d1）；
d1=新的日期对象（“2012-12-04T10:20:19.111Z”）；
列表。添加（d1）；
d1=新的日期对象（“2010-12-07T13:20:19.111Z”）；
列表。添加（d1）；
d1=新的日期对象（“2012-12-05T11:20:19.111Z”）；
列表。添加（d1）；
集合。排序（列表）；
用于（日期对象d:列表）{
系统输出打印ln（d）；
}
}
//“yyyy-MM-dd HH:MM:ss
}

---

我的问题是如何使用这个类对我的oslist进行排序？也就是说，当我根据日期HashMap对oslist进行排序时，我的其他HashMap也会相应地进行排序。需要注意的是，在oslist中，日期将存储为字符串，因此我不能直接使用排序。谢谢。

您的

Compariable

实现为false，应该是：

public class DateObject implements Comparable<DateObject> {
  ...
  @Override
  public int compareTo(DateObject o) {
     ...
  }
}

但我不能建议你做或不做，因为我不知道你的地图持有什么（都是字符串？！）

---

TreeMap

也可能很有用，因为它按键排序。

不确定我是否正确理解该问题……您想对哈希映射列表进行排序，并且在每个哈希映射中都有一个包含此DateObject的条目？如果是，您可以使用

Collections.sort（listOfHashMaps，newcomparator（）{
@凌驾
公共整数比较（最终HashMapo1，最终HashMapO2）{
最终字符串dateObject1=o1.get（“dateObjectKey”）；
最终字符串dateObject2=o2.get（“dateObjectKey”）；
//分析日期对象比较并返回结果。。。
}
})

如果需要对对象映射列表进行排序，则需要编写一个比较器，用于比较对象映射与其他对象映射的方式

    ArrayList<HashMap<String, String>> oslist = new ArrayList<HashMap<String, String>>();
    Collections.sort(oslist, new Comparator<HashMap<String, String>>(){

        @Override
        public int compare(HashMap<String, String> o1, HashMap<String, String> o2) {
            //implement your sorting logic here
        };

    });

ArrayList oslist=new ArrayList（）；
Collections.sort（oslist，newcomparator（）{
@凌驾
公共int比较（HashMap o1、HashMap o2）{
//在这里实现您的排序逻辑
};
});

两个hashmap之间没有内在的顺序，两个TreeMap之间也没有内在的顺序（尽管TreeMap中的对象，如果有办法相互比较，它们会被排序）

---

您可以在此函数中重用Compariable DateObject，但请记住，您还必须对Collections.sort（）说明如何比较一个HashMap与另一个HashMap。

树集通过自定义“Compariator”进行自然排序，因此字符串的

Comparieto（）

未使用，但不能添加空值，也不能添加重复值（但comperae=0的值）

即

公共类StringTypeDateTimeComparator扩展了Comparable{
公共整数比较（字符串o1、字符串o2）{
返回新的SimpleDataFormat（“yyyy-MM-dd HH:MM:ss”）。解析（o1）
.compareTo（新简化格式（“yyyy-MM-dd HH:MM:ss”）.parse（o2））；
}
}
TreeSet ts=新的TreeSet（新的StringTypeDateTimeComparator（））；
ts.add（“2012-12-01T11:20:19.111Z”）；
ts.add（“2012-12-20T11:20:19.111Z”）；

---

为什么要实例化SimpleDataFormat两次？这不是线程保存。

oslist中有“Map”。因此必须为Map创建比较器。从Map中获取日期比较它们如果需要有序映射，请使用树映射而不是HashMap。您患有对象恐惧症和类型恐惧症。Defin

    ArrayList<HashMap<String, String>> oslist = new ArrayList<HashMap<String, String>>();
    Collections.sort(oslist, new Comparator<HashMap<String, String>>(){

        @Override
        public int compare(HashMap<String, String> o1, HashMap<String, String> o2) {
            //implement your sorting logic here
        };

    });

public class StringTypeDateTimeComparator extends Comparable<String>{
   public int compare(String o1, String o2){
     return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(o1)
        .compareTo(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(o2));
   }
}

TreeSet<String> ts = new TreeSet<String>(new StringTypeDateTimeComparator());
ts.add("2012-12-01T11:20:19.111Z");
ts.add("2012-12-20T11:20:19.111Z");