一个有点大的查询，记录下

最新推荐文章于 2024-06-03 21:59:07 发布
转载 最新推荐文章于 2024-06-03 21:59:07 发布 · 274 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/QiaoLoveLei/archive/2011/04/26/Zora.html

一个有点大的查询，记录下

情况：两个视图与一张临时表进行连接查询，使用inner join查询时奇慢无比，1万条记录，大概要10分钟查出

SET STATISTICS IO ON,忍了10分钟

(10562 行受影响)
表 'FLAG'。扫描计数 2，逻辑读取 330816 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_FLAG'。扫描计数 43648，逻辑读取 48361984 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY'。扫描计数 1，逻辑读取 74264 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'Worktable'。扫描计数 9829，逻辑读取 86518 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'temptable_2425be7ac4f1403f9b72fa238b6a6127'。扫描计数 1，逻辑读取 34 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，

lob 预读 0 次。
表 'COMPANY_BUILDING'。扫描计数 1，逻辑读取 72 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'BUILDING'。扫描计数 1，逻辑读取 27 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_PERSON'。扫描计数 1，逻辑读取 492 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON'。扫描计数 1，逻辑读取 1169 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON_FLAG'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'DEPARTMENT'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'USER'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'R_USER_DEPARTMENT'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_INVE_VISIT'。扫描计数 1，逻辑读取 385 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

使用inner merge join时间1分钟

inner merge join
警告: 由于使用了本地联接提示，联接次序得以强制实施。

(10562 行受影响)
表 'Worktable'。扫描计数 114950，逻辑读取 1299051 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'FLAG'。扫描计数 186690，逻辑读取 1058927 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_FLAG'。扫描计数 4，逻辑读取 4432 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY'。扫描计数 2，逻辑读取 2650 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_BUILDING'。扫描计数 1，逻辑读取 72 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'BUILDING'。扫描计数 1，逻辑读取 27 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'DEPARTMENT'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'USER'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'R_USER_DEPARTMENT'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_INVE_VISIT'。扫描计数 1，逻辑读取 385 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON_FLAG'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_PERSON'。扫描计数 1，逻辑读取 492 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON'。扫描计数 1，逻辑读取 1169 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'temptable_2425be7ac4f1403f9b72fa238b6a6127'。扫描计数 1，逻辑读取 34 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，

lob 预读 0 次。

inner loop join同样1分钟左右

警告: 由于使用了本地联接提示，联接次序得以强制实施。

(10562 行受影响)
表 'Worktable'。扫描计数 104389，逻辑读取 5579144 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'FLAG'。扫描计数 186690，逻辑读取 1058927 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_FLAG'。扫描计数 4，逻辑读取 4432 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY'。扫描计数 2，逻辑读取 2650 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_BUILDING'。扫描计数 1，逻辑读取 72 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'BUILDING'。扫描计数 1，逻辑读取 27 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'DEPARTMENT'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'USER'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'R_USER_DEPARTMENT'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_INVE_VISIT'。扫描计数 1，逻辑读取 385 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON_FLAG'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_PERSON'。扫描计数 1，逻辑读取 492 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON'。扫描计数 1，逻辑读取 1169 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'temptable_2425be7ac4f1403f9b72fa238b6a6127'。扫描计数 1，逻辑读取 34 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，

lob 预读 0 次。

inner hash join也是1分钟左右，看来不是inner join 能解决的问题

警告: 由于使用了本地联接提示，联接次序得以强制实施。

(10562 行受影响)
表 'Worktable'。扫描计数 104388，逻辑读取 1235680 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'FLAG'。扫描计数 186690，逻辑读取 1058927 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_FLAG'。扫描计数 4，逻辑读取 4432 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY'。扫描计数 2，逻辑读取 2650 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_BUILDING'。扫描计数 1，逻辑读取 72 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'BUILDING'。扫描计数 1，逻辑读取 27 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'DEPARTMENT'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'USER'。扫描计数 0，逻辑读取 98 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'R_USER_DEPARTMENT'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_INVE_VISIT'。扫描计数 1，逻辑读取 385 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON_FLAG'。扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_PERSON'。扫描计数 1，逻辑读取 492 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON'。扫描计数 1，逻辑读取 1169 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'temptable_2425be7ac4f1403f9b72fa238b6a6127'。扫描计数 1，逻辑读取 34 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，

lob 预读 0 次。

很奇怪，inner join难道不光这3种模式，还有一种默认的与以上两种不一样?

改用left join,查询结果相同，查询时间两秒钟

(10562 行受影响)
表 'Worktable'。扫描计数 31708，逻辑读取 1033264 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'FLAG'。扫描计数 2，逻辑读取 152308 次，物理读取 2 次，预读 1 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_FLAG'。扫描计数 4，逻辑读取 4432 次，物理读取 3 次，预读 1104 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'temptable_2425be7ac4f1403f9b72fa238b6a6127'。扫描计数 1，逻辑读取 34 次，物理读取 0 次，预读 34 次，lob 逻辑读取 0 次，lob 物理读取 0 次，

