java实现按照自定义对象的某个属性排序

package com;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Sort {
 public Sort() { }
 public static void main(String[] args) {
  List<User> list = new ArrayList<User> ();
  User u1 = new User("a",21,0);
  User u2 = new User("b",21,2);
  User u3 = new User("c",21,4);
  User u4 = new User("d",21,1);
  User u5 = new User("e",21,3);
  list.add(u1);
  list.add(u2);
  list.add(u3);
  list.add(u4);
  list.add(u5);
  int len = list.size();
  System.out.println("排序前：");
  for(int i=0;i<len;i++){
   User u = list.get(i);
   System.out.print(u.getOrder()+" ");
  }
  //Collections.sort(list,new UserCompator());   //Collections类的的静态sort方法,传递一个compator对象
  Collections.sort(list);
  //实现倒叙
  System.out.println("\n排序后：");
  for(int i=0;i<len;i++){
   User u = list.get(i);
   System.out.print(u.getOrder()+" ");
  }
  //实现倒叙
  Collections.reverse(list);//Collections类的静态reverse方法
  System.out.println("\n倒叙后：");
  for(int i=0;i<len;i++){
   User u = list.get(i);
   System.out.print(u.getOrder()+" ");
  }
 }
}

 

//模拟用户类
//J2EE项目的bean最好都实现可序列化
/*序列化得作用：什么叫序列化?通俗点...就是对你的对象添加一个序列号作为标识(对应内存中相对应的对象),然后流化,
当反序列化的时候,把该对象恢复到内存,如果该对象的序列号和内存中的对象相对应,则恢复到内存中的对象,
否则的化,直接创建一个对象到内存

 * */
class User implements Serializable, Comparable<User>{   // Comparable<User>规定，当前的compate方法的参数必须是User
 private static final long serialVersionUID = 2802777044952669007L;
 private String Name;
 private int Age;
 private int Order;//排序的属性
 
 public User(){}; //无参构造
 //构造
 public User(String name,int age,int order){
  this.Name = name;
  this.Age = age;
  this.Order = order;
 }
 
 public int getOrder() {
  return Order;
 }
 public void setOrder(int order) {
  Order = order;
 }
 public String getName() {
  return Name;
 }
 public void setName(String name) {
  Name = name;
 }
 public int getAge() {
  return Age;
 }
 public void setAge(int age) {
  Age = age;
 }
 //必须重写的方法，而且参数必须是User，声明类的时候已经规定。
    public int compareTo(User u ) {
       return this.Order-u.getOrder();
    }  
}
//自定义的compator类，在Collections排序的时候使用（也可以不使用用）
class UserCompator implements Comparator<User>{

 public int compare(User o1, User o2) {
  return o1.getOrder()-o2.getOrder();
 }
}
结果：

排序前：
0 2 4 1 3
排序后：
0 1 2 3 4
倒叙后：
4 3 2 1 0