文章目录
- [分页「向上取整」公式 `(total + size - 1) / size` 的完整推导](#分页「向上取整」公式
(total + size - 1) / size的完整推导) -
- 一、问题:分页为什么需要「向上取整」
- 二、带余除法:先把问题拆清楚
- [三、技巧:加上 `(size-1)` 再整除](#三、技巧:加上
(size-1)再整除) - [四、验证:`k = size-1` 对所有 r 都成立](#四、验证:
k = size-1对所有 r 都成立) - [五、核心困惑:为什么推导 k 时「只看 r=0 和 r=1」?](#五、核心困惑:为什么推导 k 时「只看 r=0 和 r=1」?)
-
- [那 r=2,3,...,size-1 为什么不用管?](#那 r=2,3,…,size-1 为什么不用管?)
- 数轴直观图(一眼看懂)
- 六、一个好记的类比:装鸡蛋
- [七、为什么不用 `Math.ceil`?(附可运行对比)](#七、为什么不用
Math.ceil?(附可运行对比)) - [八、为什么 size=0 会出问题](#八、为什么 size=0 会出问题)
- 九、一句话总结
分页「向上取整」公式 (total + size - 1) / size 的完整推导
本文解释分页里计算总页数的常见写法
pages = (total + size - 1) / size;为什么成立,重点讲清一个常见困惑:「推导时为什么只看余数 r=0 和 r=1?」阅读顺序:问题 → 拆解 → 技巧 → 验证 → 边界分析(核心)→ 类比 → 总结。
一、问题:分页为什么需要「向上取整」
有 total 条数据,每页放 size 条,问需要几页?
举例:total=25,size=10。
- 25 条 = 10 + 10 + 5,需要 3 页(最后 5 条也要占一页)。
- 数学上就是
pages = ceil(25 / 10) = ceil(2.5) = 3(向上取整)。
麻烦在于 :Java 的整数除法是向下取整(直接砍掉小数):
java
25 / 10 == 2 // 不是 3!少算了一页
所以直接用 total / size 会少算页数 。我们需要一个纯整数运算的技巧,把「向下取整」变成「向上取整」------这就是 + (size - 1) 的由来。
二、带余除法:先把问题拆清楚
任何除法都能写成:
total = q * size + r 其中 0 <= r < size
q = total / size(整除的商)= "装满的完整页数"r = total % size(余数)= "最后不满一页的零头"
正确的页数规则很直白:
r = 0(刚好装满,没零头)→ 页数 =qr > 0(有零头)→ 页数 =q + 1(零头也得占一页)
⚠️ 关键澄清 :这里的
r可以是0, 1, 2, ..., size-1中的任意一个 (size=10 时,r 可以是 0~9)。r 并不是只能取 0 或 1。 这是最容易误解的点,先记住这句。
三、技巧:加上 (size-1) 再整除
我们想用一个公式一步算出上面的规则。设要加的偏移量为 k,公式是:
pages = (total + k) / size
把 total = q*size + r 代进去:
(q*size + r + k) / size
= q + (r + k) / size ← 因为 q*size 能被 size 整除,直接提出 q
于是问题缩小 成:(r + k) / size 这一小截,能不能自动做到「r=0 时给 0,r>0 时给 1」?
只要选对 k,就能。答案剧透:k = size - 1。下面先验证它对,再讲为什么推导时只看 r=0 和 r=1。
四、验证:k = size-1 对所有 r 都成立
公式变成 pages = q + (r + size - 1) / size。分两种情况:
情况 A:r = 0
(0 + size - 1) / size = (size - 1) / size
因为 size - 1 < size,整数除法结果为 0 → pages = q ✓(刚好整除,不多页)
情况 B:1 <= r <= size-1(有零头)
(r + size - 1) / size
- 最小(r=1):
(1 + size - 1)/size = size/size = 1 - 最大(r=size-1):
(2*size - 2)/size,因为2size-2 < 2size,整数除法结果为 1 - 所以恒等于 1 →
pages = q + 1✓(有零头,多一页)
用 size=10(k=9)把 r 从 0 到 9 全列出来验证:
| r | total 示例 | total + 9 | (total+9)/10 | pages | 对吗 |
|---|---|---|---|---|---|
| 0 | 20 | 29 | 2 | q=2 | ✅ |
| 1 | 21 | 30 | 3 | q+1=3 | ✅ |
| 2 | 22 | 31 | 3 | q+1=3 | ✅ |
| 3 | 23 | 32 | 3 | q+1=3 | ✅ |
| ... | ... | ... | ... | ... | ✅ |
| 9 | 29 | 38 | 3 | q+1=3 | ✅ |
所有 r 都正确 。注意 r=2~9 全都得到 q+1------这已经暗示了「只要 r=1 能进位,更大的 r 当然也能」。
一键运行验证(把上表跑出来)
不想手算?用一段循环把 r=0~9 全部验证一遍:
java
public class PagingVerify {
public static void main(String[] args) {
long size = 10;
long q = 2; // 完整页数固定为 2,方便对照
for (long r = 0; r < size; r++) {
long total = q * size + r; // 构造余数为 r 的 total:20,21,...,29
long pages = (total + size - 1) / size; // 整数向上取整公式
long expect = (r == 0) ? q : q + 1; // 期望:无余数=q,有余数=q+1
System.out.printf("r=%d total=%d 公式=%d 期望=%d 一致=%b%n",
r, total, pages, expect, pages == expect);
}
}
}
输出:
r=0 total=20 公式=2 期望=2 一致=true
r=1 total=21 公式=3 期望=3 一致=true
r=2 total=22 公式=3 期望=3 一致=true
r=3 total=23 公式=3 期望=3 一致=true
r=4 total=24 公式=3 期望=3 一致=true
r=5 total=25 公式=3 期望=3 一致=true
r=6 total=26 公式=3 期望=3 一致=true
r=7 total=27 公式=3 期望=3 一致=true
r=8 total=28 公式=3 期望=3 一致=true
r=9 total=29 公式=3 期望=3 一致=true
10 行 一致 全为 true → 公式对每个余数都正确。想验证别的每页条数,把 size 改一下即可(如 size=3,r 会自动跑 0~2)。
五、核心困惑:为什么推导 k 时「只看 r=0 和 r=1」?
这里是最容易卡住的地方。关键是换一个视角:
我们不是在「逐个测试 r」,而是在「解方程求 k」------k 要加多少才合适?
k 必须同时满足两个方向相反的要求:
要求 A(r=0 时,不能进位)
刚好整除时不能多算一页:
(0 + k) / size 必须 = 0 → k < size → k <= size - 1
这给了 k 的上限。
要求 B(r=1 时,必须进位)
哪怕只有 1 个零头也要多算一页:
(1 + k) / size 必须 = 1 → 1 + k >= size → k >= size - 1
这给了 k 的下限。
📌 严谨补充:要不要写上界
1+k < 2·size? 严格说应该写,但它是冗余、不起约束作用 的。(1+k)/size = 1的完整含义是size ≤ 1+k < 2·size(既要 ≥ size 才商得到 1,又要 < 2·size 才不至于商到 2)。上面只写下界1+k ≥ size,是因为这一步只需要它来卡出 k 的下限 。那个上界1+k < 2·size(即k ≤ 2·size-2)永远不会成为约束:要求 A 已给出更紧的上界k ≤ size-1(size-1 比 2·size-2 更小)。最终解k = size-1代入得1+k = size,显然size < 2·size,上界自动满足。所以补与不补都不改变结论。
两个要求一夹:
k <= size - 1 且 k >= size - 1 → k = size - 1(唯一解)
那 r=2,3,...,size-1 为什么不用管?
因为 (r + k) / size 关于 r 是单调不减 的------r 越大,r+k 越大,越容易越过 size 这条「进位线」。
- r=1 是「最小的正零头」,是最难进位的 (最需要 k 来帮它凑够一页)。既然连最难的 r=1 都能被顶上去,那 r=2、3、...(零头更多、离满页更近)当然更容易被顶上去,不用一个个查。
- r=0 是「最容易被误伤」的(它一点零头都没有,最不该多算页)。只要连 r=0 都不会被 k 顶上去,就说明 k 没加过头。
所以 r=0 和 r=1 是两个「最苛刻、最极端」的边界:
- r=0 卡住「k 不能太大」(否则误进位);
- r=1 卡住「k 不能太小」(否则漏进位)。
这两个最极端的约束一夹,k 就被唯一确定了;中间的 r 因为单调性自动满足 。这叫边界分析法------不是「r 只能取 0 或 1」,而是「搞定两个极端,中间全搞定」。
数轴直观图(一眼看懂)
把每个 r 都加上 k = size-1,看结果有没有越过 size 这条线(越过 = 多算一页)。以 size=10、k=9 为例:
r : 0 1 2 3 4 5 6 7 8 9
r+9: 9 10 11 12 13 14 15 16 17 18
│ └──────────── 全部 ≥ 10,越过线 ───────────┘
差1越线
整除10: 0 1 1 1 1 1 1 1 1 1
只有 r=0(加完是 9,差 1 才到 10)停在线下 不进位;其余 r>=1 加完都 >=10 越过线 进位,且都 <20 所以只进 1 位。完全符合「r=0 给 0,r>0 给 1」。
六、一个好记的类比:装鸡蛋
size 个鸡蛋装满一盒。total 个鸡蛋要几盒?
- 刚好装满 q 盒(r=0)→ 就 q 盒。
- 有零头(r>=1)→ 再拿一个盒子装零头 → q+1 盒。
+ (size-1) 的技巧 = 先给每盒「补上 size-1 个虚拟鸡蛋」(假装差一点点就满):
- r=0(本来就满):补 size-1 个 → 还差 1 个才满一盒 → 不多算盒 ✓
- r=1(有 1 个真零头):1 + (size-1) = size 个 → 刚好凑满一盒 → 多算 1 盒 ✓
- r=5:5 + (size-1) = size+4 → 满盒还多 4 个(4 个不够再满一盒)→ 多算 1 盒 ✓
一句话:补 size-1 个虚拟鸡蛋,正好让「任何真零头」都能凑成一整盒,而「没零头」的补完还差一个、凑不成。
七、为什么不用 Math.ceil?(附可运行对比)
算向上取整,很多人第一反应是 Math.ceil:
java
(long) Math.ceil((double) total / size) // 能算对常规数据,但要转 double 再转回 long
它能用,但有两处不如整数版:① 要来回转 double/long;② double 只有 52 位尾数(约 15~16 位有效数字),total 超过 253(≈9×1015)后连整数都存不精确,可能算错。
可运行对比代码
java
public class CeilDemo {
// 整数版(推荐):纯整数运算,无任何精度风险
static long pagesInt(long total, long size) {
return (total + size - 1) / size;
}
// Math.ceil 版:要经过 double
static long pagesCeil(long total, long size) {
return (long) Math.ceil((double) total / size);
}
public static void main(String[] args) {
// 1) 常规数据:两者一致
System.out.println(pagesInt(25, 10)); // 3
System.out.println(pagesCeil(25, 10)); // 3
// 2) 先看 double 的精度极限:超过 2^53 的整数存不下
long big = 9007199254740993L; // 2^53 + 1
System.out.println(big); // 9007199254740993 long 精确
System.out.println((long) (double) big); // 9007199254740992 转 double 丢了 1!
// 3) 大数分页:两版开始不一致
long total = 9007199254740993L; // 2^53 + 1
long size = 9007199254740992L; // 2^53
System.out.println(pagesInt(total, size)); // 2 正确:略多于 1 页 → 2 页
System.out.println(pagesCeil(total, size)); // 1 错误:double 把 total 截成 2^53,算成整 1 页
}
}
运行输出:
3
3
9007199254740993
9007199254740992 ← 转 double 后 +1 丢了
2 ← 整数版正确
1 ← Math.ceil 版少算一页
解读:
- 第 2 段证明根因------
(double) big把2^53+1变成了2^53,精度已经丢了。 - 第 3 段里
total只比size多 1(真实页数应是 2),但Math.ceil版因为total被截成和size相等,算出1.0→ 1 页,少算一页;整数版始终正确。
诚实说明:真实分页会踩到吗?
几乎不会。 触发精度问题需要 total 超过 2^53 ≈ 9×10^15(9 千万亿条数据),现实业务远达不到,所以常规数据下两版结果一致。
但仍推荐整数版,因为它:
- 是纯整数运算 ,没有 double 转换、零精度风险(不管数据多大都对);
- 更快(整数运算 vs 浮点 +
Math.ceil调用); - 更简洁,是业界惯用写法。
唯一要注意的极端:
total大到接近Long.MAX_VALUE时,total + size - 1可能整数溢出。正常业务量遇不到,可忽略(真要用超大数可换BigInteger,或先判total % size再决定要不要 +1)。
八、为什么 size=0 会出问题
公式里 k = size-1,最终要算 (total + size - 1) / size。一旦 size = 0,就是除以 0,Java 整数除法会直接抛异常:
java
long total = 25, size = 0;
long pages = (total + size - 1) / size; // 运行到这行↓
// java.lang.ArithmeticException: / by zero
所以每页条数 size 必须 >= 1。堵这个洞有两种常见做法,通常一起用:
做法一:入参校验(推荐,把非法值挡在门外)
给分页查询参数的 size 字段加校验注解,并给一个安全默认值:
java
public class PageQuery {
/** 当前页码,从 1 开始 */
@Min(value = 1, message = "页码最小为1")
private Long current = 1L;
/** 每页条数:默认 10,最小 1(防止 size=0 除零),最大 100(防止超大值拖垮数据库) */
@Min(value = 1, message = "每页条数最小为1")
@Max(value = 100, message = "每页条数最大为100")
private Long size = 10L;
}
@Min(1):size传 0 或负数会被校验拦下(配合 Controller 上的@Valid,直接返回"每页条数最小为1"的错误)。- 默认值
= 10L:前端不传size时用 10,也不会是 0。
做法二:计算时兜底(防御式编程,双保险)
即便有校验,计算总页数处也可以再兜一层,防止 size 因其它途径变成 0:
java
// 兜底:size 非法时退回默认每页 10 条,避免除零
if (size <= 0) {
size = 10L;
}
long pages = (total + size - 1) / size; // 此时 size 一定 >= 1,不会除零
小结:
size = 0→ 除零 →ArithmeticException。用「入参@Min(1)校验 + 默认值」把非法值挡在外面,再在计算处if (size <= 0)兜底,双保险即可根除这个边界问题。
九、一句话总结
r(余数)可以是0 ~ size-1的任意值,不是只有 0 或 1。- 推导
k时只看 r=0 和 r=1 ,是因为它们是两个最极端的边界 :r=0 要求「k 不能太大」(k <= size-1),r=1 要求「k 不能太小」(k >= size-1),一夹就得到唯一解k = size-1;其余 r 由「r 越大越容易进位」的单调性自动满足。 - 所以
pages = (total + size - 1) / size对所有情况都等于向上取整ceil(total/size)。