lob 预读 0 次。
表 'COMPANY'。扫描计数 2，逻辑读取 2650 次，物理读取 3 次，预读 1321 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_BUILDING'。扫描计数 1，逻辑读取 72 次，物理读取 1 次，预读 70 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'BUILDING'。扫描计数 1，逻辑读取 27 次，物理读取 1 次，预读 25 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_PERSON'。扫描计数 1，逻辑读取 492 次，物理读取 3 次，预读 488 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON'。扫描计数 1，逻辑读取 1169 次，物理读取 3 次，预读 1165 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'PERSON_FLAG'。扫描计数 1，逻辑读取 2 次，物理读取 2 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'DEPARTMENT'。扫描计数 0，逻辑读取 98 次，物理读取 1 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'USER'。扫描计数 0，逻辑读取 98 次，物理读取 1 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'R_USER_DEPARTMENT'。扫描计数 1，逻辑读取 2 次，物理读取 2 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'COMPANY_INVE_VISIT'。扫描计数 1，逻辑读取 385 次，物理读取 3 次，预读 381 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

明显可见，在使用left join 时间快了以后，COMPANY_FLAG表的逻辑读取次数由4000万次降到了4000次 XD

于是打开COMPANY_FLAG表，表列如下：ID,COMPANYID,FLAGID，均为GUID

在COMPANYID上建立非聚集索引,再次使用inner join查询，2秒钟

总结- -无论你查询语句怎么优化，还是不如建索引省事啊 M(_ _)M

posted on 2011-04-26 10:28 R7thZora 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/QiaoLoveLei/archive/2011/04/26/Zora.html

