按照时间排序，时间正序，时间倒序

最新推荐文章于 2025-05-19 19:15:10 发布
转载 最新推荐文章于 2025-05-19 19:15:10 发布 · 2.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：https://www.youkuaiyun.com/tags/OtTaIg5sOTMyMzUtYmxvZwO0O0OO0O0O.html
文章标签：

#前端 #JavaScript #排序

这篇博客探讨了两种时间排序方法：一种是按时间倒序排列的`ReverseDate`函数，另一种是按时间正序排列的`ForwardRankingDate`函数。这两个函数都通过比较日期并交换元素来实现排序，对于处理包含时间戳的数据非常有用。

封装时间排序

按照时间倒序


  function ReverseDate(data, p) {
    for (i = 0; i < data.length - 1; i++) {
         for (j = 0; j < data.length - 1 - i; j++) {
             console.log(Date.parse(data[j][p]));
            if (Date.parse(data[j][p]) < Date.parse(data[j+1][p])) {
                 var temp = data[j];
                 data[j] = data[j + 1];
                 data[j + 1] = temp;
            }
        }
     }
     return data;
     }

//使用
    dataContent = ReverseDate(data, "creattime");   //传入数据和对应需要排序的时间字段

//日期排序-正序

   function ReverseDate(data, p) {
    for (i = 0; i < data.length - 1; i++) {
        for (j = 0; j < data.length - 1 - i; j++) {
             console.log(Date.parse(data[j][p]));
          if (Date.parse(data[j][p]) > Date.parse(data[j+1][p])) {
                 var temp = data[j];
                data[j] = data[j + 1];
                 data[j + 1] = temp;
             }
         }
    }
    return data;
}

