通过js的可以：
创新互联公司专注于东兰企业网站建设,自适应网站建设,成都做商城网站。东兰网站建设公司,为东兰等地区提供建站服务。全流程定制网站开发，专业设计，全程项目跟踪，创新互联公司专业和态度为您提供的服务
var dateRE = /^(\d{2})[\/\- ](\d{2})[\/\- ](\d{4})/;
function dmyOrdA(a, b){
a = a.replace(dateRE,"$3$2$1");
b = b.replace(dateRE,"$3$2$1");
if (ab) return 1;
if (a b) return -1;
return 0; }
function dmyOrdD(a, b){
a = a.replace(dateRE,"$3$2$1");
b = b.replace(dateRE,"$3$2$1");
if (ab) return -1;
if (a b) return 1;
return 0; }
function mdyOrdA(a, b){
a = a.replace(dateRE,"$3$1$2");
b = b.replace(dateRE,"$3$1$2");
if (ab) return 1;
if (a b) return -1;
return 0; }
function mdyOrdD(a, b){
a = a.replace(dateRE,"$3$1$2");
b = b.replace(dateRE,"$3$1$2");
if (ab) return -1;
if (a b) return 1;
return 0; }
测试：
dateArray = new Array('15/10/2000','28/05/1999',
'17/09/2005','06/12/2004','02/01/1998');
dateArray.sort( dmyOrdA );
document.write('Ascending : ' + dateArray + 'br /');
前提，假设你使用一个数组来保存一组开始时间+结束时间，当然，你也可以用其它的数据结构。
基本思路，1转换为Date型，2使用Calendar类来比较两个日期，3 自己实现compare方法：
各部分的例子：
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
Date startDate1 = simpleDateFormat.parse("2018年3月18日");
Date startDate2 = simpleDateFormat.parse("2018年3月12日");
private void sort(ListDate dataList){
Collections.sort(dataList, new ComparatorDate() {
@Override
public int compare(Date o1, Date o2) {
if(d1 != null d2 != null){
Calendar c1 = Calendar.getInstance();
Calendar c2 = Calendar.getInstance();
c1.setTime(o1);
c2.setTime(o2);
return c1.After(c2);
}else{
return -1;
}
}
});
}
大概写了下,具体你自己调调，还要注意异常处理。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestExp {
public static void main(String[] args) {
ListMapString,Object rs = new ArrayListMapString,Object();
//假定日期字符串的格式为yyyy-MM-dd
String[] s = {"adfkjaskdfakf2012-11-23asdfasdfads",
"asdfasddfafll2011-12-03asdfasfdaa",
"asdfasddfafll2013-02-05asdfasfdaa",
"asdfasddfafll2013-01-03asdfasfdaa"};
//用正则表达式匹配日期字符串
Pattern pattern = Pattern.compile("(\\d{4})(-)(\\d{2})(-)(\\d{2})");
for (int i = 0; i s.length; i++) {
MapString,Object map = new HashMapString, Object();
Date date = null;
Matcher m = pattern.matcher(s[i]);
if(m.find()){
try {
date = new SimpleDateFormat("yyyy-MM-dd").parse(m.group());
} catch (ParseException e) {
e.printStackTrace();
}
}
map.put("date", date);
map.put("value", s[i]);
rs.add(map);
}
//用冒泡法排序
for (int i = 0; i rs.size(); i++) {
for (int j = i; j rs.size(); j++) {
if(((Date)rs.get(i).get("date")).after((Date)rs.get(j).get("date"))){
MapString,Object tmp = rs.set(i, rs.get(j));
rs.set(j, tmp);
}
}
}
for (int i = 0; i rs.size(); i++) {
System.out.println(rs.get(i).get("value"));
}
}
}
排序么?
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
public class Test {
public static void main(String args[]) {
System.out.println("字符串比较");
test1();
System.out.println("Date比较");
test2();
}
private static void test1() {
ListString data = init();
System.out.println("排序前" + data);
Collections.sort(data, new ComparatorString() {
public int compare(String o1, String o2) {
String[] arr1 = o1.split("_");
String[] arr2 = o2.split("_");
int comparator = toInt(arr1[0], -1) - toInt(arr2[0], -2);
if (comparator == 0) {
comparator = toInt(arr1[1], -1) - toInt(arr2[1], -2);
if (comparator == 0) {
return toInt(arr1[2], -1) - toInt(arr2[2], -2);
}
}
return comparator;
}
});
System.out.println("排序后" + data);
}
private static void test2() {
ListString data = init();
System.out.println("排序前" + data);
final Format f = new SimpleDateFormat("yyyy-MM-dd");
Collections.sort(data, new ComparatorString() {
public int compare(String o1, String o2) {
Date d1;
Date d2;
try {
d1 = (Date) f.parseObject(o1);
d2 = (Date) f.parseObject(o2);
return d1.compareTo(d2);
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
});
System.out.println("排序后" + data);
}
private static ListString init() {
ListString data = new ArrayListString();
data.add("2013-3-3");
data.add("2012-4-4");
return data;
}
private static int toInt(String str, int delVal) {
try {
return Integer.parseInt(str);
} catch (Exception e) {
return delVal;
}
}
}
字符串比较
排序前[2013-3-3, 2012-4-4]
排序后[2012-4-4, 2013-3-3]
Date比较
排序前[2013-3-3, 2012-4-4]
排序后[2012-4-4, 2013-3-3]
给你介绍4种排序方法及源码，供参考
1.冒泡排序
主要思路： 从前往后依次交换两个相邻的元素，大的交换到后面，这样每次大的数据就到后面，每一次遍历，最大的数据到达最后面，时间复杂度是O(n^2)。
public static void bubbleSort(int[] arr){
for(int i =0; i arr.length - 1; i++){
for(int j=0; j arr.length-1; j++){
if(arr[j] arr[j+1]){
arr[j] = arr[j]^arr[j+1];
arr[j+1] = arr[j]^arr[j+1];
arr[j] = arr[j]^arr[j+1];
}
}
}
}
2.选择排序
主要思路：每次遍历序列，从中选取最小的元素放到最前面，n次选择后，前面就都是最小元素的排列了，时间复杂度是O(n^2）。
public static void selectSort(int[] arr){
for(int i = 0; i arr.length -1; i++){
for(int j = i+1; j arr.length; j++){
if(arr[j] arr[i]){
arr[j] = arr[j]^arr[i];
arr[i] = arr[j]^arr[i];
arr[j] = arr[j]^arr[i];
}
}
}
}
3.插入排序
主要思路：使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置，时间复杂度是O(n^2）。
public static void insertionSort(int[] arr){
int j;
for(int p = 1; p arr.length; p++){
int temp = arr[p]; //保存要插入的数据
//将无序中的数和前面有序的数据相比，将比它大的数，向后移动
for(j=p; j0 temp arr[j-1]; j--){
arr[j] = arr[j-1];
}
//正确的位置设置成保存的数据
arr[j] = temp;
}
}
4.希尔排序
主要思路：用步长分组，每个分组进行插入排序，再慢慢减小步长，当步长为1的时候完成一次插入排序， 希尔排序的时间复杂度是：O（nlogn）～O（n2），平均时间复杂度大致是O(n^1.5)
public static void shellSort(int[] arr){
int j ;
for(int gap = arr.length/2; gap 0 ; gap/=2){
for(int i = gap; i arr.length; i++){
int temp = arr[i];
for(j = i; j=gap temparr[j-gap]; j-=gap){
arr[j] = arr[j-gap];
}
arr[j] = temp;
}
}
}
