零散知识点

string小白

已于 2025-03-06 13:37:17 修改

阅读量882

点赞数 19

文章标签： java 开发语言

于 2024-12-24 14:01:08 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_73782048/article/details/142379474

版权

构造方法

1. 概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

  public class Date {

         public int year;

         public int month;

         public int day;

         public void printDay(){

                 System.out.println(this.year+"/"+this.month+"/"+this.day);

         }

         public Date(int year,int month,int day){

                 this.year=year;

                 this.month=month;

                 this.day=day;

         }

         public static void main(String[] args) {

                 Date date=new Date(2023,3,22);

                 date.printDay();

         }

 }

构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

2. 特性

1. 名字必须与类名相同。
2. 没有返回值类型，设置为void也不行。
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)。

4. 构造方法可以重载

public class Date {
       public int year;
       public int month;
       public int day;
    
       public void printDay(){
              System.out.println(this.year+"/"+this.month+"/"+this.day);
       }

        //方法重载
    
        //无参的构造方法(用于对象属性值都相同)
       public Date(){
              this.year=2023;
              this.month=3;
              this.day=22;
       }
       //有参的构造方法（用于对象属性值不相同）
       public Date(int year,int month,int day){
              this.year=year;
              this.month=month;
              this.day=day;
       }

       public static void main(String[] args) {
              Date date=new Date();///传不传参都可以
              date.printDay();
       }
}

成员变量

成员变量=属性=字段（field）。这些是不同的称呼而已

成员变量是存在于类中的变量，类似于c语言中结构体的成员变量。

静态成员变量是在没有创建对象之前就进行了初始化

POJO的内在含义

：那些没有继承任何类、也没有实现任何接口，更没有被其它框架侵入的java对象。
它仅包含自身的属性以及自身属性的getter和setter方法，这意味者POJO可以方便的从一个框架迁移到另一个框架中，或者框架升级也会对代码毫无影响，因此而得到复用。

变量的分类

按变量的数据类型划分
基本类型变量：保存的是真实的数字、字符等数据。
引用类型变量：保存的也是数据，只不过这个数据比较特殊，是对象的引用值(相当于对象的内存地址)

按声明位置划分
局部变量：方法或语句块内部定义的变量
全局变量：方法外部、类的内部定义的变量

命名规范

【变量名、方法名】：首字母小写，其余单词首字母大写。这种命名方式也称为小驼峰原则
例如：title，void payTime()
【类名】：首字母大写，其余单词首字母大写。这种命名方式也称为大驼峰原则
例如：class UserManager {}
【包名】：全部小写，用英文的"."隔开
例如：com.qfedu
【项目名】：全部小写
例如：studentsys
【常量】：全部大写，单词之间用_隔开
例如：public static final int NO_LOGIN_STATUS = 401

关于后端六个文件的个人理解：

TestMapper.xml：动态sql操作文件，描述了系统和数据库的映射关系
因为在namespace里填写了mapper接口<mapper namespace="com.ruoyi.project.system.test.mapper.TestMapper">所以编译这个文件可以检查所有相关class和interface（吗？）
TestMapper.java：dao层接口文件，方法名和 xml 中定义的每个 statement 的 id 同名，输入参数类型和 xml 中定义的 statement 的parameterType 类型相同，返回类型和 xml 中定义的 statement 的resultType 类型相同
ITestService.java：service层接口文件，定义方法的参数、返回值
TestServiceImpl.java：service层类文件，实现ITestService接口的方法
MyTestController.java：controller层类文件，接收前端请求，调用service层方法实现
Test.java：domain层类文件，和数据库中的表一一对应的JavaBean，实现set和get方法

面向对象内容

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

同一种方法在同一个类中调用叫重载，不同类中调用叫重写

重写Override是父类与子类之间多态的关系，而重载Overload是一个类中多态性的表现
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

1、什么是SQL注入

SQL 注入就是指 Web 应用程序对用户输入的数据合法性没有过滤或者是判断，攻击者可以在Web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步得到相应的数据信息。

2、SQL注入产生的条件

传递给后端的参数是可以控制的
参数内容会被带入到数据库查询
变量未存在过滤或者过滤不严谨

回调函数

一般写程序是你调用系统的API，如果把关系反过来，你写一个函数，让系统调用你的函数，那就是回调了，那个直接被系统调用的函数就是回调函数（间接的不算）

取地址符 &

导包

