`

对象排序：Comparator与Comparable的区别

JavaSQL算法数据结构Bean 
阅读更多

    当集合中存储的都是对象时，我们要对其进行排序，就要借助于Comparator或Comparable，以简单的方式实现对象排序或自定义排序。

例子：一个对象类：

Java代码 复制代码
  1. public class UserPo  {   
  2.     // 名字   
  3.     private String name;   
  4.     // 年龄   
  5.     private int age;   
  6.   
  7.     public String getName() {   
  8.         return name;   
  9.     }   
  10.   
  11.     public void setName(String name) {   
  12.         this.name = name;   
  13.     }   
  14.   
  15.     public int getAge() {   
  16.         return age;   
  17.     }   
  18.   
  19.     public void setAge(int age) {   
  20.         this.age = age;   
  21.     }   
  22.   
  23. }  
public class UserPo  {
	// 名字
	private String name;
	// 年龄
	private int age;

	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;
	}

}

 

1：使用Comparator接口实现排序：实现其compare方法，根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数来判断大小。
     强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

Java代码 复制代码
  1. import java.util.Comparator;   
  2.   
  3. public class MyCompare implements Comparator<Object>{   
  4.        
  5.     public int compare(Object o0, Object o1) {   
  6.         UserPo user0 = (UserPo) o0;   
  7.         UserPo user1 = (UserPo) o1;   
  8.         if (user0.getAge() > user1.getAge()) {   
  9.             return 1; // 第一个大于第二个   
  10.         } else if (user0.getAge() < user1.getAge()) {   
  11.             return -1;// 第一个小于第二个   
  12.         } else {   
  13.             return 0; // 等于   
  14.         }   
  15.     }   
  16. }  
import java.util.Comparator;

public class MyCompare implements Comparator<Object>{
	
	public int compare(Object o0, Object o1) {
		UserPo user0 = (UserPo) o0;
		UserPo user1 = (UserPo) o1;
		if (user0.getAge() > user1.getAge()) {
			return 1; // 第一个大于第二个
		} else if (user0.getAge() < user1.getAge()) {
			return -1;// 第一个小于第二个
		} else {
			return 0; // 等于
		}
	}
}

 

测试代码：

Java代码 复制代码
  1. import java.util.ArrayList;   
  2. import java.util.Collections;   
  3.   
  4. public class Test {   
  5.   
  6.     public static void main(String args[]){   
  7.            
  8.         String sql="select name,age from users";   
  9.         // 从数据库中得到数据并组装对象集合   
  10.         ArrayList<UserPo> array =BaseDao.getyAll(sql);   
  11.         MyCompare comp = new MyCompare();   
  12.         // 执行排序方法   
  13.         Collections.sort(array,comp);   
  14.         for(UserPo p:array) {   
  15.             System.out.println(p.getName()+":"+p.getAge());   
  16.         }   
  17.            
  18.     }   
  19. }  
import java.util.ArrayList;
import java.util.Collections;

public class Test {

	public static void main(String args[]){
		
		String sql="select name,age from users";
        // 从数据库中得到数据并组装对象集合
		ArrayList<UserPo> array =BaseDao.getyAll(sql);
		MyCompare comp = new MyCompare();
        // 执行排序方法
		Collections.sort(array,comp);
		for(UserPo p:array) {
			System.out.println(p.getName()+":"+p.getAge());
		}
		
	}
}

 

getAll()方法:

Java代码 复制代码
  1. public static ArrayList<UserPo> getyAll(String sql) {   
  2.         ArrayList<UserPo> list = new ArrayList<UserPo>();    
  3.         ResultSet rs = null;   
  4.         PreparedStatement ps = null;   
  5.         try {   
  6.             Connection con = JdbcUtils.getMsConnection();   
  7.             ps = con.prepareStatement(sql);   
  8.             rs = ps.executeQuery();   
  9.             while (rs.next()) {   
  10.                 UserPo p = new UserPo();   
  11.                 p.setName(rs.getString("name"));   
  12.                 p.setAge(rs.getInt("age"));   
  13.                 list.add(p);   
  14.             }   
  15.         } catch (Exception e) {   
  16.             e.printStackTrace();   
  17.         }   
  18.         return list;   
  19.       
public static ArrayList<UserPo> getyAll(String sql) {
        ArrayList<UserPo> list = new ArrayList<UserPo>(); 
        ResultSet rs = null;
        PreparedStatement ps = null;
        try {
            Connection con = JdbcUtils.getMsConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
            	UserPo p = new UserPo();
            	p.setName(rs.getString("name"));
                p.setAge(rs.getInt("age"));
                list.add(p);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;

 

2:使用Comparable接口完成排序：实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

 

对UserPo类进行改装

Java代码 复制代码
  1. import java.util.ArrayList;   
  2. import java.util.Collections;   
  3. public class UserPo implements Comparable  {   
  4.        
  5.     private String name;   
  6.        
  7.     private int age;   
  8.   
  9.     public String getName() {   
  10.         return name;   
  11.     }   
  12.   
  13.     public void setName(String name) {   
  14.         this.name = name;   
  15.     }   
  16.   
  17.     public int getAge() {   
  18.         return age;   
  19.     }   
  20.   
  21.     public void setAge(int age) {   
  22.         this.age = age;   
  23.     }   
  24.     /**  
  25.      * compareTo  
  26.      */  
  27.     public int compareTo(Object o) {   
  28.         return this.age-((UserPo)o).getAge();   
  29.     }   
  30.     // 测试   
  31.     public static void main(String args[]){   
  32.         String sql="select name,age from users";   
  33.         ArrayList<UserPo> array =BaseDao.getyAll(sql);   
  34.         // 执行排序方法   
  35.         Collections.sort(array);   
  36.         for(UserPo p:array) {   
  37.             System.out.println(p.getName()+":"+p.getAge());   
  38.         }   
  39.     }   
  40. }  
import java.util.ArrayList;
import java.util.Collections;
public class UserPo implements Comparable  {
	
	private String name;
	
	private int age;

	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;
	}
    /**
     * compareTo
     */
	public int compareTo(Object o) {
		return this.age-((UserPo)o).getAge();
	}
    // 测试
	public static void main(String args[]){
		String sql="select name,age from users";
		ArrayList<UserPo> array =BaseDao.getyAll(sql);
		// 执行排序方法
		Collections.sort(array);
		for(UserPo p:array) {
			System.out.println(p.getName()+":"+p.getAge());
		}
	}
}

 

这两个接口的比较：
1：java.lang.Comparable是在集合内部定义的方法实现的排序，java.util.Comparator是在集合外部实现的排序
2：一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。一般我们写的bean都要实现这一接口，这也是标准javabean的规范。
3：Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
     1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
     2、可以使用多种排序标准，比如升序、降序等。

4：java.lang.Comparable接口中实现的方法是：int compareTo(T o)，比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

     java.util.Compatator接口中实现的方法是：int compare(T o1, T o2)，比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

 

参考：http://www.iteye.com/topic/503812

分享到：
| Struts框架结构分析
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Compable和Comparator自定义对象属性排序

    可以通过两种方式自定义对象的属性大小进行比较,对一个list或数组对根据属性排序一个list或数组

    JAVA集合的使用(List、Map、Set、Queue,Collections、Comparable与Comparator,排序、搜索,内部类、equals、hashCode)

    要注意的是List,Set,Queue继承了Collection接口，...这里想用一个简单的例子展示一下他们的使用，内容包括：List、Map、Set、Queue,Collections、Comparable与Comparator,排序、搜索,内部类,泛型、重写equals、hashCode

    对比Java中的Comparable排序接口和Comparator比较器接口

    Comparable和Comparator接口都可用作普通意义上对象间的比大小,但两个接口在实例化方面的用法不尽相同,接下来我们就来详细对比Java中的Comparable排序接口和Comparator比较器接口

    Comparable接口和Comparator接口的比较

    实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。 此外，实现此接口的对象可以用作有序映射中的键或有序集合中的集合，无需指定比较器。 此 接口只有一个方法...

    java实现别踩白块儿源码-SortedList:用Java编写的SortedList的实现。可以与实现Comparable接口的对象一起使用

    它是使用Comparator对象构造的，该对象可以将两个对象进行比较，从而使SortedList可以将其元素按升序或降序排序。 当且仅当要使用的对象实现Comparable接口时，我们也可以创建不带Comparator对象的SortedList。 用法...

    Java开发详解.zip

    031113_【第11章：Java常用类库】_比较器（Comparable、Comparator）笔记.pdf 031114_【第11章：Java常用类库】_观察者设计模式笔记.pdf 031115_【第11章：Java常用类库】_正则表达式笔记.pdf 031116_【第11章：Java...

    Java基础知识点.html

    哈希值 LinkedHashSet TreeSet 自然排序Comparable 比较器排序Comparator Set集合 并发修改异常 LinkedList集合 ArrayList集合 List集合 Collection集合概述 冒泡排序 Object 异常 Math 包装类 Calendar类 ...

    Guava 16.0 API (CHM格式)

    排序： Guava 强大的 "fluent Comparator"比较器， 提供多关键字排序。 　5. Throwable类： 简化了异常检查和错误传播。 　二. 集合类：集合类库是 Guava 对 JDK 集合类的扩展， 这是 Guava 项目最完善和为人所知...

    java常用工具类的使用

    格式化的目的是把一个对象以不同的格式表示，以满足不同环境对格式的要求，比如：前面学习的Date对象实质是一个以毫秒值表示的时间，但是在不同的国家和地区表示方式不一样。那么就需要对Date进行格式化处理。接下来...

    AIC的Java课程1-6章

     知道实现比较器(Comparable，Comparator)用于排序算法(多态性)。  [*]了解同步包装和不可修改包装。 第12章 IO与串行化 2课时  了解Java IO 中类的层次结构，介绍Java IO采用的装饰...

    Java学习笔记-个人整理的

    {4.9}Comparable与Comparator}{86}{section.4.9} {4.9.1}Comparable}{86}{subsection.4.9.1} {4.9.2}Comparator}{87}{subsection.4.9.2} {4.10}包装类}{87}{section.4.10} {4.11}集合的复制}{88}{section.4.11}...

Magicbox
Global site tag (gtag.js) - Google Analytics