一个list排序问题

Question

一个list里面存的是一个类order
order类里面有个age变量 
要求根据age变量排序list

Answer 1

重写order的equals然后list调用contains

Answer 2

写错了
应该是order实现Comparator接口，然后Collections.sort(List<T> list, Comparator<? super T> c) 

Answer 3

。。
API
API
API
API
API
API

Answer 4

/**
 * 实现排序接口的Order类，排序接口也可以在其他类实现
 */
public class Order implements Comparator<Order> {
private int age; /**
 * @param age
 */
public Order(int age) {
super();
this.age = age;
} /* (non-Javadoc)
 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 */
@Override
public int compare(Order o1, Order o2) {
//以下是顺序排序，需要逆序，可以在o1.age>o2.age的情况下返回-1
//同理o1.age < o2.age 返回1
if(o1.age == o2.age)
return 0;
else if(o1.age > o2.age)
return 1;
else if(o1.age < o2.age)
return -1;
return -1;
}

@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Order [age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
}
public static void main(String[] args) {
//构造被排序的数组
List<Order> list = new ArrayList<Order>();
list.add(new Order(0));
list.add(new Order(3));
list.add(new Order(-10));
list.add(new Order(100));
list.add(new Order(9));
list.add(new Order(7));

//排序接口实现类，这里因为我把排序接口实现在了Order类
//这里就实例化Order类，也可以是其他类
Order o = new Order(0);
Collections.sort(list,o);

for(Order item : list){
System.out.println(item.toString());
}
}

Answer 5

这里还有一个方法 package com.keeya.Test;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;public class Test {
public static void main(String[] args) throws Exception{
List<Employee> employees = new ArrayList<Employee>();

employees.add(new Employee("Andy", 21, 2000));
employees.add(new Employee("Felix", 21, 3000));
employees.add(new Employee("Bill", 35, 20000));
employees.add(new Employee("Helen", 21, 10000));
employees.add(new Employee("Cindy", 28, 8000));
employees.add(new Employee("Douglas", 25, 5000)); // 按名称排序
Collections.sort(employees, new NameComparator());
display(employees); // 按年龄排序
Collections.sort(employees, new AgeComparator());
display(employees); // 按薪水排序
Collections.sort(employees, new SalaryComparator());
display(employees);
} public static void display(List<Employee> employees) {
for (Employee e : employees) {
System.out.println("雇员名=" + e.getName() + " 年龄=" + e.age + " 薪水="
+ e.getSalary());
}
System.out.println();
}
}class Employee {
protected String name; protected int age; protected int salary; public Employee(String name, int age, int salary) {
this.name = name;
this.age = age;
this.salary = salary;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getSalary() {
return salary;
} public void setSalary(int salary) {
this.salary = salary;
}
}class AgeComparator implements Comparator {
public int compare(Object op1, Object op2) {
Employee eOp1 = (Employee) op1;
Employee eOp2 = (Employee) op2; // 按年龄排序
return eOp1.getAge() - (eOp2.getAge());
}
}class NameComparator implements Comparator {
public int compare(Object op1, Object op2) {
Employee eOp1 = (Employee) op1;
Employee eOp2 = (Employee) op2; // 按姓名排序
return eOp1.getName().compareTo(eOp2.getName());
}
}class SalaryComparator implements Comparator {
public int compare(Object op1, Object op2) {
Employee eOp1 = (Employee) op1;
Employee eOp2 = (Employee) op2; // 按薪水排序
return eOp1.getSalary() - (eOp2.getSalary());
}
}

Answer 6

实现Comparable也可以
public class Order implements Comparable<Order> { private int age; public Order(int age){
this.age = age;
}

public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} @Override
public int compareTo(Order o) {
int age1 = o.getAge();
return this.getAge() > age1 ? this.getAge() : age1;
}
}

Answer 7

keeya0416 正解，bean就是bean，加入排序就不纯了，外接排序器更灵活。
其他的也可以，只是设计不够 好，应付这个DEMO足够了