list中时间排序

最初设想使用:时间long型

    private void testTimes() throws InterruptedException{
        Calendar cal=Calendar.getInstance();
        cal.add(Calendar.DATE, 1);
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        Long time1=cal.getTimeInMillis();

        Calendar ca2=Calendar.getInstance();
        ca2.add(Calendar.DATE, 1);
        ca2.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);

        Long time2=ca2.getTimeInMillis();

        System.out.println(time1+"--"+time2);
    }

发现整型可能不一致,即有时候一致,有时候不一致。

经测算发现,Collections提供了排序功能:

private void testSort(){
        List<Calendar> cals=new ArrayList<Calendar>();

        Calendar cal3=Calendar.getInstance();
        cal3.add(Calendar.DATE, 2);
        cal3.set(cal3.get(Calendar.YEAR), cal3.get(Calendar.MONTH), cal3.get(Calendar.DAY_OF_MONTH), 0, 0, 0);

        Calendar cal4=Calendar.getInstance();
        cal4.add(Calendar.DATE, 2);
        cal4.set(cal4.get(Calendar.YEAR), cal4.get(Calendar.MONTH), cal4.get(Calendar.DAY_OF_MONTH), 0, 0, 0);

        Calendar cal1=Calendar.getInstance();
        cal1.add(Calendar.DATE, 2);
        cal1.set(cal1.get(Calendar.YEAR), cal1.get(Calendar.MONTH), cal1.get(Calendar.DAY_OF_MONTH), 0, 0, 2);

        Calendar cal2=Calendar.getInstance();
        cal2.add(Calendar.DATE, 2);
        cal2.set(cal2.get(Calendar.YEAR), cal2.get(Calendar.MONTH), cal2.get(Calendar.DAY_OF_MONTH), 0, 0, 0);

        cals.add(cal3);
        cals.add(cal4);
        cals.add(cal1);
        cals.add(cal2);

        Calendar minTime=Collections.min(cals);

        System.out.println(DateUtils.formatDate(Collections.min(cals).getTime(),"yyyy-MM-dd HH:mm:ss"));

        for(int i=0;i<cals.size();i++){
            if(DateUtils.defaultFormatDate(minTime.getTime()).equals(DateUtils.defaultFormatDate(cals.get(i).getTime()))){
                System.out.println(DateUtils.formatDate(cals.get(i).getTime(),"yyyy-MM-dd HH:mm:ss"));
            }
        }
        /*        for(int i=0;i<cals.size();i++){
            System.out.println(DateUtils.formatDate(cals.get(i).getTime(),"yyyy-MM-dd HH:mm:ss"));
        }

        Collections.sort(cals);

        //排序后
        for(int i=0;i<cals.size();i++){
            System.out.println(DateUtils.formatDate(cals.get(i).getTime(),"yyyy-MM-dd HH:mm:ss"));
        }*/
    }
时间: 2024-10-26 01:24:28

list中时间排序的相关文章

C#实现对指定文件夹中文件按修改时间排序

string path = "~/Document/Introduction/团队管理制度/";            DirectoryInfo dirinfo = new DirectoryInfo(Server.MapPath(path));            FileInfo[] Files = dirinfo.GetFiles();            Array.Sort<FileInfo>(Files, new FIleLastTimeComparer(

数据库表分组后按时间排序,取每个分组中最近的一条记录

数据库表分组后按时间排序,取每个分组中最近的一条记录.在网上找了好几个,都不行,最终找到了解决办法,Oracle亲测可以. with m as (select id,max(times) c from test_max group by id)select n.id,n.duowei from test_max n join m on m.id=n.id and m.c=n.times 第一次在博客园写知识,愿意和大家分享.

将集合中的内容按时间排序

/** * 将集合中的内容按时间排序 * @param list */ private static void ListSort(List<BossMsgInfo> list) { Collections.sort(list, new Comparator<BossMsgInfo>() { public int compare(BossMsgInfo o1, BossMsgInfo o2) { SimpleDateFormat format = new SimpleDateForm

排序算法(4)-线性时间排序

在前面三节排序算法中,我们分别分析了不同策略,思想用于排序,而这些算法都是基于数据间的比较来确定顺序的.假设我不用比较,换一种思路,那么就可以达到时间复杂度为O(n)的排序算法,当然是以付出额外的空间为代价的. 一.基本思想 线性时间排序的算法思想: (1):在计数排序中,利用比x小或等的元素个数和的来确定x位置.比如2 5 4 9 1 6.9比其余5个数都大,那就说明9 在排序后的第6个位置,这样我们只要得到比某个数大的元素个数就能得到元素在排序后数组中的位置了. (2):在桶排序中,是通过映

STL笔记(6)标准库:标准库中的排序算法

STL笔记(6)标准库:标准库中的排序算法 标准库:标准库中的排序算法The Standard Librarian: Sorting in the Standard Library Matthew Austern http://www.cuj.com/experts/1908/austern.htm?topic=experts 用泛型算法进行排序    C++标准24章有一个小节叫“Sorting and related operations”.它包含了很多对已序区间进行的操作,和三个排序用泛型

Mysql中的排序规则utf8_unicode_ci、utf8_general_ci的区别总结

Mysql中的排序规则utf8_unicode_ci.utf8_general_ci的区别总结 用了这么长时间,发现自己竟然不知道utf_bin和utf_general_ci这两者到底有什么区别.. ci是 case insensitive, 即 "大小写不敏感", a 和 A 会在字符判断中会被当做一样的; bin 是二进制, a 和 A 会别区别对待. 例如你运行: SELECT * FROM table WHERE txt = 'a' 那么在utf8_bin中你就找不到 txt

算法导论 第八章 线性时间排序(python)

比较排序:各元素的次序依赖于它们之间的比较{插入排序O(n**2) 归并排序O(nlgn) 堆排序O(nlgn)快速排序O(n**2)平均O(nlgn)} 本章主要介绍几个线性时间排序:(运算排序非比较排序)计数排序O(k+n)基数排序O() 第一节:用决策树分析比较排序的下界 决策树:倒数第二层满,第一层可能满的二叉树,它用来表示所有元素的比较操作{于此来分析下界},忽略控制,移动操作 1:2 #A[1]和A[2]比 <= 走左边 >走右边 <3,1,2> 最后的结果 下标对应排

【经典算法】线性时间排序

在计算机科学中,排序是一门基础的算法技术,许多算法都要以此作为基础,不同的排序算法有着不同的时间开销和空间开销.排序算法有非常多种,如我们最常用的快速排序和堆排序等算法,这些算法需要对序列中的数据进行比较,因为被称为基于比较的排序. 基于比较的排序算法是不能突破O(NlogN)的.简单证明如下: N个数有N!个可能的排列情况,也就是说基于比较的排序算法的判定树有N!个叶子结点,比较次数至少为log(N!)=O(NlogN)(斯特林公式). 而非基于比较的排序,如计数排序,桶排序,和在此基础上的基

算法导论 第8章 线性时间排序

合并排序和堆排序的时间复杂度为O(nlgn),插入排序和冒泡排序的时间复杂度为O(n^2),快速排序的时间复杂度在平均情况下是O(nlgn),这些排序算法都是通过对元素进行相互比较从而确定顺序的,因此都叫比较排序. 比较排序可以看做是决策树(一个满二叉树),因为每一次比较都是一个分支.n个元素的序列,其排序的结果有 n! 种可能(n个元素的全排),所以这个决策树有 n! 个叶子结点,假设树的高度为h,则有:n! <= 2^h,所以h >= lg(n!) = Ω(nlgn).一次比较排序就是从决