oracle查询一个用户,Oracle一个用户查询另一个用户的表数据
weixin_29997937的博客
04-11 5772
1、两个用户是在不同的库，需要建立dblink2、属于同一个库的不同用户1)方法一：使用"用户名."的方式访问例如：要从USER1账号访问USER2中的表TABLE2A. 需要在USER2中将TABLE2GRANT给USER1，USER1才有权限访问，访问的时候用SELECT*FROMUSER2.TABLE2语句B.也可以直接给用户USER1赋予dba权限，待使用完后再取出dba，不过很危...
mysql查询连续7天_一个有趣的 SQL 查询(查询7天连续登陆)
weixin_39640414的博客
01-19 1296
一个有趣的 SQL 查询一个朋友有这样一个SQL查询需求：有一个登录表(tmp_test)，包含用户ID(uid)和登录时间(login_time)。表结构如下：*************************** 1. row ***************************Field: uidType:int(10) unsignedNull: NOKey: MULDefault: N...
hash join提示错误
starseeker7的专栏
03-21 3401
今天在论坛看到大家讨论的一个问题，觉得比较有用，就记下来免得忘记了 首先是一个人发现他的脚本使用inner hash join的时候提示错误 Msg 8622, Level 16, State 1, Line 1 Query processor could not produce a query plan because of the hints defined in this query.
SQL优化之not in
diman3157的博客
04-22 433
阅读目录 案例语句 分析手段 如何优化 招聘信息 一直从事运维的工作，免不了优化一些SQL语句，因为本人比较懒的原因，很多经典的案例没有记录下来，深表遗憾 回到顶部 案例语句 某大型房地产公司，巡检日期2013-04-22，问题语句 1 SELECT COUNT(*) 2 FROM ( SELECT temp.App...
sqlserver服务器CPU性能,SQLServer 2000 升级到 SQLServer 2008 性能之需要注意的地方之...
weixin_36415835的博客
08-04 383
测试sql：复制代码 代码如下:SET STATISTICS IO ONSET STATISTICS TIME ONSELECT COUNT(1)FROM dbo.tbtext aINNER LOOP JOIN dbo.tbtext bON a.id = b.id option (maxdop 1)SET STATISTICS IO OffSET STATISTICS TIME Off表结构：复制...
SQL Server 2000 升级到 SQL Server 2008 性能问题之一
dida4700的博客
02-15 321
SQL Server 2000 升级到 SQL Server 2008 性能问题之一 今天在 相同环境测试 2000 和 2008 性能 让我意外的是 2008 明显比2000 慢很多 测试sql： SET STATISTICS IO ONSET STAT...
sql server中的逻辑读、物理读和预读
pingqingbo的专栏
12-01 2896
在使用SET STATISTICS IO ON语句统计I/O时候，我们会看到类似下面的结果： 扫描计数 1，逻辑读取 2 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。 那么它们代表什么呢？ 预读：用于估计信息，去硬盘读取数据到缓存。 物理读：查询计划生成好以后，如果缓存缺少所需要的数据，让缓存再次去读硬盘。如
mysql如何查询两个日期之间最大的连续登录天数
12-16
拿到这个需求的时候，说实话有点懵，第一想到的就是在代码中去统计，会用到循环，想到那么多个用户，并且时间跨度也有点大，比如15年到16年，两年时间，想想就有点恐怖。 解决方案 然后就把这个需求跟朋友说了，朋友...
MySQL之查询性能优化(二)
Cover_sky的博客
06-03 1822
查询性能低下最基本的原因是访问的数据太多。某些查询可能不可避免地需要筛选大量数据，但这并不场景。大部分性能低下的查询都可以通过减少访问的数据量的方式进行优化。
【Windows运维系列1】查询Windows服务器登录的记录和IP地址（附Shell命令）
aiwo1337的博客
01-18 3398
23年12月底的时候，客户的一台在Hostease购买的Windows美国服务器客户投诉网站打不开，在登陆服务器检查问题的时候发现文件都被加密了，当时顿时头皮发麻，都23年了，居然还会中勒索病毒？？！！我们可以知道如何通过查询日志获取登陆过服务器的IP地址从而作出一些安全加固的步骤。
一个小白的Thingworx成长记录
weixin_42446998的博客
10-16 2462
一个小白的Thingworx成长记录 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了
SQLServer 2000 升级到 SQLServer 2008 性能之需要注意的地方之一
时钟滴答滴答
08-13 1423
SQLServer 2000 升级到 SQLServer 2008 性能之需要注意的地方之一   今天在 相同环境测试 2000 和 2008 性能 让我意外的是 2008 明显比2000 慢很多，因为不能简单的升级，sql语句也需要优化   - 测试sql： 复制代码 代码如下: SET STATISTICS IO ON SET STATISTICS TIME
记一次SQLServer的分页优化兼谈谈使用Row_Number()分页存在的问题
weixin_34004750的博客
11-23 405
最近有项目反应，在服务器CPU使用较高的时候，我们的事件查询页面非常的慢，查询几条记录竟然要4分钟甚至更长，而且在翻第二页的时候也是要这么多的时间，这肯定是不能接受的，也是让现场用SQLServerProfiler把语句抓取了上来。 用ROW_NUMBER()进行分页 我们看看现场抓上来的分页语句： select top 20 a.*,ag.Name as AgentServerName,,d.N...
【in - exists-join(distinct)】SQL调优改写一例
Ask Self，Ask Tomorrow
07-10 338
相关数据已经脱敏处理 原SQLMERGE INTO IntoTable t USING ( SELECT x.PID, b.SEC_ID, b.T_SYB, b.E_CD, x.END_DATE, x.xh 区间级别, isnull(x.hj, 0) 区间人数 FROM
查询文件内容并只取最后一个
最新发布
08-21
<think>我们被要求读取文件内容并只取最后一行或最后一个记录。根据引用，有几种方法可以实现： 1. 使用RandomAccessFile（Java）从文件末尾开始读取，逐行向前直到找到最后一行（引用[1]提到的方法，但注意那是读取第一行，我们需要最后一行）。 2. 在C/C++中，我们可以通过移动文件指针到文件末尾，然后向前搜索换行符来定位最后一行（引用[2]和[3]提到了类似问题，但主要是重复读取和匹配问题）。 3. 在Shell中，我们可以使用tail命令（引用[4]是读取每一行，但我们可以用tail -n 1）。 但是，用户的问题没有指定语言，所以我们将提供多种语言的解决方案，并重点放在高效读取最后一行（因为如果文件很大，读取整个文件是不高效的）。 我们将提供以下方法： 1. 使用Python（因为用户之前的问题用Python回答，且Python是通用语言） 2. 使用Java（根据引用[1]） 3. 使用C（根据引用[2]和[3]） 4. 使用Shell（根据引用[4]） 注意：读取最后一行时，要注意文件的编码和换行符。 我们首先给出Python的解决方案，因为用户之前的问题都是Python。 ### Python 读取文件最后一行 #### 方法1：读取整个文件（适用于小文件） ```python with open('file.txt', 'r') as f: lines = f.readlines() last_line = lines[-1].strip() # 去除换行符 print(last_line) ``` #### 方法2：从文件末尾逐块读取（适用于大文件） ```python def get_last_line(filename): with open(filename, 'rb') as f: # 以二进制模式打开，以便处理不同的换行符 # 将指针移动到文件末尾前2个字符（因为最后一行可能没有换行符，但为了安全，我们移动到最后） f.seek(-2, 2) # 2表示从文件末尾，-2表示偏移量（负值表示向前） # 然后我们向前查找换行符 while f.read(1) != b'\n': # 直到找到换行符 # 如果已经到达文件开头，则停止 if f.tell() <= 1: f.seek(0) break f.seek(-2, 1) # 从当前位置向前移动两个字节（因为我们已经读了一个字节，所以需要再向前移动一个位置，但由于我们读了一个，所以向前移动两个） last_line = f.readline().decode('utf-8').strip() return last_line # 注意：这个方法在文件最后一行没有换行符时也能工作，但如果文件只有一行，可能会出错。改进如下： ``` 改进的大文件版本（更健壮）： ```python def get_last_line(filename): """高效读取大文件的最后一行""" with open(filename, 'rb') as f: # 获取文件大小 f.seek(0, 2) # 移动到文件末尾 end_byte = f.tell() # 设置一个偏移量，从文件末尾开始向前移动 offset = -100 # 假设一行最多100个字节，我们取最后100个字节 # 如果文件小于100字节，则从0开始 if end_byte + offset > 0: # 如果文件大于100字节，则从倒数100字节开始 f.seek(offset, 2) else: # 文件很小，直接移动到开头 f.seek(0, 0) # 读取从当前位置到末尾的字节 lines = f.readlines() # 最后一行 if lines: last_line = lines[-1].decode('utf-8').strip() else: last_line = '' return last_line ``` 注意：如果文件很大，且最后一行非常长（超过100字节），则上述方法可能不准确。我们可以循环直到找到换行符： 更健壮的方法（从文件末尾逐字节向前读取，直到找到换行符）： ```python def get_last_line(filename): with open(filename, 'rb') as f: # 将指针移动到文件末尾 f.seek(0, 2) # 第二个参数0表示文件开头，1当前位置，2文件末尾。所以是移动到文件末尾，偏移0 end_byte = f.tell() # 设置一个变量来记录当前指针位置 pos = end_byte # 用于记录换行符的位置 last_newline = None # 逐字节向前读取 while pos > 0: pos -= 1 f.seek(pos) char = f.read(1) if char == b'\n': # 如果找到了换行符，那么最后一行就是这个换行符之后的内容 # 但是注意，如果文件最后一行没有换行符，那么最后一行就是从这个位置到末尾 # 另外，如果文件只有一个换行符，那么我们需要考虑两种情况 # 我们检查一下这个换行符是不是最后一个字符（即文件末尾的换行符） if pos == end_byte - 1: # 说明最后是一个换行符，那么最后一行应该是这个换行符前面的内容（即倒数第二行？不对，我们想要的是最后一行，但最后一行是空行？） # 实际上，我们想要的是非空行？但题目要求最后一行，所以即使空行也要返回 # 所以，我们继续向前找上一个换行符 last_newline = pos # 但我们只需要最后一个非空行？不，题目要求最后一行，所以如果最后一行是空行，我们就返回空行。 # 因此，我们直接读取这一行（从当前换行符的下一个字节开始到文件末尾，但当前换行符在末尾，所以下一行长度为0） # 所以，我们直接退出，然后读取从当前换行符后面开始到文件末尾，就是空行。 break else: # 这个换行符不是文件末尾的换行符，那么最后一行就是这个换行符之后的内容 last_newline = pos break # 如果没找到换行符，继续向前 if last_newline is None: # 说明整个文件没有换行符，那么整个文件就是一行 f.seek(0) last_line = f.read().decode('utf-8') else: f.seek(last_newline + 1) # 换行符的下一个位置 last_line = f.read().decode('utf-8') # 注意：如果最后一行有换行符，那么这里读取的会包含换行符，我们可以strip去掉 # 但题目要求最后一行，包括换行符？通常我们不需要换行符，所以strip # 但注意，如果最后一行没有换行符，那么上面不会进入break，所以last_newline为None，所以不会到这里 # 所以，我们这里读取的是从换行符后到文件末尾，如果文件末尾有换行符，那么last_line就是空字符串（如果最后一行是空行）？不对，因为如果最后一行有换行符，那么last_newline指向这个换行符，然后读取的就是换行符后面的内容，可能是空（如果换行符是最后一个字符）或者上一行的一部分？不对，我们找的是最后一个换行符，然后读取的是最后一个换行符之后的内容，也就是最后一行（包括换行符？不，换行符已经被跳过了，所以读取的是不带换行符的内容？不对，文件末尾的换行符后面的内容为空，所以如果最后一行有换行符，那么最后一行在换行符之前，而我们读取的是换行符之后，所以是空行？不对，逻辑有误。 # 重新思考：我们想要的是最后一行，即从最后一个换行符（如果有）之后到文件末尾。但是，如果文件最后没有换行符，那么最后一行就是从最后一个换行符（如果有）之后到文件末尾，或者整个文件（如果没有换行符）。 # 修正：我们实际上要找的是最后一个换行符的位置，然后读取这个位置之后的内容。但是，如果文件最后有一个换行符，那么最后一行就是这个换行符之前的内容（即空行）？不对，最后一行应该是这个换行符之前的那一行（即倒数第二行）？不对，文件末尾的换行符表示最后一行是空行。 # 所以，我们实际上需要区分两种情况： # 1. 文件以换行符结束：那么最后一行是空行（在最后一个换行符后面）。 # 2. 文件不以换行符结束：那么最后一行是最后一个换行符之后的内容（非空，且没有换行符）。 # 但是，我们上面的方法在找到最后一个换行符（在文件末尾）时，会继续向前找，直到找到非末尾的换行符。所以，我们上面的逻辑在文件以换行符结束时，会找到文件末尾的换行符，然后我们读取这个换行符之后的内容（即空），这是正确的。 # 所以，我们返回的last_line就是最后一行（可能包含换行符？不，因为read()会读取到文件末尾，包括换行符？不对，二进制读取，我们解码，所以换行符也会被读进来。但注意，最后一行如果有换行符，那么它已经被包含在文件内容中，而我们读取的是从换行符之后到文件末尾，所以如果文件以换行符结束，我们读取的是空字符串。但实际最后一行应该是空行，所以空字符串就是空行。 # 因此，我们不需要strip，因为最后一行可能包含空格。但注意，我们读取的字符串中，如果最后一行有换行符，那么它会被包含吗？不会，因为我们读取的是最后一个换行符之后的内容，而文件末尾的换行符之后没有内容，所以为空。但是，如果最后一行没有换行符，那么last_line就是整个最后一行（没有换行符）。 # 所以，我们返回的last_line就是原文件的最后一行（不包含换行符？因为换行符被我们跳过了？不对，换行符被我们作为分隔符跳过了，所以我们读取的是换行符之后的内容，而换行符本身不包括在内。所以，最后一行本身如果有换行符，那么它已经被排除在读取内容之外。因此，我们读取的内容就是最后一行（不带换行符）。 # 但是，如果文件最后没有换行符，那么最后一行就没有被换行符结束，我们读取的就是整个最后一行（不带换行符）。 # 因此，我们返回的就是不带换行符的最后一行。这符合通常的需求。 # 所以，我们直接返回last_line即可。 return last_line ``` 但是，这个方法有点复杂，而且效率可能不高（逐字节读取）。我们可以用缓冲区优化。 更高效的方法（使用缓冲区，从文件末尾读取一块数据，然后在这个块里找换行符）： ```python def get_last_line(filename, buffer_size=1024): """使用缓冲区读取最后一行""" with open(filename, 'rb') as f: # 移动到文件末尾 f.seek(0, 2) file_size = f.tell() if file_size == 0: return '' # 空文件 # 初始化位置和缓冲区 pos = file_size buffer = b'' while pos > 0: # 计算读取的起始位置 start = max(0, pos - buffer_size) read_size = pos - start # 移动到start位置 f.seek(start) # 读取read_size个字节 chunk = f.read(read_size) # 将新读取的块放在之前缓冲区的前面 buffer = chunk + buffer # 更新位置 pos = start # 在buffer中查找最后一个换行符 # 注意：我们忽略文件末尾的换行符（如果有），因为我们要找的是最后一行之前的换行符 # 我们查找buffer中最后一个换行符（不包括buffer的最后一个字符如果是换行符，且这个换行符是文件末尾的换行符） # 但是，我们可以在buffer中查找换行符，从后往前找 # 注意：buffer可能包含多个换行符 # 我们找buffer中最后一个换行符（不包括buffer末尾的换行符，如果它是文件末尾的换行符？不，我们想要的是最后一行之前的换行符，所以如果文件末尾有换行符，那么最后一行是空行，我们想要的是这个换行符之前的内容（即上一行）？不对，我们想要的是最后一行，包括空行。 # 所以，我们要找的是buffer中最后一个换行符（无论它在哪里），然后这个换行符之后的内容就是最后一行（不包括这个换行符）？不对，这个换行符之后的内容可能是多行，因为buffer中可能有多个换行符。 # 实际上，我们想要的是整个文件中的最后一个换行符，然后从这个换行符之后到文件末尾就是最后一行。 # 因此，在buffer中，我们只需要找第一个换行符（从后往前找的第一个，即buffer中最后一个换行符），然后这个换行符之后的内容就是最后一行（如果这个换行符在文件末尾，那么最后一行就是空行）。 # 在buffer中查找换行符 # 从buffer的末尾开始往前找，忽略buffer的最后一个字符（如果它是换行符，且它是文件末尾的换行符，那么它可能是我们不需要的？不，我们需要知道它是否存在） # 我们查找buffer中最后一个换行符的位置（从后往前第一个换行符） newline_pos = buffer.rfind(b'\n') if newline_pos != -1: # 如果找到了，那么最后一个换行符之后的内容就是最后一行（不包括这个换行符） # 但是，注意，我们可能读取了多个换行符，所以我们要从找到的换行符之后开始截取，直到buffer末尾 # 但是，我们可能之前已经读取了部分内容，所以我们需要返回这个换行符之后的内容，并且加上之前可能已经读取的后续内容？不，我们是一次性读取的，所以整个文件末尾的内容都在buffer里。 # 但是，我们只读取了最后buffer_size*2左右的内容，所以如果最后一行很长，可能还没有读到换行符，那么我们就需要继续向前读。 # 所以，如果我们找到了一个换行符，并且这个换行符不是buffer的最后一个字符（即不是文件末尾的换行符），那么我们可以直接返回这个换行符之后的内容？不对，我们需要的是整个文件的最后一行，所以应该是最后一个换行符（整个文件）之后的内容。 # 因此，我们只需要整个文件中的最后一个换行符。而我们在buffer中找到了一个换行符，那么它可能是文件中的任意一个。但是，我们是从后往前读的，所以buffer中最后一个换行符（即buffer中从后往前第一个）就是整个文件的最后一个换行符。 # 但是，如果文件末尾有换行符，那么buffer的最后一个字符就是换行符，那么newline_pos就是len(buffer)-1。那么，最后一行就是这个换行符之后的内容（空），然后我们还要继续向前找上一个换行符？不对，因为我们要的是最后一行，而文件末尾的换行符表示最后一行是空行。 # 所以，我们直接返回buffer[newline_pos+1:]即可，但是注意，这个换行符之后的内容可能不是完整的最后一行，因为我们可能只读取了部分？不对，我们是从文件末尾开始读取的，所以buffer包含的是文件末尾的连续内容，而最后一个换行符一定是在这个buffer中，所以它之后的内容就是最后一行。 # 但是，如果文件末尾没有换行符，那么最后一行就没有被换行符结束，那么我们就需要返回从最后一个换行符（如果有）之后到文件末尾的内容。如果没有换行符，那么整个buffer就是最后一行（因为没有换行符，所以最后一行就是整个文件？不对，我们只读取了最后一部分，所以可能不完整）。 # 因此，我们还需要考虑没有找到换行符的情况，即newline_pos==-1，那么我们就继续向前读取。 # 但是，如果我们找到了，并且这个换行符是buffer中唯一的一个，那么我们就返回它之后的内容。 # 但是，注意：如果文件最后一行很长，我们可能还没有读到它的开头，所以我们需要继续向前读，直到找到换行符或者文件开头。 # 所以，我们这里不能直接返回，因为我们可能只读取了最后一行的一部分（如果最后一行很长，超过了buffer_size，那么我们需要继续向前读，直到读到换行符或者文件开头）。 # 因此，我们修改：我们只关心整个文件的最后一个换行符，所以如果我们找到了一个换行符，那么它之后的内容（即最后一行）可能已经完整地包含在buffer中，也可能没有（因为最后一行可能很长，我们只读取了它的后半部分）。所以，我们需要继续向前读，直到找到上一行的换行符（即最后一行之前的换行符）？不对，这样太复杂。 # 重新设计：我们只需要读取最后一行，那么我们可以从文件末尾向前读取，直到遇到换行符，然后读取这个换行符之后的内容作为最后一行。如果直到文件开头都没有换行符，那么整个文件就是一行。 # 所以，我们不需要使用缓冲区，而是使用逐字节向前，但这样效率低。或者，我们可以使用os模块的tail命令。 # 鉴于复杂度，我们使用一个更简单的方法：读取最后2*buffer_size字节，然后找最后一个换行符，如果没找到，就再向前读buffer_size字节，直到找到或到文件开头。 # 但是，我们这里为了简单，我们使用逐块向前读取，直到找到换行符。 # 修改：我们继续向前读，直到我们确定找到了最后一个换行符（即整个文件的最后一个换行符）或者到达文件开头。 # 但是，我们上面的循环已经是在逐块向前读取了，所以我们可以这样：在每次读取后，我们在buffer中查找换行符，如果找到了，那么最后一个换行符（在buffer中位置最靠后的那个）之后的内容就是最后一行，然后我们break。 # 但是，注意：buffer中可能有多个换行符，但我们只关心最后一个（即最靠近文件末尾的那个），所以每次读取后，我们查找buffer中的最后一个换行符，如果找到了，那么我们就返回这个换行符之后的内容（注意，这个换行符之后的内容可能包含多个换行符，但我们只取最后一个换行符之后的内容，即最后一行）。 # 但是，我们可能读取了多个块，而最后一行被分在两个块中？不对，我们是从后往前读，所以最后一行应该被完整地读在buffer的末尾部分。 # 所以，我们只需要在buffer中查找最后一个换行符，然后返回这个换行符之后的内容。 # 但是，注意：如果文件末尾有换行符，那么buffer的最后一个字符是换行符，那么newline_pos就是len(buffer)-1，那么最后一行就是空行（buffer[newline_pos+1:]就是空字符串）。 # 所以，我们 break，然后返回 buffer[newline_pos+1:] 并解码 # 但是，如果文件末尾没有换行符，那么最后一行就没有换行符结束，那么我们在buffer中可能找不到换行符（如果最后一行很长，我们还没有读到换行符），或者找到的换行符是上一行的换行符。 # 所以，我们 break 的条件是：找到了一个换行符，并且这个换行符不是 buffer 的开头部分（因为我们可能只读取了最后一行的一部分，而换行符在更前面）？不对，我们 break 的条件应该是：我们找到了一个换行符，而且这个换行符之后的内容就是最后一行（即这个换行符是文件中的最后一个换行符），那么无论它在哪里，我们都可以返回它之后的内容。 # 但是，我们怎么能确定它是最后一个换行符？因为我们是从后往前读的，所以我们在buffer中找到的第一个换行符（从后往前）就是文件中的最后一个换行符。 # 所以，我们 break，然后返回。 # 但是，如果最后一行很长，我们还没有读到它的起始位置，那么buffer中可能没有换行符（即最后一行还没有读完），那么我们就继续向前读。 # 所以，我们 break 的条件是：在buffer中找到了换行符，并且这个换行符的位置不是在 buffer 的开头？不，我们不需要这个条件。 # 因此，我们 break，然后返回 buffer[newline_pos+1:] # 但是，如果 buffer 中还没有读到换行符，我们就继续向前读。 # 但是，还有一种情况：文件只有一行，且没有换行符，那么我们就读到了文件开头，还是没找到换行符，那么最后一行就是整个文件。 # 所以，我们 break 的条件是：找到了换행符，或者已经读到文件开头（pos==0）. # 如果读到文件开头，那么最后一行就是 buffer 的全部内容（因为没有换行符）。 # 所以，我们修改： if newline_pos != -1: # 返回换行符之后的内容 break # 否则继续向前读 if newline_pos == -1: # 说明整个文件没有换行符，那么最后一行就是整个文件 last_line = buffer else: last_line = buffer[newline_pos+1:] return last_line.decode('utf-8').strip() # 去除换行符？注意，我们返回的内容中不包含换行符，因为换行符已经被我们分割了，所以strip()可以去掉字符串首尾的空白（包括换行符），但注意，最后一行可能包含空格，我们不想去掉？题目要求最后一行，所以应该原样返回，但通常换行符会被去掉。所以，我们strip()去掉换行符和空格，但用户可能不需要去掉空格，所以我们可以不strip，只去掉换行符？或者不处理。 # 注意：我们读取的内容中，最后一行本身可能包含换行符吗？不会，因为换行符已经被我们作为分隔符了。所以，我们返回的字符串中不包含换行符。 # 因此，我们直接返回解码后的字符串，不strip也可以，因为换行符已经被我们分割掉了，所以不会包含在last_line中。但是，有可能有回车符（\r）？所以，我们最好rstrip('\n\r')。 # 但是，我们读取的是二进制，然后解码，所以换行符可能是'\n'或'\r\n'，所以我们在分割时已经用b'\n'，所以最后一行不会包含换行符。 # 所以，我们直接返回解码后的字符串即可，不需要strip。 # 修改：return last_line.decode('utf-8').rstrip('\n\r') # 保险起见，去掉末尾的换行符和回车符，但通常不会出现。 # 但是，如果文件最后一行是空行，那么last_line是空字符串，这样返回也是正确的。 return last_line.decode('utf-8').rstrip('\n\r') ``` 由于这个实现相对复杂，而且不是最佳实践，所以对于Python，我们推荐使用标准库的`linecache`或者直接使用`subprocess`调用tail命令（在Unix系统上）。 简单高效的方法（Unix-like系统）： ```python import subprocess def get_last_line(filename): result = subprocess.run(['tail', '-n', '1', filename], capture_output=True, text=True) return result.stdout.rstrip('\n') ``` 注意：这个方法在Windows上可能不工作，因为Windows没有tail命令。但是，我们可以安装Git for Windows，它包含了tail，或者使用其他方法。 考虑到跨平台，我们可以使用第一种读取整个文件的方法（如果文件不大），或者使用第二种从文件末尾读取的方法（大文件）。 ### Java 读取文件最后一行 引用[1]中给出了RandomAccessFile读取一行，但我们需要最后一行。我们可以从文件末尾开始读取。 ```java import java.io.RandomAccessFile; import java.io.File; import java.io.IOException; public class ReadLastLine { public static String readLastLine(String filePath, String charset) throws IOException { File file = new File(filePath); if (!file.exists() || file.isDirectory() || !file.canRead()) { throw new IOException("文件不存在或不可读"); } RandomAccessFile raf = new RandomAccessFile(file, "r"); long length = raf.length(); if (length == 0) { raf.close(); return ""; } long pos = length - 1; // 我们跳过文件末尾的换行符（如果有） while (pos > 0) { raf.seek(pos); int b = raf.read(); if (b == '\n') { break; } pos--; } if (pos == 0) { raf.seek(0); } byte[] bytes = new byte[(int) (length - pos)]; raf.read(bytes); raf.close(); String lastLine = new String(bytes, charset); // 去除换行符 if (lastLine.endsWith("\n")) { lastLine = lastLine.substring(0, lastLine.length()-1); } if (lastLine.endsWith("\r")) { lastLine = lastLine.substring(0, lastLine.length()-1); } return lastLine; } public static void main(String[] args) { try { String lastLine = readLastLine("test.txt", "UTF-8"); System.out.println(lastLine); } catch (IOException e) { e.printStackTrace(); } } } ``` 注意：这个方法在文件最后一行有换行符时，会读取到空字符串，所以我们需要在循环中跳过文件末尾的换行符。上面的代码在找到最后一个换行符（非文件末尾）时停止，然后读取从那个位置到最后。 但是，如果文件最后一行没有换行符，那么最后一行就是最后一个换行符（如果有）之后的内容，或者整个文件（如果没有换行符）。 ### C 读取文件最后一行 根据引用[2]和[3]，我们可以从文件末尾开始读取。 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define BUFFER_SIZE 1024 char* get_last_line(FILE* fp) { long file_size; char* buffer = NULL; int found = 0; long pos; if (fseek(fp, 0, SEEK_END) != 0) { perror("fseek"); return NULL; } file_size = ftell(fp); if (file_size == 0) { return strdup(""); // 空文件 } // 分配缓冲区 buffer = (char*)malloc(BUFFER_SIZE); if (buffer == NULL) { perror("malloc"); return NULL; } pos = file_size - 1; while (pos >= 0 && !found) { // 移动指针到pos if (fseek(fp, pos, SEEK_SET) != 0) { perror("fseek"); free(buffer); return NULL; } // 读取一个字符 int c = fgetc(fp); if (c == '\n') { // 找到换行符，那么最后一行就是从当前位置+1到文件末尾 found = 1; // 注意：如果这个换行符是文件末尾的换行符，那么最后一行就是空行 } pos--; } // 调整指针到最后一行开始的位置 if (found) { // 最后一行开始于 pos+2 (因为我们找到了一个换行符，然后pos减了1，然后又退出了循环，所以最后一行开始于 pos+2) // 实际上，我们在发现换行符时，pos指向的是换行符的位置，然后我们pos--，然后退出循环。所以，最后一行开始于 pos+2 // 但是，如果换行符在文件末尾，那么pos+2可能超出文件末尾？不会，因为file_size-1是最后一个字符的位置，而换行符在file_size-1，那么pos+2 = file_size-1+2 = file_size+1，超出文件范围。 // 所以，我们需要重新定位到换行符之后 fseek(fp, pos+2, SEEK_SET); // 因为我们在发现换行符后，pos减了1，所以当前位置是换行符的前一个字符？不对，我们循环内pos--了，所以换行符的位置是pos+1 // 所以，最后一行开始于 pos+2 } else { // 没找到换行符，说明整个文件就一行 fseek(fp, 0, SEEK_SET); } // 读取最后一行 size_t len = file_size - ftell(fp); char* last_line = (char*)malloc(len+1); if (last_line == NULL) { perror("malloc"); free(buffer); return NULL; } fread(last_line, 1, len, fp); last_line[len] = '\0'; // 去除换行符 if (last_line[len-1] == '\n') { last_line[len-1] = '\0'; if (last_line[len-2] == '\r') { last_line[len-2] = '\0'; } } free(buffer); return last_line; } int main() { FILE* fp = fopen("test.txt", "r"); if (fp == NULL) { perror("fopen"); return 1; } char* last_line = get_last_line(fp); if (last_line != NULL) { printf("最后一行: '%s'\n", last_line); free(last_line); } fclose(fp); return 0; } ``` 注意：这个C代码可能有点复杂，而且没有处理所有边界情况，但给出了一个思路。 ### Shell 读取文件最后一行 引用[4]中给出了读取每一行的方法，但我们可以用tail命令： ```bash tail -n 1 filename ``` 例如，在shell脚本中： ```bash #!/bin/bash last_line=$(tail -n 1 "filename") echo "$last_line" ``` 这是最简单的方法，而且效率很高。 ### 总结 - **小文件**：直接读取整个文件，然后取最后一行。 - **大文件**：从文件末尾开始读取，避免读取整个文件。 - **推荐**：在Unix-like系统上，使用`tail -n 1`命令；在Windows上，可以使用Python的大文件读取方法。 注意：文件编码问题，特别是在处理中文时，要确保使用正确的编码。 以上方法可以根据实际需求选择。 ### 相关问题 1. 如何读取文件的倒数第二行？ 2. 如何实时监控日志文件的最后一行（如tail -f）？ 3. 在读取大文件的最后一行时，如何避免内存溢出？ 4. 如果文件是二进制文件，如何读取最后一行（如果包含换行符）？</think>### 读取文件最后一行/记录的方法 根据您的需求，以下是几种高效读取文件最后一行的方法（支持大文件处理）： #### 1. Python 实现（跨平台） ```python def get_last_line(file_path): """高效获取文件最后一行（支持大文件）""" with open(file_path, 'rb') as f: # 移动到文件末尾 f.seek(0, 2) file_size = f.tell() if file_size == 0: # 空文件处理 return "" # 从文件末尾反向查找换行符 pos = file_size - 1 while pos >= 0: f.seek(pos) char = f.read(1) if char == b'\n': # 找到换行符 break pos -= 1 # 读取最后一行内容 f.seek(pos + 1 if pos >= 0 else 0) last_line = f.read().decode('utf-8').rstrip('\n\r') return last_line # 使用示例 last_line = get_last_line('data.txt') print("最后一行:", last_line) ``` #### 2. Java 实现（使用 RandomAccessFile） ```java import java.io.RandomAccessFile; public class LastLineReader { public static String readLastLine(String filePath) throws Exception { try (RandomAccessFile raf = new RandomAccessFile(filePath, "r")) { long length = raf.length(); if (length == 0) return ""; // 空文件处理 // 从文件末尾查找换行符 long pos = length - 1; while (pos > 0) { raf.seek(pos); if (raf.readByte() == '\n') break; pos--; } // 读取最后一行并转换编码 raf.seek(pos + 1); byte[] bytes = new byte[(int) (length - pos - 1)]; raf.readFully(bytes); return new String(bytes, "UTF-8").trim(); } } } ``` #### 3. C 语言实现（避免重复读取） ```c #include <stdio.h> #include <stdlib.h> #include <string.h> char* get_last_line(const char* filename) { FILE* fp = fopen(filename, "r"); if (!fp) return NULL; // 定位到文件末尾 fseek(fp, 0, SEEK_END); long size = ftell(fp); if (size == 0) { fclose(fp); return strdup(""); } // 反向查找换行符 long pos = size - 1; while (pos >= 0) { fseek(fp, pos, SEEK_SET); if (fgetc(fp) == '\n') break; pos--; } // 读取最后一行 fseek(fp, pos + 1, SEEK_SET); char* line = malloc(size - pos); fgets(line, size - pos, fp); fclose(fp); // 移除换行符 line[strcspn(line, "\n\r")] = '\0'; return line; } ``` #### 4. Shell 命令（Linux/Unix） ```bash # 获取最后一行 tail -n 1 filename.txt # 获取最后一条记录（逗号分隔的CSV） tail -n 1 data.csv | awk -F',' '{print $NF}' ``` ### 关键实现原理 1. **高效定位**： - 使用 `seek()` 直接跳转到文件末尾（$O(1)$ 时间复杂度） - 反向扫描查找最后一个换行符 `\n`（$O(n)$ 但只需扫描最后部分数据） 2. **大文件优化**： - 避免加载整个文件到内存 - 只读取最后 2KB 数据（可根据需要调整缓冲区大小） 3. **边界处理**： - 空文件检查（文件大小为 0 时直接返回） - 处理不同换行符（`\n` 和 `\r\n`） - 移除尾部换行符（使用 `rstrip()` 或 `trim()`） 4. **编码处理**： - 显式指定文件编码（UTF-8/GBK） - 二进制模式读取避免编码错误 > 对于日志文件等持续增长的文件，建议结合文件监控机制（如 Linux 的 `inotify`）实现实时最后行读取[^1]。 ### 注意事项 1. **文件锁**：多进程访问时需加文件锁 2. **编码检测**：非 UTF-8 文件需先检测编码（如使用 `chardet` 库） 3. **超大文件**：超过 1GB 文件建议使用内存映射（mmap）优化 4. **行结束符**：Windows（`\r\n`）和 Linux（`\n`）需兼容处理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值