我们每次在一个项目需要 jar 包时都需要去进行导入，但是有时我们希望某个 jar 包被所有项目共用，这时我们就需要将 jar 包导入到 JRE System Libraries 中，我们有很多途径来达到这一目的，在这里展示的是通用的方式：首先选中 eclipse 工具栏的 project > Properties > 选中 Java Build Path 的 Libraries 栏下的 JRE System Library > Add External JARs > 添加相应的 jar 包后 > Apply and Close 即可

final关键字

final关键字可以用来修饰变量、成员方法以及类。

1. 修饰变量或字段，表示常量(即不能修改)
final int a = 10;
a = 20; // 编译出错
2. 修饰类：表示此类不能被继承

`public static` 是 Java 等面向对象编程语言中的修饰符，它用于声明成员变量或方法。当这两个关键字同时出现在一起时，它们有以下含义：

1. **访问级别**：`public` 表示该成员变量或方法可以被程序包内外的所有类访问，无论是否在同一包内。

2. **静态成员**：`static` 指定这是一个类级别的属性或方法，而不是实例级别的。这意味着你不需要创建类的对象就可以直接通过类名访问它，比如静态方法可以直接在类名后面调用，而不需要创建对象。

例如，`public static int COUNT = 0;` 定义了一个类级别的整型常量COUNT，所有类的实例都会共享这个计数。

抽象类

在Java中，抽象类是一种特殊的类，它不能被实例化，它的主要目的是为了提供一种蓝图或者说是一种模板，供其他类去继承。有以下几个原因促使Java引入抽象类：

1. **方法模板**：抽象类可以包含抽象方法（无方法体的方法），这些方法由其子类具体实现，使得抽象类成为了一个接口的集合。

2. **共享属性**：抽象类可以包含常量、字段和非抽象方法，这些可以直接被所有子类访问，避免了代码的冗余。

3. **代码结构**：通过抽象类，可以组织相关的类，并确保它们具有一些共同的行为。这种方式有助于代码的模块化和分类。

4. **创建接口**：抽象类实际上是一种特殊的接口，它可以包含变量和方法，而接口只能包含常量和抽象方法。

5. **防止滥用**：如果一个类不需要被实例化，而是作为其他类的父类，那么将其声明为抽象类可以强制开发者实现某些方法，避免空壳类的出现。

方法体

是程序设计中的一个概念，它是指在定义函数或方法时，包含的具体实现步骤、操作或逻辑代码部分。在函数或方法定义中，通常会有一对大括号 {} 来包围这一块内容，这部分就是方法体。当你调用这个方法时，程序会执行其中的代码来完成特定的任务。例如，在Java中：
public void printMessage(String message) {
    System.out.println(message);
}
在这个例子中，printMessage 是一个方法，它的方法体就是 System.out.println(message) 这一行代码，当传入不同的字符串时，会打印出对应的内容。

方法体是可以设置为空的，尤其在一些不需要执行任何实际操作或者功能非常简单的场景下。在编程语言中，比如Java，如果你定义了一个无操作的方法，你可以直接将其声明但不提供具体的实现，例如：
public void doNothing() {}
在这种情况下，doNothing() 就是一个空方法体，当你尝试调用它时，实际上不会执行任何代码。这在创建抽象类或者接口时常见，作为其他实现类需要覆盖的基础方法，即使它们目前没有任何实际作用。

多态

