Compareable接口和Comparator

最新推荐文章于 2022-08-07 11:47:23 发布

ewili

最新推荐文章于 2022-08-07 11:47:23 发布

阅读量833

点赞数

需求：

做一个对象排序的功能，需要按不同规则排序

Compareable接口和Comparator接口都是用来实现集合排序的，只是Comparable是在集合内部定义的方法实现的排序，而Comparator是在集合外部实现的排序，所以，如想实现排序，就需在集合外定义Comparator接口的方法或在集合内实现Compareable接口的方法。

Comparable 是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作）;
Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
可以说一个是类自已完成比较，一个是外部程序实现比较的差别而已。

Compareable接口

要对对象进行比较大小则需要实现Compareable接口

Compareable接口只有一个方法int compareTo(Object obj) 实现了此接口的对象列表(或数组) 可以通过Collections.sort(Arrays.sort)来排序

Java代码

class Paper implements Comparable<Paper>
{
String pcolor;
public Paper(String pcolor)
{
this.pcolor=pcolor;
}
public int compareTo(Object o)//public int compareTo(Paper o)
{
if (o instanceof TestComparable) {
Paper p=(Paper)o; //未使用泛型不转换的话不能访问pcolor
int cmp=this.pcolor.compareTo(p.pcolor);
return cmp;
}
}
//重载toString方法定义输出
public String toString()
{
return this.pcolor;
}
}
public class TestComparable
{
public static void main(String []args)
{
Paper p1=new Paper("red");
Paper p2=new Paper("blue");
Paper p3=new Paper("green");
List l=new LinkedList();
l.add(p1);
l.add(p2);
l.add(p3);
Collections.sort(l);
System.out.println(l);
}
}

class Paper implements Comparable<Paper>
{
     String pcolor;
  
     public Paper(String pcolor)
     {
       this.pcolor=pcolor;
     }
  
     public int compareTo(Object o)//public int compareTo(Paper o)
     {
     if (o instanceof TestComparable) {
       Paper p=(Paper)o; //未使用泛型不转换的话不能访问pcolor
       int     cmp=this.pcolor.compareTo(p.pcolor);
       return cmp;
         }
     }
  //重载toString方法定义输出
     public String toString()
     {
       return this.pcolor;
     }
}

public class TestComparable
{
     public static void main(String []args)
     {
       Paper p1=new Paper("red");
       Paper p2=new Paper("blue");
       Paper p3=new Paper("green");
       List l=new LinkedList();
       l.add(p1);
       l.add(p2);
       l.add(p3);
       Collections.sort(l);
       System.out.println(l);
     }
}

Comparator接口：

在Comparator接口里，只有一个方法是需要实现的：

Java代码

int compare(Object o1,Object o2);

 int compare(Object o1,Object o2);

提示: 如果o1小于o2,返回一个负数;如果o1大于o2，返回一个正数;如果他们相等，则返回0;

注意: compare 方法一定要是对称的，意思是compare(a,b) 返回的结果要跟compare(b,a) 相反。相反的结果意味着，要么返回的值带有不同的正负号，要么都是0。注意，象compare(a,b) 返回4而compare(b,a) 返回-2这样的情况是合法的。方法里常常可能抛出异常，在这个方法里抛出异常也要是对称的。如果调用compare(a,b) 时抛出了一个ClassCastException 异常,那么调用compare(b,a) 时也必须抛出一个ClassCastException 异常。

另外: 任何你准备重用的Comparator 都必须是可序列化的。TreeSet 和TreeMap 类存储Comparator 以便进行比较，因此为了这两个类能被序列化，它们使用的Comparator 也必须能被序列化。

Comparator 接口，通常被Collections.sort 方法使用，它是JAVA中需要了解的一个很重要的部分

Java代码

public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
get.set...
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
}

public class Person {
  
   private String name;
     private int age;
     
     public Person() {      
      }

     public Person(String name, int age) {
         this.name = name;
        this.age = age;
     }
      get.set...

     @Override
     public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
     } 
 }

新建一个实现Comparator的实现类PersonComparator：

Java代码

