list排序

借助Collections工具类，实现按照日期进行排序 1、日期集合排序 2、包含日期字段类的集合按照日期字段排序 public static void main(String[] args) throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String a = "2019-08-01 08:00:00"; String b = "2019-08-01 18:00:00"; String c = "2019-08-01 15:00:00"; Date d1 = sdf.parse(a); Date d2 = sdf.parse(b); Date d3 = sdf.parse(c); List<Date> list = new ArrayList<>(); list.add(d1); list.add(d2); list.add(d3); Collections.sort(list, new Comparator<Date>() { @Override public int compare(Date o1, Date o2) { return o1.compareTo(o2); } }); System.out.println(list);

原文: http://www.cppblog.com/mzty/archive/2007/03/14/19819.html STL算法学习，小结如下： 前提: 下载stl源码： http://www.sgi.com/tech/stl/download.html 打开网页： http://www.sgi.com/tech/stl/stl_index.html 一 函数对象： 因为很多的算法中多使用了函数对象 二元函数对象，V1和V2为输入，V3为结果 plus<T>: transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),plus<double>()); 其他的二元函数对象：minus,multiples,divieds,modulus. 二元断言函数对象，使用时需要bind2nd（）或bind1st（）来绑定比较对象。 less<T>: find_if(L.begin(), L.end(), bind2nd(less<int>(), 0)); 其他的二元断言函数：equal_to,notequal_to,greater,greater_equal,less_equal,logical_and,logical_or 二元逻辑函数 binary_negate: const char* wptr = find_if(str, str

https://www.cnblogs.com/onepixel/p/7674659.html 0 算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序 ：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序 ：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定 ：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度 ：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度： 是指算法在计算机 内执行时所需存储空间的度量，它也是数据规模n的函数。 1、冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对

排序算法主要包括：冒泡排序、快速排序、希尔排序、插入排序、选择排序、堆排序、归并排序、基数排序、桶排序 （1）.冒泡排序： 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直到排序完成。 　/** * 冒泡排序 * * @param array * @return */ public int[] bubbleSort(int[] array){ if(array.length==0) return array; int temp=0; for(int i=0;i<array.length;i++){ for(int j=0;j<array.length-i;j++){ if (array[j + 1] < array[j]) { temp = array[j + 1]; array[j + 1] = array[j]; array[j] = temp; } } } } （2）.快速排序 　　快速排序的原理：选择一个关键值作为基准值，比基准值小的在左边序列，比基准值大的在右边序列（一般左右都是无序的），一般选择序列的第一个元素。 　　一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的就交换位置

public class UserName implements Comparable<UserName> { String name; int age; public UserName(String name, int age) { super(); this.name = name; this.age = age; } public UserName() { super(); // TODO Auto-generated constructor stub } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int compareTo(UserName o) { UserName userName; return this.age - o.getAge(); } @Override public String toString() { return "UserName [name=" + name + ", age=" + age + "]

行为参数化就是可以帮你处理频繁变更的需求的一种软件开发模式. 一言以蔽之，它意味着拿出一个代码块，把它准备好却不去执行它。这个代码块以后可以被你程序的其他部分调用， 这意味着你可以推迟这块代码的执行。例如，你可以将代码块作为参数传递给另一个方法，稍后 再去执行它。这样，这个方法的行为就基于那块代码被参数化了。 打个比方吧: 你的室友知道怎么开车去超市，再开回家。于是你可 以告诉他去买一些东西，比如面包、奶酪、葡萄酒什么的。这相当于调用一个 goAndBuy 方法，把 购物单作为参数。然而，有一天你在上班，你需要他去做一件他从来没有做过的事情：从邮局取一 个包裹。现在你就需要传递给他一系列指示了：去邮局，使用单号，和工作人员说明情况，取走包 裹。你可以把这些指示用电子邮件发给他，当他收到之后就可以按照指示行事了。你现在做的事情 就更高级一些了，相当于一个方法： go ，它可以接受不同的新行为作为参数，然后去执行. 应对不断变化的需求 编写能够应对变化的需求的代码并不容易。让我们来看一个例子，我们会逐步改进这个例子， 以展示一些让代码更灵活的最佳做法。就农场库存程序而言，你必须实现一个从列表中筛选绿苹 果的功能。听起来很简单吧？ 第一个解决方案可能是下面这样的： /** *筛选绿苹果 * @param inventory 苹果仓库 * @return */ public static

5分钟了解基数排序 前言 基数排序无需进行比较和交换，而是利用分配和收集两种基本操作实现排序。基数排序分为两种：第一种是LSD ，从最低位开始排序；第二种是 MSD， 从最高位开始排序。 。 基数排序思想介绍 分配：对于数字，每位的取值范围是0-9，因此需要10个容器（我们可以将其称为桶），这10个桶标号为0-9。每趟排序时，我们取每一个元素在该位的数值依次放入桶中。 2. 收集：在一趟排序完成后，我们按顺序从0-9的桶中依次取元素。 3. 继续进行分配和收集，直到最大位数排序完成。 算法说明： 待排序数据：12, 34, 2, 123, 25, 59, 37 采用LSD，从低位开始排序 第一轮：取个位数，放入对应的桶，比如12的个位数是2，放到2号桶；34的个位数是4，放到4号桶 0 1 2 12 2 3 123 4 34 5 25 6 7 37 8 9 59 第一轮后，得到数据：12, 2, 123, 34, 25, 37, 59 第二轮：取十位数，放入桶中。比如2，十位数是0，放到0号桶 0 2 1 12 123 2 25 3 34 37 4 5 59 6 7 8 9 第二轮后，得到数据：2, 12, 123, 25, 34, 37, 59 第三轮：取百位数，放入桶 0 2 12 25 34 37 59 1 123 2 3 4 5 6 7 8 9 最后，得到有序数据 2,

算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 算法复杂度 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度：是指算法在计算机 内执行时所需存储空间的度量，它也是数据规模n的函数。 1、冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直到排序完成。 1.2 代码实现

代码：List<Map<String,Object>> list = null; //list中放入数据集后根据每一笔map中的order_no字段进行冒泡排序 list.sort((Map<String,Object> h1,Map<String,Object> h2) -> ((String) h1.get("order_no")).compareTo((String)h2.get("order_no"))); 来源： https://www.cnblogs.com/sikuaiwu/p/11321320.html

题目描述： 用一维数组存储学号和成绩，然后，按成绩排序输出。 输入描述： 输入第一行包括一个整数n(1<=n<=100)，代表学生的个数。接下来的n行每行包括两个整数p和q，分别代表每个学生的学号和成绩。 输出描述： 按照学生的成绩从小到大进行排序，并将排序后的学生信息打印出来。如果学生的成绩相同，则按照学号的大小进行从小到大排序。 思路 ：构造一个Student类，有两个属性num(学号)和score(成绩)，该类实现Comparable接口，覆写compareTo(o)，在该方法里，遵循先按照成绩升序排序，如果不相等再按照学号升序排序。 import java.util.*; class Student implements Comparable{ int num;//学号 int score;//成绩 public String toString(){ return this.num+" "+this.score; } public Student(int num,int score){ this.num=num; this.score=score; } public int getScore() { return score; } @Override public int compareTo(Object o) { int r=Integer.compare(this