是同一个父类方法不同的子类调用

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
 
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class Dog extends Animals{
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

持久化操作

是指将程序运行中的数据保存到某种存储介质（如硬盘、数据库等），以便在程序关闭或系统崩溃后能够恢复之前的状态。这在软件开发中非常重要，特别是对于需要长期存储用户数据的应用。常见的持久化技术包括数据库操作（比如SQL、NoSQL）、文件I/O、缓存机制以及序列化和反序列化等。通过持久化，应用程序可以在用户下次访问时快速加载先前的数据，提供无缝的用户体验。

‌在Eclipse中使用不同版本的JDK编译项目，可以通过以下步骤进行设置‌：

‌全局JDK版本设置‌：

打开Eclipse，选择Window -> Preferences -> Java -> Installed JREs。
在这里可以添加、编辑或删除已安装的JREs。点击Add按钮，选择JDK的安装路径，完成添加后，可以选择一个作为默认的JRE。

‌项目特定JDK版本设置‌：

右键点击项目，选择Properties -> Java Compiler。
在这里可以设置项目的编译版本。勾选Enable project specific settings，然后选择合适的JDK版本。这样，项目的编译版本将覆盖全局设置‌12。

‌修改eclipse.ini文件‌：

如果需要在启动时指定JDK版本，可以在eclipse.ini文件中添加如下行：-vm C:\path\to\your\jdk\bin\javaw.exe。这样，每次启动Eclipse时都会使用指定的JDK版本‌3。

通过以上步骤，可以灵活地在Eclipse中使用不同版本的JDK进行项目编译，满足不同开发需求。

cd命令执行跨盘时，先进行转盘："d:" 注意：号

eclipse方便显示代码来源

对象的 key 是什么

在编程中，特别是面向对象编程中，"key"通常指对象的属性或者键(Key)。它是一个标识符，用于在数据结构（如哈希表、字典或映射）中唯一地标识和访问一个特定值。

例如，在JavaScript的对象中，你可以通过键来获取或设置对应的值：
let obj = {name: 'John', age: 30};
// 使用键 'name' 访问值
let name = obj.name; // 输出 'John'
// 修改键对应的值
obj.age = 31;

JSON对象

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。JSON对象由键值对组成，类似于JavaScript中的对象字面量。它采用文本形式表示数据，常用大括号 { 表示对象开始，} 表示结束，每个键值对之间用逗号 , 分隔，键通常是字符串，用冒号 : 分割键和对应的值，值可以是多种数据类型，如字符串、数字、布尔值、数组（[]）、null，以及嵌套的对象和数组。

例如：
{
  "name": "John",
  "age": 30,
  "city": "New York",
  "hobbies": ["reading", "gaming"],
  "isEmployed": true
}

Java中如何使用正则表达式进行其他类型的匹配？

在Java中，正则表达式是一种强大的工具，用于处理文本模式匹配。除了检测是否包含数字（如上述的 \d+），还可以做很多其他类型的匹配。以下是一些常见的用途：

邮箱地址：String email = input.getText(); Pattern pattern = Pattern.compile("\\b[A-a-Zz0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\\b"); Matcher matcher = pattern.matcher(email);
URLs：Pattern pattern = Pattern.compile("(http|https)://[a-zA-Z0-9\\.\\-]+(\\.[a-zA-Z]{2,3})+(\\/\\S*)?");
日期时间：Pattern pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}");

要使用这些模式，首先需要创建一个Pattern对象，然后通过matcher()方法与输入字符串匹配，并检查Matcher对象的matches()、find()或split()等方法结果。

正则表达式（Regular Expression，简称正则或 regex）

正则表达式是一种用于匹配、搜索、替换和处理字符串的工具。通过定义规则（或模式）来描述字符串的某种特征或结构，可以应用于文本的查找、提取、替换、验证等操作。正则表达式在编程、文本处理、数据清洗、日志分析等领域有广泛的应用。

正则表达式的基本概念

正则表达式由一系列字符组成，这些字符定义了某种匹配模式。它包括普通字符、特殊字符以及它们的组合。正则表达式的作用非常强大，能够处理复杂的文本操作任务。

常见的正则表达式元素

普通字符（Literal characters）

普通字符就是直接匹配的字符，例如：

a：匹配字母 "a"。
1：匹配数字 "1"。

特殊字符（Metacharacters）

正则表达式中有一些特殊字符，用来定义更复杂的匹配规则：

.：匹配任意单个字符（除了换行符）。
示例：a.b 可以匹配 "acb"、"axb"，但不匹配 "ab"。

\：转义符，用来转义后面紧跟的字符，使其失去特殊含义或赋予普通字符特殊含义。例如：\. 匹配点字符 "."，\d 匹配数字。
示例：\. 匹配字面上的 "." 字符。

^：匹配字符串的开始位置。
示例：^abc 匹配以 "abc" 开头的字符串（如 "abcdef"）。

$：匹配字符串的结束位置。
示例：abc$ 匹配以 "abc" 结尾的字符串（如 "helloabc"）。

[]：字符类，用于匹配方括号内的任意字符。
示例：[aeiou] 匹配任何一个元音字母（如 "a", "e", "i"）。

|：表示 "或" 操作符，用于匹配左边或右边的表达式。
示例：a|b 匹配 "a" 或 "b"。

()：用于分组，将表达式的部分组合在一起。
示例：(abc|def) 匹配 "abc" 或 "def"。

