在java开发中，我们经常会遇到一些问题需要对数据进行排序处理，那么在list集合的使用中，怎样根据集合中的对象的某个参数为参照进行集合的排序呢？
今天为大家分享一个比较愚笨的排序方式：
每个list集合的数据都会是一个类对象，在每个类对象中都会有若干个变量存在。那么我们就以对象中的变量为参照，进行排序。
首先，将需要参照的类变量取出，存放在一个可以进行元素大小比较的数组中，这里我用到long数组。请参考代码：
ArrayList<Order> orders = new ArrayList<Order>();
long[] condition = new long[orders.size()];
for (int i = 0; i < orders.size(); i++) {
condition[i] = orders.get(i).getStartTime().getTime();
}
SortAlgorithmUtil.selectSort(orders, condition, "asc");
SortAlgorithmUtil.exchangeSort(orders, condition, "asc");
SortAlgorithmUtil.insertSort(orders, condition, "asc");然后，创建一个排序种类的工具类（重点）。请参照代码：
package com.example.listdelectdemo;
import java.util.List;
/**
* 排序算法类 作者：小明的码路
*
* @author warmdoc_ANDROID_001
*
*/
public class SortAlgorithmUtil {
/**
* 交换排序法/冒泡排序法 ：对相邻两元素进行比较、进行交换，嵌套for每次循环依据条件数组将最大元素往后移动，下一次循环将剩余元素进行类似操作。
* 适用：初始状态基本有序，不需要进行反复元素交换
*
* @param <E>
* list中的泛型实体对象
*
* @param rawDatas
* 进行排序的数据集合
* @param condition
* 要排序的条件，来自数据集合的每一个对象代表
* @param sortType
* 排序类型 正序/倒序
*/
public static <E> void exchangeSort(List<E> rawDatas, long[] condition, String sortType) {
if (sortType.equals("asc")) { // 正序
for (int i = 1; i < condition.length; i++) {
// 比较条件数组中相邻的两个元素，较大的数往后移动
for (int j = 0; j < condition.length - i; j++) {
if (condition[j] > condition[j + 1]) {
// 交换相邻两个元素的位置
swapElement(rawDatas, condition, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { // 倒序
for (int i = 1; i < condition.length; i++) {
// 比较条件数组中相邻的两个元素，较小的数往后移动
for (int j = 0; j < condition.length - i; j++) {
if (condition[j] < condition[j + 1]) {
// 交换相邻两个元素的位置
swapElement(rawDatas, condition, j, j + 1);
}
}
}
}
}
/**
* 选择排序法/直接排序法 ：嵌套for每次循环依据排序条件从待排序的数组元素中选出最小或最大的一个元素，并依次排列组合。
* 特点：交换次数比冒泡排序少，速度较冒泡排序高
*
* @param <E>
* list中的泛型实体对象
*
* @param rawDatas
* 进行排序的数据集合
* @param condition
* 要排序的条件，来自数据集合的每一个对象代表
* @param sortType
* 排序类型 正序/倒序
*/
public static <E> void selectSort(List<E> rawDatas, long[] condition, String sortType) {
if (sortType.equals("asc")) {
int record;
for (int i = 1; i < condition.length; i++) {
record = 0;
for (int j = 1; j <= condition.length - i; j++) {
if (condition[j] > condition[record]) {
record = j;
}
}
// 交换condition.length - i和当前最小元素
swapElement(rawDatas, condition, condition.length - i, record);
}
} else if (sortType.equals("desc")) {
int record;
for (int i = 1; i < condition.length; i++) {
record = 0;
for (int j = 1; j <= condition.length - i; j++) {
if (condition[j] < condition[record]) {
record = j;
}
}
// 交换condition.length - i和当前最小元素
swapElement(rawDatas, condition, condition.length - i, record);
}
}
}
/**
* 插入排序法 ：嵌套for每次循环将新增的一项元素与已处理的元素进行依次比较并排在适当位置，每次将生成一个新的有序数组
* 特点：性能较好。
* 适用：当记录规模较小时
*
* @param <E>
* list中的泛型实体对象
*
* @param rawDatas
* 进行排序的数据集合
* @param condition
* 要排序的条件，来自数据集合的每一个对象代表
* @param sortType
* 排序类型 正序/倒序
*/
public static <E> void insertSort(List<E> rawDatas, long[] condition, String sortType) {
if (sortType.equals("asc")) {
for (int i = 1; i < condition.length; i++) {
for (int j = 0; j < i; j++) {
if (condition[j] > condition[i]) {
// 交换x和y两个元素
swapElement(rawDatas, condition, i, j);
}
}
}
} else if (sortType.equals("desc")) {
for (int i = 1; i < condition.length; i++) {
for (int j = 0; j < i; j++) {
if (condition[j] < condition[i]) {
// 交换x和y两个元素
swapElement(rawDatas, condition, i, j);
}
}
}
}
}
/**
* 交换指定元素的位置
*
* @param <E>
* @param rawDatas
* @param condition
* @param x
* @param y
*/
private static <E> void swapElement(List<E> rawDatas, long[] condition, int x, int y) {
long tempC = condition[x];
condition[x] = condition[y];
condition[y] = tempC;
if (rawDatas != null) {
E temp = rawDatas.get(x);
rawDatas.set(x, rawDatas.get(y));
rawDatas.set(y, temp);
}
}
}最后，使用或者打印最初创建的list集合，将实现排序效果。
本人技术水平较一般，代码中有不足之处望指教。谢谢！
本文出自 “小明的码路” 博客，请务必保留此出处http://798056674.blog.51cto.com/9862415/1701095
原文：http://798056674.blog.51cto.com/9862415/1701095