分页「向上取整」公式 `(total + size - 1) / size` 的完整推导

文章目录

分页「向上取整」公式 (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(刚好装满,没零头)→ 页数 = q
  • r > 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)。

相关推荐
装不满的克莱因瓶2 小时前
【从零搭建】AI大模型之ReactAgent智能体对接MCP实战
java·人工智能·ai·springai·mcp·springaialibaba
SimonKing3 小时前
AI Assistant被"隐藏"了?别慌,IDEA 2026.3 这波是换了个脑子
java·后端·程序员
Resean02233 小时前
SpringMVC 6+源码分析(九)异常处理
java·spring·springmvc
geats人山人海3 小时前
现代c++4.1
java·开发语言·c++
下一站春风里4 小时前
Spring IoC 控制反转 完整技术笔记
java·spring boot·笔记·spring
挖掘狂人4 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·后端·面试
codigger4 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·程序员·支付·java后端
Resean02234 小时前
SpringMVC 6+源码分析(十)数据绑定与类型转换
java·spring·springmvc
lw_zhang11014 小时前
爆肝一个月,Java 从入门到精通39 - 使用Log4j
java·单元测试·log4j