量词（Quantifiers）

量词用于指定前一个字符或子表达式出现的次数：

*：匹配前一个字符或子表达式出现 0 次或多次。
示例：a* 匹配零个或多个 "a"（如 "", "a", "aa"）。

+：匹配前一个字符或子表达式出现 1 次或多次。
示例：a+ 匹配至少一个 "a"（如 "a", "aa"）。

?：匹配前一个字符或子表达式出现 0 次或 1 次。
示例：a? 匹配零个或一个 "a"（如 "", "a"）。

{n}：匹配前一个字符或子表达式恰好出现 n 次。
示例：a{3} 匹配恰好三个 "a"（如 "aaa"）。

{n,}：匹配前一个字符或子表达式至少出现 n 次。
示例：a{2,} 匹配至少两个 "a"（如 "aa", "aaa"）。

{n,m}：匹配前一个字符或子表达式出现 n 次到 m 次。
示例：a{2,4} 匹配 2 到 4 个 "a"（如 "aa", "aaa", "aaaa"）。

字符类（Character classes）

字符类用于匹配特定类型的字符：

\d：匹配任何数字字符，等价于 [0-9]。
示例：\d+ 匹配一个或多个数字（如 "123", "456"）。

\w：匹配字母、数字和下划线，等价于 [A-Za-z0-9_]。
示例：\w+ 匹配一个或多个字母、数字或下划线（如 "abc123", "hello_123"）。

\s：匹配任何空白字符（包括空格、制表符、换行符等）。
示例：\s+ 匹配一个或多个空白字符（如 " "、"\t"）。

\D：匹配任何非数字字符，等价于 [^0-9]。
示例：\D+ 匹配一串非数字字符（如 "abc"）。

\W：匹配非字母、数字和下划线字符，等价于 [^A-Za-z0-9_]。
示例：\W+ 匹配一个或多个非字母数字字符（如 "!", "@", "#"）。

\S：匹配任何非空白字符。
示例：\S+ 匹配一个或多个非空白字符。

否定字符集（Negated Character Set）

否定字符集通过 [^] 来匹配不在指定字符集中的任意字符。例如：

[^aeiou]：匹配任何非元音字母。
示例：[^aeiou] 匹配 "b", "c", "x" 等，但不匹配 "a", "e", "i", "o", "u"。

[^0-9]：匹配任何非数字字符。
示例：[^0-9] 匹配字母、符号等，但不匹配数字。

定位符（Anchors）

定位符用于指定匹配的位置：

^：匹配字符串的开始。
示例：^abc 匹配以 "abc" 开头的字符串（如 "abcdef"）。

$：匹配字符串的结束。
示例：abc$ 匹配以 "abc" 结尾的字符串（如 "helloabc"）。

\b：匹配单词边界。
示例：\bword\b 匹配完整的单词 "word"，而不会匹配如 "wording" 中的 "word"。

正则表达式示例
匹配数字
正则表达式：\d+ 匹配一个或多个数字。
示例：

"123" 匹配
"4567" 匹配
"abc" 不匹配

匹配电子邮件地址
正则表达式：^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
用于匹配简单的电子邮件地址。
示例：

"example@domain.com" 匹配
"user123@gmail.com" 匹配
"invalid-email.com" 不匹配

匹配电话号码
正则表达式：^\d{3}-\d{3}-\d{4}$
用于匹配形如 "123-456-7890" 的电话号码。
示例：

"123-456-7890" 匹配
"1234567890" 不匹配
"123-4567-890" 不匹配

匹配日期（格式：YYYY-MM-DD）
正则表达式：^\d{4}-\d{2}-\d{2}$
用于匹配形如 "2024-12-24" 的日期。
示例：

"2024-12-24" 匹配
"2024-13-24" 不匹配（月份不能超过 12）
替换文本
正则表达式：将文本中的所有空格替换为下划线。
示例：
text.replace(/\s+/g, "_")
将 "hello world" 替换为 "hello_world"。
正则表达式应用场景

数据验证
用于验证输入数据是否符合预期格式，如验证电子邮件、手机号、日期等。

文本搜索与替换
在大量文本中查找并替换匹配的内容。

日志分析
从日志文件中提

取关键字或信息，分析系统错误或状态。

网页爬虫
提取网页中的特定数据，如标题、链接、图片等。

正则表达式的优缺点

优点