import java.util.Comparator;
public class PersonComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
if (p1.getAge() > p2.getAge()) {
return 1;
} else if (p1.getAge() < p2.getAge()) {
return -1;
}
return 0;
}
}

 import java.util.Comparator;

 public class PersonComparator implements Comparator<Person> {

     @Override
    public int compare(Person p1, Person p2) {
        if (p1.getAge() > p2.getAge()) {
             return 1;
        } else if (p1.getAge() < p2.getAge()) {
             return -1;
         }
         return 0;
     }     
 }

CompareTest做测试：

Java代码

import java.util.Arrays;
ublic class CompareTest {
public static void main(String[] args) {
Person[] persons = {
new Person("P1", 60),
new Person("P2", 20),
new Person("P3", 40)
};
System.out.println(Arrays.toString(persons));
Arrays.sort(persons, new PersonComparator());
System.out.println(Arrays.toString(persons));
}
}

 import java.util.Arrays;

public class CompareTest {
 
    public static void main(String[] args) {
        Person[] persons = {
                new Person("P1", 60),
                new Person("P2", 20),
                new Person("P3", 40)
       };  
         System.out.println(Arrays.toString(persons));        

         Arrays.sort(persons, new PersonComparator());    

         System.out.println(Arrays.toString(persons));
     } 
 }

Java代码

public class RunDemoMain {
public static void main(String[] args) {
List<DataBean> dataBeans = new ArrayList<DataBean>();
dataBeans.add(new DataBean(23, "b", "w"));
dataBeans.add(new DataBean(34, "e", "w"));
dataBeans.add(new DataBean(12, "s", "w"));
dataBeans.add(new DataBean(10, "c", "w"));
System.out.println("==========排序前==========");
for (DataBean bean : dataBeans) {
System.out.println(bean);
}
System.out.println("==========排序后==========");
Collections.sort(dataBeans, new DemoComparator());
for (DataBean bean : dataBeans) {
System.out.println(bean);
}
}
}

 public class RunDemoMain {  
   
     public static void main(String[] args) {  
         List<DataBean> dataBeans = new ArrayList<DataBean>();  
         dataBeans.add(new DataBean(23, "b", "w"));  
         dataBeans.add(new DataBean(34, "e", "w"));  
         dataBeans.add(new DataBean(12, "s", "w"));  
         dataBeans.add(new DataBean(10, "c", "w"));  
 
   
         System.out.println("==========排序前==========");  
         for (DataBean bean : dataBeans) {  
             System.out.println(bean);  
         }  
       
         System.out.println("==========排序后==========");  

         Collections.sort(dataBeans, new DemoComparator());  
   
         for (DataBean bean : dataBeans) {  
             System.out.println(bean);  
         }  
     }  
 }

参考：

http://kentkwan.iteye.com/blog/739505

http://baomw.iteye.com/blog/197905

实际项目应用：

Java代码

if(hotelForm.get("ascOrDesc").equals("ASC")){
Collections.sort(list, new MyComparator.HotelComparator());
}else{
Collections.sort(list, new MyComparator.HotelComparator());
Collections.reverse(list);
}

if(hotelForm.get("ascOrDesc").equals("ASC")){
						Collections.sort(list, new MyComparator.HotelComparator());
					}else{
						Collections.sort(list, new MyComparator.HotelComparator());
						Collections.reverse(list);
					}

Java代码

public class MyComparator {
public static class HotelComparator implements Comparator {
public int compare(Object first, Object second) {
return ((Hotel)first).getHotelNameEn().compareToIgnoreCase(((Hotel)second).getHotelNameEn());
}
}
}

public class MyComparator {
    public static class HotelComparator implements Comparator {
    	public int compare(Object first, Object second) {
    		return ((Hotel)first).getHotelNameEn().compareToIgnoreCase(((Hotel)second).getHotelNameEn());
    	}
    }

}

...

ewili

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Compareable接口和Comparator

需求：做一个对象排序的功能，需要按不同规则排序 Compareable接口和Comparator接口都是用来实现集合排序的，只是Comparable是在集合内部定义的方法实现的排序，而Comparator是在集合外部实现的排序，所以，如想实现排序，就需在集合外定义Comparator接口的方法或在集合内实现Compareable接口的方法。Compara
复制链接

扫一扫