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