用java重写Comparator实现自定义排序
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了用java重写Comparator实现自定义排序相关的知识,希望对你有一定的参考价值。
这样的数据
2014-04-01T15:47:33.273Z
2014-04-01T15:47:33.444Z
2014-04-01T15:47:33.614Z
2014-04-06T19:43:03.202Z
2014-04-06T19:43:03.274Z
2014-04-06T19:43:03.372Z
2014-04-06T19:43:03.416Z
2014-09-26T18:49:34.024Z
2014-09-26T18:49:34.026Z
怎么重写Comparator实现排序呢,(这是一种时间格式,最好保留原格式,用重写比较接口的方式实现)
!!!最好把原数据建一个文本文件,读取后进行排序,然后排序后的结果也输出到文本文件中,要求有点多~!!!楼主新手!!请见谅~
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
public class Test
public static void main ( String[] args )
String[] array =
"2014-04-01T15:47:33.273Z",
"2014-04-01T15:47:33.444Z",
"2014-04-01T15:47:33.614Z",
"2014-04-06T19:43:03.202Z",
"2014-04-06T19:43:03.274Z",
"2014-04-06T19:43:03.372Z",
"2014-04-06T19:43:03.416Z",
"2014-09-26T18:49:34.024Z",
"2014-09-26T18:49:34.026Z"
;
final SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
Arrays.sort (array, new Comparator<String>()
@Override
public int compare ( String o1, String o2 )
try
Date d1 = sdf.parse (o1);
Date d2 = sdf.parse (o2);
if (d1.before (d2))
return 1;
else if (d1.after (d2))
return -1;
else
return 0;
catch (ParseException e)
e.printStackTrace ();
return 0;
);
for ( String string : array )
System.out.println (string);
追问
就是这样,但能不能用文本方式读取和输出啊??就是上面加的要求写的~我在加50分哦~!不好意思,实在新手!!
追答进步啊
参考技术A List<TestDate> dates=...;//要排序的时间Collections.sort(dates,new Comparator<TestDate>()
public int compare(TestDate t1, TestDate t2)
if(t1.after(t2))
return -1;
else if(t1.before(t2))
return 1;
else
return 0;
);
这样是降序,你要想升序把1和-1换一下 参考技术B List<String> dateList = new ArrayList<String>();
Collections.sort(dateList, new Comparator<String>()
@Override
public int compare(String o1, String o2)
if(null == o1)
o1 = "";
if(null == o2)
o2 = "";
return o1.compareTo(o2);
);
JAVA Comparator 接口排序用法
java的比较器有两类,分别是Comparable接口和Comparator接口。
在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。
让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组,实例如下:
- class Student implements Comparable<Student>{
- private String name;
- private int age;
- private float score;
- public Student(String name, int age, float score) {
- this.name = name;
- this.age = age;
- this.score = score;
- }
- public String toString()
- {
- return name+"\t\t"+age+"\t\t"+score;
- }
- @Override
- public int compareTo(Student o) {
- // TODO Auto-generated method stub
- if(this.score>o.score)//score是private的,为什么能够直接调用,这是因为在Student类内部
- return -1;//由高到底排序
- else if(this.score<o.score)
- return 1;
- else{
- if(this.age>o.age)
- return 1;//由底到高排序
- else if(this.age<o.age)
- return -1;
- else
- return 0;
- }
- }
- }
- public class ComparableDemo01 {
- /**
- * @param args
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Student stu[]={new Student("zhangsan",20,90.0f),
- new Student("lisi",22,90.0f),
- new Student("wangwu",20,99.0f),
- new Student("sunliu",22,100.0f)};
- java.util.Arrays.sort(stu);
- for(Student s:stu)
- {
- System.out.println(s);
- }
- }
- }
在上面的程序中,实现了Comparable接口,并重写了compareTo方法,将学生先按成绩由大到小排名,成绩相同时候按照年龄由低到高排序。
执行的结果是
sunliu 22 100.0
wangwu 20 99.0
zhangsan 20 90.0
lisi 22 90.0
但是在设计类的时候,可能没有考虑到让类实现Comparable接口,那么就需要用到另外的一个比较器接口Comparator。
从上面的实例我们可以发现,compareTo(T o)只有一个参数,而Comparator接口中必须要实现的compare(T o1,T o2)就有两个参数。
代码实例
- package edu.sjtu.ist.comutil;
- import java.util.Comparator;
- class Student {
- private String name;
- private int age;
- private float score;
- public Student(String name, int age, float score) {
- this.name = name;
- this.age = age;
- this.score = score;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- public float getScore() {
- return score;
- }
- public void setScore(float score) {
- this.score = score;
- }
- public String toString()
- {
- return name+"\t\t"+age+"\t\t"+score;
- }
- }
- class StudentComparator implements Comparator<Student>{
- @Override
- public int compare(Student o1, Student o2) {
- // TODO Auto-generated method stub
- if(o1.getScore()>o2.getScore())
- return -1;
- else if(o1.getScore()<o2.getScore())
- return 1;
- else{
- if(o1.getAge()>o2.getAge())
- return 1;
- else if(o1.getAge()<o2.getAge())
- return -1;
- else
- return 0;
- }
- }
- }
- public class ComparableDemo02 {
- /**
- * @param args
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Student stu[]={new Student("zhangsan",20,90.0f),
- new Student("lisi",22,90.0f),
- new Student("wangwu",20,99.0f),
- new Student("sunliu",22,100.0f)};
- java.util.Arrays.sort(stu,new StudentComparator());
- for(Student s:stu)
- {
- System.out.println(s);
- }
- }
- }
上面依然是对student对象数组进行排序,用的都是Array.sort方法,不同的是实现comparator接口时,sort方法需要传进来两个参数,即stu对象数组,以及重写的实现了comparator比较方法类。
程序运行的结果和上面是一样的
Array.sort是对数组进行排序,假如我们不想使用数组,想使用Collection接口下的集合,如想使用List,那么需要稍微做些修改:
全部的学生:
0zhangnan3 6778
0zhangnan2 390
2zhangnan1 5796
3zhangnan4 6253
在这里我们没有使用对象数组,而是使用了Collection 接口下的ArrayList 集合,所以排序用的是Collections.sort(st,new ComparatorSort())
java的比较器有两类,分别是Comparable接口和Comparator接口。
在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。
让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组,实例如下:
- class Student implements Comparable<Student>{
- private String name;
- private int age;
- private float score;
- public Student(String name, int age, float score) {
- this.name = name;
- this.age = age;
- this.score = score;
- }
- public String toString()
- {
- return name+"\t\t"+age+"\t\t"+score;
- }
- @Override
- public int compareTo(Student o) {
- // TODO Auto-generated method stub
- if(this.score>o.score)//score是private的,为什么能够直接调用,这是因为在Student类内部
- return -1;//由高到底排序
- else if(this.score<o.score)
- return 1;
- else{
- if(this.age>o.age)
- return 1;//由底到高排序
- else if(this.age<o.age)
- return -1;
- else
- return 0;
- }
- }
- }
- public class ComparableDemo01 {
- /**
- * @param args
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Student stu[]={new Student("zhangsan",20,90.0f),
- new Student("lisi",22,90.0f),
- new Student("wangwu",20,99.0f),
- new Student("sunliu",22,100.0f)};
- java.util.Arrays.sort(stu);
- for(Student s:stu)
- {
- System.out.println(s);
- }
- }
- }
在上面的程序中,实现了Comparable接口,并重写了compareTo方法,将学生先按成绩由大到小排名,成绩相同时候按照年龄由低到高排序。
执行的结果是
sunliu 22 100.0
wangwu 20 99.0
zhangsan 20 90.0
lisi 22 90.0
但是在设计类的时候,可能没有考虑到让类实现Comparable接口,那么就需要用到另外的一个比较器接口Comparator。
从上面的实例我们可以发现,compareTo(T o)只有一个参数,而Comparator接口中必须要实现的compare(T o1,T o2)就有两个参数。
代码实例
- package edu.sjtu.ist.comutil;
- import java.util.Comparator;
- class Student {
- private String name;
- private int age;
- private float score;
- public Student(String name, int age, float score) {
- this.name = name;
- this.age = age;
- this.score = score;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- public float getScore() {
- return score;
- }
- public void setScore(float score) {
- this.score = score;
- }
- public String toString()
- {
- return name+"\t\t"+age+"\t\t"+score;
- }
- }
- class StudentComparator implements Comparator<Student>{
- @Override
- public int compare(Student o1, Student o2) {
- // TODO Auto-generated method stub
- if(o1.getScore()>o2.getScore())
- return -1;
- else if(o1.getScore()<o2.getScore())
- return 1;
- else{
- if(o1.getAge()>o2.getAge())
- return 1;
- else if(o1.getAge()<o2.getAge())
- return -1;
- else
- return 0;
- }
- }
- }
- public class ComparableDemo02 {
- /**
- * @param args
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Student stu[]={new Student("zhangsan",20,90.0f),
- new Student("lisi",22,90.0f),
- new Student("wangwu",20,99.0f),
- new Student("sunliu",22,100.0f)};
- java.util.Arrays.sort(stu,new StudentComparator());
- for(Student s:stu)
- {
- System.out.println(s);
- }
- }
- }
上面依然是对student对象数组进行排序,用的都是Array.sort方法,不同的是实现comparator接口时,sort方法需要传进来两个参数,即stu对象数组,以及重写的实现了comparator比较方法类。
程序运行的结果和上面是一样的
Array.sort是对数组进行排序,假如我们不想使用数组,想使用Collection接口下的集合,如想使用List,那么需要稍微做些修改:
全部的学生:
0 zhangnan3 67 78
0 zhangnan2 39 0
2 zhangnan1 57 96
3 zhangnan4 62 53
在这里我们没有使用对象数组,而是使用了Collection 接口下的ArrayList 集合,所以排序用的是Collections.sort(st,new ComparatorSort())以上是关于用java重写Comparator实现自定义排序的主要内容,如果未能解决你的问题,请参考以下文章
java.ArrayList集合调用并重写sort方法,使用时报错
面试----java基础集合---------------------comparable和comparator 的区别