List<Entity>排序：根据javabean中的一个字段对beanList进行排序

问题：项目中可能大家经常遇到List<Entity> 这样的数据结构吧，因为我们经常要查数据库，所得的数据大多都是类似这样的数据结构。

既然是从数据库取数据，排序的问题就应该在sql文中解决了的，可是经常会遇到合并组装过的数据，或者其他来源的数据等等，这时候就需要我们自己再程序中排序了。

知识面：

Collections中sort方法，两种方法：

1，容器内要排序的类必须继承Comparable接口，而Comparable接口就必须实现

int compareTo(T o) 方法。

2，使用静态内部类实现Comparator接口，实现compare(T o1, T o2) 方法。

网上继承Comparable接口的代码如下：

public class Person implements Comparable<Person> {
    private int age ; 
    private String name ; 
  
    public Person( int age, String name) { 
       this . age = age; 
       this . name = name; 
    } 
  
//实现compareTo方法，方法实现的是比较的规则
    public int compareTo(Person person) {  
       int cop = age - person.getAge(); 
       if (cop != 0) 
           return cop; 
       else 
           return name .compareTo(person. name ); 
    } 
  
    public int getAge() { 
       return age ; 
    } 
  
    public String getName() { 
       return name ; 
    } 
  
    public int hashCode() { 
       int result = 17; 
       result = 37 * result + age ; 
       result = 37 * result + name .hashCode(); 
       return result; 
    } 
  
    public boolean equals(Object o) { 
       if (!(o instanceof Person)) 
           return false ; 
       Person person = (Person) o; 
       return ( age == person. age ) && ( name .equals(person. name )); 
    } 
  
    public String toString() { 
       return ( age + "{" + name + "}" ); 
    } 
} 

 

2，网上关于继承Comparator的代码：

import java.util.Comparator;

// 继承Comparator接口后，要实现compare(a,b), 就可以使用Collections.sort()方法，Arrays.sort()方法。
public class StudentComparator implements Comparator<Object> {

	public int compare(Object o1, Object o2) {
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		int result = (s1.id > s2.id) ? 1 : ((s1.id == s2.id) ? 0 : -1);
		if (0 == result) {
			result = s1.name.compareTo(s2.name);
		}
		return result;
	}
}

public class Student {
	int id;
	String name;
	Student(int id, String name) {
		this.id = id;
		this.name = name;
	}
	public String toString() {
		return "id=" + this.id + ",name=" + this.name;
	}
}

还有一个知识点：java的反射机制

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性

一下是我写的一可以进行简单排序的代码：

只是一个雏形，还有很多需要添加的代码，以及更具需求不同可以加上更多的功能。

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class EntitySort<T> implements Comparator<T> {

	public static boolean ASC = true;// 升序
	public static boolean DESC = false;// 降序
	private boolean sortFlg;// 排序升降序flg
	private String sortKey;// 比较的字段
	private List<T> list;//比较的list

	public EntitySort(List<T> list, String sortKey, Boolean sortFlg) {
		this.list = list;
		this.sortKey = sortKey;
		this.sortFlg = sortFlg;
	}

	public EntitySort(List<T> list, String sortKey) {
		this.list = list;
		this.sortKey = sortKey;
	}

	public List<T> sort() {
		Collections.sort(list, this);// 调用Collections.sort方法，第二个参数this，表示使用本class下的compare方法（策略模式？）

		// sorted list
		return this.list;
	}

	// 排序规则实现
	public int compare(T sortOne, T sortTow) {

		StringBuffer methodName = new StringBuffer();
		methodName.append("get");
		methodName.append(sortKey.substring(0, 1).toUpperCase());
		methodName.append(sortKey.substring(1));

		String keyOne = null;
		String keyTow = null;

		try {
			keyOne = (String) sortOne.getClass()
					.getMethod(methodName.toString(), null)
					.invoke(sortOne, null);// 利用反射机制动态取得T下的字段值。

			if (keyOne == null) {
				keyOne = "";
			}
			keyTow = (String) sortOne.getClass()
					.getMethod(methodName.toString(), null)
					.invoke(sortTow, null);

			if (keyTow == null) {
				keyOne = "";
			}
		} catch (Exception e) {

		}

		if (sortFlg) {// 升降序判断
			return keyOne.compareTo(keyTow);
		} else {
			return -(keyOne.compareTo(keyTow));
		}
	}
}