//使用
dataContent = ForwardRankingDate(data, "endtime");
javascript 冒泡排序 正序和倒序实现代码
10-28
在JavaScript中，冒泡排序可以实现升序（正序）和降序（倒序）两种排序方式。 首先，我们来看一下冒泡排序实现升序排序的原理。在升序排序中，我们需要比较数组中的相邻元素，如果当前元素比下一个元素小，那么就...
表格点击首行数据按列排序js功能,正序倒序
08-19
一个点击表格首行任意一列可将该列按正序或倒序排列，简单易懂，复制可用
数据按照时间正序倒序排序以及数据反转
weixin_43638890的博客
11-04 3046
数据按照时间正序倒序排序以及数据反转
时间倒叙正序
malanjun11的博客
03-12 1347
<div class="add-left fl"> <el-dropdown trigger="click" @command="command"> <span class="el-dropdown-link"> {{value}} <i class="el-icon-...
日期正序 时间倒叙。
一万亿
06-04 2326
哇哈哈哈哈哈 就是原创的。 select a||' '||b c from (select user_date,to_char(user_date,'yyyy-MM-dd') a,to_char(user_date,'hh24:mi:ss') b from PPEDT_T_MEMBER_USER t order by a asc,b desc)
按时间日期排序
m0_56175362的博客
11-26 416
var data = [ { name: '时间1', time: '2017-08-18 13:23:21' }, { name: '时间2', time: '2018-03-18 19:23:22' }, { name: '时间3', time: '2019-03-24 19:23:20' }, { name: '时间4', time: '2017-05-16 19:23:19' }, { nam
笔记2-关于列表为时间格式进行正序排列用例
qq_56190082的博客
04-11 497
断言时间格式的方法
Java集合实现正序与倒序排序方法
07-01
通过实现Comparable接口或使用Comparator接口，可灵活地根据对象属性进行正序或倒序排序。此外，通过封装工具类MySortList，进一步提升了代码的复用性和灵活性，对处理复杂业务逻辑和提高代码可维护性意义重大。
Java：集合排序（正序、倒序）的方法
10-17
### Java：集合排序（正序、倒序）的方法 #### 一、背景介绍与需求分析 在Java开发中，我们经常需要对一个包含自定义对象的`List`进行排序。例如，当我们有一个`Member`对象列表，每个成员都有用户名(`username`)...
基于Fortran实现一维数组的简单排序算法，通过参数可以控制进行正序或倒序排序
07-04
本资源包含了一个排序函数和一个主程序，主程序包含一个调用示例，能够对一维数组进行正序和倒序排列，并打印了排序结果，module文件中包含一个排序算法，输入一个输入返回一个排序后的数组，调用形式比较简单。
9个元素换6次达到排序序列_拜托，别再问我计数排序了！！！
weixin_39547298的博客
11-22 203
拜托，别再问我计数排序了！！！到目前为止，我们已经介绍了插入排序、归并排序、堆排序、快速排序等几种排序算法，他们的运行时间上界不会超过O(nlgn)。 这些算法都有一个有趣的性质：在排序的最终结果中，各元素的次序依赖于它们之间的比较。我们把这类排序算法称为比较排序。可以证明，基于比较的排序算法在最坏情况下的时间下界是Ω(nlgn)。堆排序和归并排序的运行时间上界为O(nlgn)，因此这两种排序算法...
python经典排序算法
qq_41872905的博客
09-19 378
python经典排序算法 冒泡排序： 算法思想： 1.比较相邻的元素，如果第一个比第二个大，则交换他们的位置； 2.依次对每一对的元素进行比较，如果前一个比后一个大，则交换他们的位置，这样第一轮下来，最大的元素在序列最后； 3.重复步骤二，这样，经过（n-1）轮，以后，序列按照从小到大依次排列； 分析：数组arr,首先分析数组的长度（len(arr)），接着第一次循环，从第一个元素开始比较，第二次循环从剩下未排序的元素进行比较 因此时间复杂度：O（n^2） python代码实现： def sort(arr)
算法（1）---八大排序算法
m0_37671741的博客
07-20 475
一、选择排序 核心思想：从全部序列中选取最小的，与第0个元素交换，然后从第1个元素往后找出最小的，与第一个元素交换。再从第2个元素往后选取最小的，与第二个元素交换，直到最后一个元素。 代码： //选择排序 //核心思想：不断遍历数组的每个位置，并且为每个位置选择当前数组中最小的元素填入。 //思路分析：遍历数组的每个位置需要一层for循环，为每个位置遍历选择最小值也需要一层for循环。 public static void sort1(int [] arr){ //第一层for循环，遍历数组中的每
select * from 按时间倒序排序
计算机辅助工程
05-19 1328
在SQL中，使用ORDER BY子句结合DESC关键字可以根据时间字段对查询结果进行倒序排序。例如，SELECT * FROM events ORDER BY event_time DESC;会按event_time从最新到最旧排列记录。若需结合其他字段排序，可在ORDER BY中添加多个列，如ORDER BY event_time DESC, id ASC;。若时间字段为字符串格式，可使用日期时间函数（如MySQL的STR_TO_DATE）进行转换后再排序。此外，还可使用别名进行排序，如SELECT ev
时间倒叙显示(计算时间 多少天前/多少小时前/多少分钟前 )
ttaoai的博客
03-22 1216
//时间-倒序显示 年-月-日 时:分 function(timestamp1) { if(!timestamp1){ return “”; } var myDate = new Date(); var timestamp = new Date(timestamp1 ); myDate=myDate.getTime(); timestamp=timestamp.getTime(); var date3=myDate-timestamp; var days=Ma
mongodb 按时间倒序查询
weixin_41393540的博客
07-26 1339
go相关学习资料：https://edu.51cto.com/video/4196.htmlMongoDB 按时间倒序查询：高效数据检索指南 在处理时间序列数据时，MongoDB 提供了强大的查询功能，允许我们按时间倒序获取数据。本文将介绍如何使用 MongoDB 进行时间倒序查询，并提供代码示例以及甘特图来展示查询过程...
排序 时间倒序_时间管理你知道多少
weixin_39686634的博客
01-12 873
1项目时间管理由哪些过程组成？过程间关系是怎么样的？1)活动定义—指确认一些特定的工作；通过完成这些活动就完成了工程项目的各项细节工作2)活动排序—明确各活动间的相互联系性(前后、并列等)3)活动时间估计—估计各活动所需的时间4)进度计划编制—分析活动时间排序、活动所需时间和资源以做出项目进度计划5)进度控制—控制项目进度计划2活动定义的输入、工具与方法、输出都有哪些...
逆序数 时间复杂度O(nlgn)
huiguixian的专栏
03-19 2349
<br />逆序数的定义，摘自百度百科：<br />在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列；逆序数为奇数的排列称为奇排列。如2431中，21，43，41，31是逆序，逆序数是4，为偶排列。<br />我是在看算法导论的时候，看到合并排序的课后习题有一个逆序数，要求是在O(nlgn)的时间复杂度之内查找出来。最直接的算法就是双重循环，类似于冒泡排序法，对整个数组进行外循环，内循环
linux 按照时间倒序或者升序显示文件列表
Ruishine的博客
10-13 2753
在使用Linux时，经常会有按照时间顺序排列文件的需求。
ktolin 通过文件名和修改时间正序倒序ArrayList
最新发布
08-20
<think>我们正在处理一个ArrayList，其中每个元素可能包含文件名和修改时间。我们需要根据这两个属性进行排序（可能单独或组合）。在Kotlin中，我们可以使用`sortedBy`（正序）和`sortedByDescending`（倒序）或者使用`sortedWith`并传入自定义的比较器（Comparator）来实现更复杂的排序（比如多条件排序）。 假设我们有一个类`FileItem`，它包含两个属性：`fileName`（字符串类型）和`modificationTime`（可能是`Long`类型的时间戳，或者`java.util.Date`等）。 例如： ```kotlin data class FileItem(val fileName: String, val modificationTime: Long) ``` 现在，我们有一个`ArrayList<FileItem>`，我们想按照以下方式排序： 1. 按文件名正序/倒序 2. 按修改时间正序/倒序 3. 组合排序（例如先按文件名排序，文件名相同的再按修改时间排序） 我们将分别展示这些情况。 ### 1. 按文件名排序 - 正序（升序）：使用`sortedBy`或`sortedWith(compareBy{...})` - 倒序（降序）：使用`sortedByDescending`或`sortedWith(compareByDescending{...})`，或者使用`reversed()`但更推荐直接使用降序函数。 ### 2. 按修改时间排序 - 类似文件名排序，只是属性不同。 ### 3. 多条件排序 - 使用`compareBy`（正序）或`compareByDescending`（倒序）构建比较器链，可以添加多个条件。 - 语法：`list.sortedWith(compareBy<FileItem> { it.property1 }.thenBy { it.property2 })` 或者倒序：`list.sortedWith(compareByDescending<FileItem> { it.property1 }.thenByDescending { it.property2 })` - 注意：每个条件可以单独指定正序或倒序，使用`thenBy`（正序）或`thenByDescending`（倒序）。 下面我们通过代码示例展示： ```kotlin data class FileItem(val fileName: String, val modificationTime: Long) fun main() { val fileList = arrayListOf( FileItem("document.txt", 1620000000000), FileItem("image.png", 1625000000000), FileItem("audio.mp3", 1623000000000), FileItem("document.txt", 1622000000000) // 同文件名，不同时间 ) // 1. 按文件名正序（升序：A-Z） val sortedByNameAsc = fileList.sortedBy { it.fileName } println("按文件名正序：") sortedByNameAsc.forEach { println(it) } // 2. 按文件名倒序（降序：Z-A） val sortedByNameDesc = fileList.sortedByDescending { it.fileName } println("\n按文件名倒序：") sortedByNameDesc.forEach { println(it) } // 3. 按修改时间正序（升序：从早到晚） val sortedByTimeAsc = fileList.sortedBy { it.modificationTime } println("\n按修改时间正序：") sortedByTimeAsc.forEach { println(it) } // 4. 按修改时间倒序（降序：从晚到早） val sortedByTimeDesc = fileList.sortedByDescending { it.modificationTime } println("\n按修改时间倒序：") sortedByTimeDesc.forEach { println(it) } // 5. 多条件排序：先按文件名正序，再按修改时间倒序（同一文件名下，最新的排前面） val sortedByMultiple = fileList.sortedWith( compareBy<FileItem> { it.fileName } // 文件名正序 .thenByDescending { it.modificationTime } // 修改时间倒序 ) println("\n多条件排序（文件名正序，修改时间倒序）：") sortedByMultiple.forEach { println(it) } // 6. 多条件排序：先按文件名倒序，再按修改时间正序 val sortedByMultiple2 = fileList.sortedWith( compareByDescending<FileItem> { it.fileName } // 文件名倒序 .thenBy { it.modificationTime } // 修改时间正序 ) println("\n多条件排序（文件名倒序，修改时间正序）：") sortedByMultiple2.forEach { println(it) } } ``` 输出示例（具体输出取决于数据）： ``` 按文件名正序： FileItem(fileName=audio.mp3, modificationTime=1623000000000) FileItem(fileName=document.txt, modificationTime=1620000000000) FileItem(fileName=document.txt, modificationTime=1622000000000) FileItem(fileName=image.png, modificationTime=1625000000000) 按文件名倒序： FileItem(fileName=image.png, modificationTime=1625000000000) FileItem(fileName=document.txt, modificationTime=1620000000000) FileItem(fileName=document.txt, modificationTime=1622000000000) FileItem(fileName=audio.mp3, modificationTime=1623000000000) ...（其他输出略） ``` 注意：`sortedBy`和`sortedWith`等函数返回一个新的排序后的列表（只读List），不会改变原始列表。如果你想在原`ArrayList`上排序（改变自身），可以使用`sortBy`、`sortByDescending`或`sortWith`（注意：这些是可变列表的方法，ArrayList是MutableList的子类，所以可用）。 例如，对原列表进行按文件名正序排序： ```kotlin fileList.sortBy { it.fileName } ``` 或者使用`sortWith`进行多条件排序： ```kotlin fileList.sortWith(compareBy({ it.fileName }, { it.modificationTime })) ``` 总结： - 单条件排序：`sortedBy` / `sortedByDescending`（返回新列表）或`sortBy`/`sortByDescending`（原地排序）。 - 多条件排序：`sortedWith`（返回新列表）或`sortWith`（原地排序）配合`compareBy`（可以链式调用`thenBy`等）。 引用说明：在引用[1]中提到了使用Java Stream API的Comparator进行排序（正序和倒序），在Kotlin中我们使用了更简洁的扩展函数，但原理类似（都是使用比较器）[^1]。 如果用户需要更复杂的比较逻辑（比如忽略文件名大小写），可以在比较器中指定，例如： ```kotlin sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.fileName }) ``` 或者： ```kotlin sortedBy { it.fileName.toLowerCase() } ``` 但注意，使用`toLowerCase()`可能涉及区域设置问题，推荐使用`compareBy`并传入`String.CASE_INSENSITIVE_ORDER`。 例如，忽略大小写的文件名正序： ```kotlin val sortedByNameIgnoreCase = fileList.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.fileName }) ``` 或者使用Kotlin 1.3及以上版本，可以使用： ```kotlin val sortedByNameIgnoreCase = fileList.sortedBy { it.fileName.lowercase() } ``` 但注意：使用`lowercase()`（Kotlin 1.3+）或`toLowerCase()`会创建新的字符串，对于非常大的列表可能有性能影响。使用`String.CASE_INSENSITIVE_ORDER`则不会创建新字符串。 因此，根据需求选择合适的方法。 相关问题： 1. Kotlin中如何对集合进行自定义复杂排序（例如，不同的属性使用不同的排序方向）？ 2. Kotlin中的排序函数（如sortedBy）与Java的Stream API排序有何性能差异？ 3. 在Kotlin中如何实现不区分大小写的字符串排序？</think>### Kotlin 中对 ArrayList 按文件名和修改时间排序（正序/倒序） 在 Kotlin 中，对 `ArrayList` 按文件名和修改时间排序需要结合 `sortedWith()` 和自定义比较器。以下是完整实现方案，支持单条件/多条件排序和正序/倒序排列： #### 1. 数据模型准备 假设我们有一个文件类 `FileItem`： ```kotlin data class FileItem( val name: String, // 文件名 val modified: Long // 修改时间戳 (毫秒) ) ``` #### 2. 单条件排序 ```kotlin // 按文件名正序 (A-Z) val nameAscending = fileList.sortedBy { it.name } // 按文件名倒序 (Z-A) val nameDescending = fileList.sortedByDescending { it.name } // 按修改时间正序 (旧→新) val timeAscending = fileList.sortedBy { it.modified } // 按修改时间倒序 (新→旧) val timeDescending = fileList.sortedByDescending { it.modified } ``` #### 3. 多条件组合排序（推荐） ```kotlin // 先按文件名正序，再按修改时间倒序 val sortedList = fileList.sortedWith( compareBy<FileItem> { it.name } // 主排序：文件名正序 .thenByDescending { it.modified } // 次排序：修改时间倒序 ) // 先按修改时间倒序，再按文件名正序 val sortedList2 = fileList.sortedWith( compareByDescending<FileItem> { it.modified } // 主排序：时间倒序 .thenBy { it.name } // 次排序：文件名正序 ) ``` #### 4. 自定义复杂排序 ```kotlin val customSorted = fileList.sortedWith { a, b -> // 第一优先级：文件名长度 val nameLengthCompare = a.name.length.compareTo(b.name.length) if (nameLengthCompare != 0) return@sortedWith nameLengthCompare // 第二优先级：修改时间倒序 -a.modified.compareTo(b.modified) // 负号表示倒序 } ``` #### 5. 原地排序（修改原集合） ```kotlin // 原地按文件名正序排序 fileList.sortBy { it.name } // 原地多条件排序 fileList.sortWith( compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } // 忽略大小写 .thenByDescending { it.modified } ) ``` #### 关键说明： 1. **比较器链**：使用 `compareBy().thenBy()` 链式调用实现多级排序[^1] 2. **性能优化**：`sortedWith` 时间复杂度为 $O(n \log n)$，适合大型集合 3. **原地排序**：`sortBy`/`sortWith` 直接修改原集合，`sortedBy`/`sortedWith` 返回新集合 4. **特殊处理**： - 文件名忽略大小写：`compareBy(String.CASE_INSENSITIVE_ORDER) { it.name }` - 空值处理：`compareBy(nullsFirst()) { it.name }` > **最佳实践**：对于文件系统排序，推荐使用多条件组合 `compareBy { it.name }.thenByDescending { it.modified }`，这符合"先按名称分组，再按时间降序"的常见需求[^1]。 --- ### 相关问题 1. 如何在 Kotlin 中实现不区分大小写的文件名排序？ 2. Kotlin 集合排序与 Java 的 Stream API 排序有何性能差异？ 3. 如何对包含空值的文件列表进行安全排序？ 4. Kotlin 中 `sortBy` 和 `sortedBy` 的主要区别是什么？
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值