强大灵活：可以高效地处理各种复杂模式匹配。
简洁高效：在处理字符串任务时，比传统方法更加简洁和高效。
广泛支持：几乎所有编程语言和文本编辑器都支持正则表达式。

缺点

学习曲线陡峭：正则表达式语法较为复杂，初学者需要时间掌握。
可读性差：没有注释或格式化时，正则表达式的可读性较差。
调试困难：复杂的正则表达式较难调试，错误排查较为麻烦。

总结

正则表达式是非常强大的工具，适用于各种文本匹配和操作任务。掌握正则表达式可以帮助开发者高效地进行数据验证、文本搜索、替换及日志分析等任务。尽管其语法复杂，初学者可能需要一些时间适应，但掌握正则表达式后，它将成为提升编程效率的有力武器。

java键盘获取数据方式

使用 Scanner:

import java.util.Scanner;

public class KeyboardInputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一些文字:");
        String userInput = scanner.nextLine(); // 读取一行用户输入
        System.out.println("你输入的是: " + userInput);
        scanner.close();
    }
}

使用 BufferedReader:

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class KeyboardInputExample {
    public static void main(String[] args) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一些文字:");
        String userInput = null;
        try {
            userInput = reader.readLine(); // 读取一行用户输入
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("你输入的是: " + userInput);
        reader.close();
    }
}

在Eclipse中设置默认编码的步骤

通常包括以下几步：

1. **打开Eclipse首选项**：点击菜单栏上的“Window” -> “Preferences”（或者在Mac上是“Eclipse” -> “Preferences”）。

2. **导航到编码设置**：在左侧的树形视图中，展开"General"，然后选择"Workspace"。

3. **设定文本文件编码**：在右侧的“Text file encoding”下拉菜单中，选择“Other”，然后在弹出的列表中选择“UTF-8”。

4. **应用并保存设置**：点击“Apply”然后“OK”以保存你的更改。现在，Eclipse应该会将UTF-8设为所有新创建文件的默认编码。

此外，还可以针对特定项目设置编码，而不是全局设置。在项目的“Properties”中，可以找到类似的文本文件编码选项进行修改。

文件夹名称排序

默认按照ASCII码排序，可用命名" "永远排在第一位，例如" .txt"，此文件不能用重命名生成，重命名生成的是".txt"（少空格），但可以用JAVA程序生成

for-each 循环遍历数组

for (实体类对象 : 列表) 语法中的 “对象” 变量名是可以修改的，修改后的名字不会影响原本的功能。它只是在循环中代表当前遍历到的集合元素的引用，因此你可以使用任何合法的变量名来代替对象。
 // 使用 for-each 循环遍历列表
 for (Marketzrxx market : marketzrxxList) {
     // 打印每个 Marketzrxx 对象的信息
     System.out.println("Market Name: " + market.getName() + ", Status: " + market.getStatus());
        }
for (Marketzrxx m : marketzrxxList) {
    // 打印每个 Marketzrxx 对象的信息
    System.out.println("Market Name: " + m.getName() + ", Status: " + m.getStatus());
}
以上两个结果相等
for (type var : collection) {
    // 在这里使用 var 进行相关操作
}
type：表示集合中元素的类型，或者数组中元素的类型。
var：在每次迭代时，var 会取到集合或数组中的每个元素。
collection：可以是一个数组、集合类（如 List, Set 等）或者任何实现了 Iterable 接口的对象。
public class ForEachExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 使用 for-each 循环遍历数组
        for (int num : numbers) {
            System.out.println(num);
        }
    }
}
int num : numbers 这里 num 会依次获取 numbers 数组中的每个元素，依次输出每个数字
int totalElements = 55;
int size = 10;

int totalPages = (int) Math.ceil((double) totalElements / size);
System.out.println(totalPages);  // 输出 6
Math.ceil()：Math.ceil() 是 Java 的一个数学函数，它会将输入的数字 向上取整，即不管小数部分是多少，都会进一位。比如，Math.ceil(2.1) 会返回 3。

(int)：最后， (int) 强制将浮动类型的结果转换为整数。这样做的原因是，Math.ceil() 返回的是 double 类型，但我们需要一个整数来表示页数。转换成 int 后，小数部分被舍弃。

55 / 10 结果为 5.5。
Math.ceil(5.5) 会返回 6，表示需要 6 页。

这个代码片段常用来计算分页总页数，确保即使数据总数不是页大小的整数倍，最后一页仍能容纳剩余的数据。