java基本程序设计结构总结

学习一门语言：（1）掌握它的表现形式（2）这些语言什么应用。

1.1关键字

1.关键字是被赋予了特殊含义的单词。

2.关键字特点：关键字所有字母都小写。

3.类名的每一个单词开头必须大写。

1.2标识符

1.标识符：

• 在程序中自定义的一些名称
• 由26个英文字母大小写，数字：0-9符号：_$组成
• 定义合法标识符规则：

（1）数字不可以开头

（2）不可以使用关键字

• java注意区分大小写
• 注意：在起名字的时候，为了提高阅读性，要尽量有意义。

1.3注释

1. 注释是用于注解说明解释程序的文字。可提高代码的阅读性。

2.//和/*~*/这两种注释多种语言都通用，java特有的注释：

   /**~*/(文档注释)：该注释可通过java工具Javadoc提取出来，生成一套以网页文件形式体现的该程序的说明文档。

3.单行注释可以嵌套多行注释，多行也可以嵌套单行。多行注释不能嵌套多行注释。

4.注释可以进行程序的调试。

5.注释不编译到字节码去。

6.编写代码时写注释是编码规范。

7.java程序都是以类的形式存在的，类的形式就是一个字节码文件最终体现。

8.代码仅仅是思想的一种体现形式。

1.4常量与变量

1.常量是不能改变的数据。

2.java中常量的6种分类：

• 整数常量
• 小数常量
• 布尔型常量（boolean）。较为特有，只有两个数值：true false。
• 字符常量。将一个数字字母或符号用单引号标识
• 字符串常量。用双引号标识。（ "" 没有内容的字符串或者空字符串）
• null常量。只有一个数值就是：null

3.对于整数：有四种表现形式：

• 二进制
• 八进制
• 十进制
• 十六进制

4.byte（字节）=八个二进制位，每个位叫做bit位。其表示的值是有限的。

5.计算机的内容都是以二进制表示的。

6.1k=1024字节；

7.八进制数：其实就是二进制位 3 个二进制位为一个八进制位。

十六进制：其实就是二进制中的 4 个二进制位为一个十六进制位

8.负数的二进制表现形式：对应的整数二进制取反，加1。凡是负数，它的二进制最高位是1。

9.一个整数在内存中通常是用4个字节表示的，32位。

10.变量的概念：

• 内存中的存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）
• 该区域的数据可以同一类型范围内不断变化

11.为什么定义变量：用来不断存放同一类型的常量，并可以重复使用。记录不确定的数据。

12.变量使用注意：

• 变量的作用范围（一对{}之间有效）
• 初始化值

13.定义变量的格式：

• 数据类型 变量名=初始化值；
• 注：格式是固定的，记住格式以不变应万变。

14.java是强类型的，要求变量只能存放同类型的常量。

15.java中的数据类型分为：

（1）基本数据类型：

• 数值型中的整数类型（byte（1字节）, short（2字节）, int（4个字节）, long（8个字节））
• 数值型的浮点类型（float（单精度，4字节）, double （双精度，8字节））
• 字符型（char（2字节））
• 布尔型（boolean）

（2）引用数据类型

• 类（class）
• 接口（interface）
• 数组（【】）

16.在定义时，整数默认为int类型，小数默认double类型。

17.一个中文占2字节。

18.在整数值过大的情况下，在数值后面标识一个l，表示长整型的数。

19.由于小数默认为double型，如果你想将其定义为float类型，需要在数的后面加f。

20.自动类型转换（也叫隐式类型转换）；强制类型转换（也叫显式类型转换）

21.表达式的数据类型自动提升：

• 所有的byte型、short型和char的值将被提升到int型
• 如果一个操作数是float型，计算结果就是float型
• 如果一个操作数是long型，、计算结果就是long型
• 如果一个操作数是double型，计算结果都是double型

22.两端必须是数值型时，就可以进行自动类型提升，然后进行运算。以占用内存比较大的为主。

23.中国的编码表GBK。

24.在ASCII码表中，大写字母比小写字母小32.

25.在java中有一张国际标准码表（unicode），包括世界上各个国家的码表。

26. int a=Integer.MAX_VALUE可以得到int的最大值

27.成员变量在使用时不必被初始化，局部变量在使用时必须被初始化。

基本数据类型：

1.java没有任何无符号（unsigned）形式的int、long、short和byte类型。

2. 长整型数值有一个后缀L或l。

十六进制有一个前缀 0x 或 0X。

八进制有一个前缀 0。

注意：八进制容易混淆，建议最好不要使用八进制常数。

3.目前绝大部分情况都是使用 double 类型。

4.可以使用十六进制表示浮点数值。例如：0.125 ==> 0x1.0p-3

注意：p表示指数。尾数采用十六进制，指数采用十进制。指数的基数是2。

5.char 类型 需要使用单引号括起来。

6.转义字符可以出现在加引号的字符或者字符串中。

7.需要注意注释中的 \u 。

注释：// \u00A0 is a newline

这会导致一个语法错误，在读程序时， \u00A0 会变为换行符。

8.除非需要处理UTF-16 代码单元，一般不要使用char类型，在程序中。

变量：

1.每个声明必须以分号结束，因为声明是一条完整的 java 语句。

2.变量名必须是一个以字母开头并有字母或数字构成的序列。

3.变量名的长度基本上没有限制。

4.声明一个变量后，必须用赋值语句对变量进行显式初始化，千万不要使用未被初始化的变量。

5.在java中，变量的声明尽可能的靠近变量第一次使用的地方，这是一种良好的编程习惯。

6.java中不区分变量的声明和定义。

常量：

1.java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用 static final 设置一个类常量。习惯上，常量名需要大写。

2.类常量的定义位于main方法的外部。设置为public 时，其他类的方法也可以使用。

1.5 运算符

1.算术运算符包含：+、-、/、*、%（取余数，模运算）、+（连接符）、++（自增）、--（自减 ）。

2.在进行负数取余运算时，负号只参考被模数。

3.任何数据和字符串用+相加，都叫做相连接。

4.a++会先把a值记录下来，参与其他运算，然后自增。

5.赋值运算符：=、+=、-=、*=、/=、%=；在运算时，遇见不同的类型时，会自动转换，只进行一次运算。

6.比较运算符：==、！=、<、>、>=、<=。

7.逻辑运算符：&（AND 与）、|（OR 或）、^（XOR 异或）、！（Not（非））、&&（AND 短路）、||（OR（短路））。

8.逻辑运算符是用于连接两个boolean类型的表达式。

9.^(异或)运算规律：^符号两边如果相同，结果是false；两边的结果不同，结果是true。

10.！(非)：非运算，判断的事物的另一面。

11.&&：左边一旦为假，右边不运算。&是不管左边如何，右边运算。两者运算结果一样。

12.注意：整数被 0 除将会产生一个异常，而浮点数被 0 除将会得到无穷大或NaN结果。

13.如果将一个类或者方法标记为 strictfp ,这个类或者方法中的所有方法或者指令都将使用严格的浮点计算。

14.java 的 Math 类中包含了各种各样的数学函数。包括 sqrt(x)（平方根）、pow(x,y)（幂运算）等。

15.Math 类追求最快的性能。如果想要得到一个完全可预测的结果，需要使用 StrictMath 类。

16.自增或自减运算符有 “前缀”和“后缀”两种形式。前缀形式会先完成加 1 ，后缀形式先使用原来的变量值。

17.+= 是右结合运算符，所以表达式：

a += b += c 等价于 a += (b += c)

1.5.2数值转换：

1.自动类型转换（也叫隐式类型转换）；强制类型转换（也叫显式类型转换）

2.表达式的数据类型自动提升：

• 所有的byte型、short型和char的值将被提升到int型
• 如果一个操作数是float型，计算结果就是float型
• 如果一个操作数是long型，计算结果就是long型
• 如果一个操作数是double型，计算结果都是double型

3.两端必须是数值型时，就可以进行自动类型提升，然后进行运算。以占用内存比较大的为主。

4.强制类型转换的格式是在圆括号中给出想要转换的目标类型，后面是变量名。例如：

double a = 1.2345;

int i = (int)a;

5.强制转换类型通过截断小数部分将浮点型转换为整型，可能会在造成精度的缺失。

6.注意：如果将一个数值从一种类型强制转换为另一种类型，而又超出了目标类型的表示范围，结果会被截断为一个完全不同的值。例：(byte)300 的实际值为 44。

7.不要在Boolean 类型与任何数值类型之间进行强制转换，会发生错误。

1.5.5位运算符：

1.位运算符主要用于二进制位运算的符号。

2.位运算符：<<(左移)、>>(右移)、>>>(无符号右移)、&（与运算）、|（或运算）、^(异或运算)、~(反码)。

3.<<：在二进制数上，向左移动，相当于乘以2的倍数，空缺位补0 。

>>：在二进制数上，向右移动，相当于除以2的倍数。而且，最高位是啥，就用啥补位。

>>>:数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补。

移n位，就是对乘以或除以2的n次幂。

4.^（异或运算）：一个数异或同一个数两次，结果还是这个数。

5.计算机中存储负数是用补码存储的。

6.位运算非常高效。

1.5.6三元运算符：

1.格式：（条件表达式）？表达式1：表达式；

• 如果条件为true，运算后的结果是表达式1
• 如果条件为false，运算后的结果是表达式2.
• 表达式就是具有一定语法规则的语句。

1.6字符串

1.java 字符串就是 Unicode 字符序列。

2.java没有内置的字符串类型，而是在标准类库中提供了一个预定义类，叫做 String。

3.每一个有双引号括起来的字符串都是 String 类的实例。

4.String 类中的 subString(a,b) 方法，可以截取一个子串。优点：易计算长度， b-a。

5.java语言中可以使用 + 号拼接字符串。

6.String类对象被称为不可变字符串，因为不能修改字符串中的字符。

7.字符串存储在一个公共的存放池中。字符串变量指向存储池中相应的位置。复制字符串变量，就是让原始字符串和复制的字符串共享相同的字符。

8.java 将自动进行垃圾回收。如果一块内存不在使用，系统最终会回收。

9.对于表达式 s.equals(t) 中，s 和 t 可以是字符串变量，也可以是字符串本身。

【1】equals() 方法 检测两个字符串是否相同。

【2】equalsIgnoreCase()方法，不区分大小写。

【3】== 不要用来检测两个字符串是否相等，可以确定两个字符串是否放在一个位置。

【4】compareTo 方法和 C的 strcmp 完全类似。

10. 空串和 NULL 串：

• 空串 "" 是长度为 0 的字符串，也是一个 java对象，有自己的内容（空）和串长度（0）
• String 中一个特殊的值，为 null。目前没有对象与该变量关联。

11.码点和代码单元：

• 码点就是编码表中的某个字符对应的代码值。
• 每个char 用16位表示Unicode码点的代码单元。多数常用Unicode字符使用一个代码单元，辅助字符需要一堆代码单元表示。
• 当使用 charAt（index）时，遇到两个代码单元的字符时，就可能返回第二个代码单元。
• 可以使用 codePoints 方法，生成一个 int 值的 “流”，每个int 值对应一个码点。

12.每次连接字符串，都会构建一个新的 String 对象，耗时又浪费空间，可以使用StringBuilder 类解决。

13.StringBuffer 和 StringBuilder：

• StringBuffer 效率低，但是允许采用多线程的方式执行添加或者删除字符的操作。
• StringBuilder 在单线程中编辑。两个类的API相同。

1.7输入输出

1.调用 System.out.println() ，可以打印输出到控制台窗口。

2.想要通过控制台进行输入，需要构造一个 Scanner 对象，并且和 “标准输入流” System.in 关联。例如：

Scanner in = new Scanner(Sytem.in);

3.Scanner 类中的nextLine 和 next：

• nextLine() 可以输入一行，也可以输入空格
• next() 可以输入一个单词（以空格符作为分隔符）

4.输入是可见的，所以Scanner 类不适用从控制台中读取密码。Java SE6 引入了Console实现目的。例如：

Console con = System.console();
String username = con.readline("User name:");
char[] pswd = con.readPassword("Password:");

注意：为了安全，返回的密码存放在一个一维字符数组中，而不是字符串中。

5.为了格式化输出，JavaSE5.0 沿用了C语言库函数中的 printf 方法。

6.System.out.printf("%s,%d",name,age);

• 每一个以 % 字符开始的格式说明符都用相应的参数替换。
• 格式说明符尾部的转换符将指示被格式化的数值类型。
• f 表示浮点数，s 表示字符串，d 表示十进制整数，c 表示字符。
• 还可以给出控制格式化输出的各种标志，例如：逗号标志增加了分组的分隔符。即：
• System.out.printf("%,.2f",1000.0/3.0); 打印：3,333.33

7.可以使用 s 转换符格式化任意的对象。

8.文件的输入和输出：

1. 如果要对文件进行读取，需要使用File 对象构造一个 Scanner 对象，例如：
   1. Scanner in = new Scanner(Paths.get("myfile.txt"),"UTF-8");
   2. 如果文件名中包含反斜杠，就要在每个反斜杠之前再加一个反斜杠。
   3. 这里指定字符编码为 UTF-8，如果省略，就会使用机器的默认编码。
2. 读文件进行写入，需要构造一个 PrintWriter对象。在构造器中，需要提供文件名：
   1. PrintWriter out = new PrintWriter("myfile.txt","UTF-8");
   2. 如果文件不存在，就创建。可以像System.out 一样使用方法。
3. 如果使用一个不存在的文件构造一个Scanner，或者用一个不能被创建的文件名构造一个 PrintWriter，就会发生异常。编译器认为这些异常比 “被零除”的异常还要严重。

1.8程序流程控制

结构有：（1）顺序结构（2）判断结构（3）选择结构（4）循环结构

1.8.1块作用域：

1.块（复合语句）：有一对大括号括起来的若干条简单的 java 语句。

2.块确定了变量的作用域。

3.一个块可以嵌套在另一个块中。但是我们不能在嵌套的两个块中声明同名的变量。

注意：使用块可以在java程序结构中原本只能放置一条（简单）语句的地方放置多条。

 

1.8.2 条件语句：

1.判断结构：代表性语句 if语句（三种格式）。

2.三元运算符就是if else语句的简写格式。简化形式弊端：它就是一个运算符，必须有运算结果。

3简写格式什么时候用：当if else运算后，有一个具体地结果时，可以简化成三元运算符。

4.if的应用：

• 对具体的值进行判断
• 对区间判断
• 对运算结果是boolean类型的表达式进行判断

5.else 子句和最临近的 if 构成一组。

 

1.8.3循环语句：

1.循环结构：代表语句：while，do while，for。

2.如果开始循环条件的值就位 false ，则 while 循环体一次也不会执行。

3.do while特点：是条件无论是否满足，循环体至少执行一次。

4.Ctrl+C 结束控制台的运行

5.for循环格式：（支持迭代）

for（初始化表达式;循环条件表达式;循环后的操作表达式）

{

执行语句；（循环体）

}

6.for 语句的三个部分应该对同一个计数器变量进行初始化、检测和更新。

7.当在 for 语句中的第1部分中声明了一个变量后，这个变量的作用域就为 for 循环的整个循环体。

8.while与for可以互换，区别在于for为了循环而定义的变量在for循环结束后就在内存中释放，而while循环使用的变量结束后还可以继续使用。

9.最简单无限循环格式：while（true），for（；；），无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

10.for和while的特点：

1. for和while可以互换
2. 格式上的不同，在使用上有点小区别，如果需要通过变量对循环进行控制，该变量只作为循环增量存在时，区别就体现出来了。

11.当对某些代码执行很多次时，使用循环结构 完成。

当对一个条件进行一次判断时，可以使用if语句。

当对一个条件进行多次判断时，可以使用while语句。

12.注意：

（1）在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。

（2）循环通常情况下，需要定义条件，需要控制次数

13.转义字符：能转变某些字母和符号含义的字符。（\n：回车符；\t：制表符 ；\b：退格；\r：按下回车键）

14.Windows系统中回车符其实是由两个字符组成的 \r \n；

linux中回车符是 \n。

15.字符串中出现了单纯的反斜线，并没有将后面的转义，则反斜线要被转义为普通的符号。

 

1.8.5 多重选择:

1.选择结构：switch语句

格式：switch（表达式）

{
case 取值1：执行语句;break;
case 取值2：执行语句;break;
·········
default：执行语句；break；
}

2.switch语句执行到大括号处会结束，如果没有break，会继续向下执行，不在判断，直到碰到break，或者大括号终结。

3.switch的应用：

• 对具体的值进行判断
• 值的个数通常是固定的

对于具体的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率相对高一点。

4. case 标签可以是：

• 类型为 char、byte、short 或 int 的常量表达式。
• 枚举常量
• 从 JavaSE 7 开始，case 标签还可以是字符串字面量。

5.java 中提供一种带标签的 break 语句，用于跳出多重嵌套的循环语句。通过执行带标签的 break 跳转到带标签的语句块末尾。

注意：只能跳出语句块，不能跳入语句块。

6. continue 语句，和break 语句一样，他将中断正常的控制流程。continue 语句将控制转移到最内层循环的首部。还有一种带标签的 continue 语句，可以跳到与标签匹配的循环首部。

 

增强for循环：

1.遍历数组

语法为: for (Type value : array)

{

 expression value;

}

2.显而易见，for/in(for each) 循环自动控制一次遍历数组中的每一个元素，然后将它赋值给一个临时变量（如上述代码中的value），然后在循环体中可直接对此临时变量进行操作。这种循环的缺点是：

• 只能顺次遍历所有元素，无法实现较为复杂的循环，如在某些条件下需要后退到之前遍历过的某个元素；
• 循环变量（i）不可见，如果想知道当前遍历到数组的第几个元素

 

1.9大数值：

1. java.math 包中的两个类：BigInteger 和 BigDecimal ：

• 两个类都可以处理包含任意长度数字序列的数值。
• BigInteger 类实现了任意精度的整数运算。
• BigDecimal 实现了任意精度的浮点数运算。
• 使用静态的 valueOf 方法可以将普通的数值转换为大数值：
• BigInteger a = BigInteger .valueOf(100);
• 不能使用普通的算术运算符（+或*等）处理大数值。
• 运算时，可以使用大数值类中的 add 和 multiply 方法。

2. java中没有提供运算符重载功能，程序员无法重定义 + 和 * 运算符，应用于以上两个类。

1.10函数

1.函数：就是定义在类中的具有特定功能的一段独立小程序。（函数也称为方法）

2. 函数的格式：

修饰符（public static） 返回值类型 函数名（参数类型 形式参数1 ，参数类型 形式参数2，··）

{

执行语句；

return返回值；

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该函数运算后的结果，该结果会返回给调用者。

函数名：如果使用2个以上的单词，第一个单词首字母小写，第二个大写首字母（规范）。

3.java语言是强类型语言，其将所有的数据都划分类型。

4. 特殊情况：功能没有具体的返回值。这时return的后面直接用分号结束。

如何体现返回值类型：没有具体值，返回值类型用void表示。

注意：如果返回值类型是void，那么函数中return语句可以省略不写。

1.10.2 函数的特点

1.定义函数可以将功能代码进行封装。

2.便于对该功能进行复用。

3.函数只有被调用才会被执行。

4.函数可以提高代码的复用性。

5.注意：

• 函数中只能调用函数，不可以在函数内部定义函数。
• 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

6. 函数的定义有2个明确完成：

1. 这个功能的结果是什么？
2. 这个功能实现过程中是否需要未知内容参与运算？

7.函数的参数列表（参数的个数、参数的类型）

8.返回值类型和参数类型没有直接关系。

1.10.3 函数的重载

1.重载：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数不同或参数类型不同即可。

2.函数的重载和返回值无关。

3.java是严谨性语言，如果函数出现的调用的不确定性，会编译失败。

1.11 数组

1.数组：同一种类型数据的集合，起始数组就是一个容器。

2.数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

3.数组格式：

• 格式1：元素类型[ ] 数组名 = new 元素类型[ 元素个数或数组个数]；
• 也可以使用：元素类型 数组名[ ]；
• 格式2：元素类型[ ] 数组名 = new 元素类型[ ] {元素，元素，····}；
• 等同于（ 元素类型[ ] 数组名 = {元素，元素，····}）

4.数组长度不要求是常量：new int[n] 会创建一个长度为 n 的数组。

5.在创建一个数组时，初始化：

• 数字数组时，所有元素都初始化为 0。
• boolean 数组的元素初始化为 false。
• 对象数组时，元素初始化为一个特殊值 null 。

注释：这表示这些元素都还没有存放任何对象。

6.数组一旦创建，就不能改变大小，可以改变存放的数组元素。

7.利用 Arrays 类中的 toString 方法，可以返回一个包含数组元素的字符串。

8.java 中可以在不创建新变量的情况下，重新初始化数组。例如：

int a = {1,2,45,6,94};
a = new int[]{13,325,34}

9.java 允许数组的长度为 0。注意：数组长度为 0 和 null 不同。

10.在java中，可以将一个数组变量拷贝给另一个数组变量，此时，两个变量将引用同一个数组。

11.拷贝过程：

• 如果数组元素是数值型，多余的元素会被赋值为 0。
• 如果数组元素是布尔型，将赋值为 false。
• 如果长度小于原始数组的长度，只拷贝最前面的数据元素。
• 拷贝方法：Arrays.copyOf(数组名，数组长度)；

12.java 中的 [ ] 运算符被预定义为检查数组边界，即不能通过 a 加 1 得到数组的下一个元素。

13.在主函数的main 方法中，程序名并没有存储在 args 数组中。

14.常见问题：

• 当访问到数组中不存在的角标时，就会发生数组角标越界异常。
• 当引用型变量没有任何实体指向时，还在用其操作实体，就会引发空指针异常。

15. 对数组操作最基本的动作就是存和取。（就是对角标的操作）

16.length是数组自带的一个属性。

17. 排序有选择排序和冒泡排序。

18.冒泡排序内循环：

-1：为了避免角标越界

-x：为了让外循环增加一次，内循环参数与比较的元素个数递减。

19.Arrays.sort(arr) 这是java中设定好的排序功能。

29.数组常见功能查找 ：返回-1，代表角标不存在。 如果出现两个，只会出现第一个。

21. 折半查找（二分查找）：被查找的数据必须是有序的。

22.Arrays.binarySearch(arr，元素) 是java中自带的折半查找功能。该功能中，如果存在返回的具体的角标位置，不存在返回的是，-插入点-1.

23.什么时候使用数组：如果数据出现了对应关系，而且对应关系的乙方是有序的数字编号。并作为角标使用。这是就必须使用数组。

24.查表法：可以将数据存储到数组中，根据运算的结果作为角标直接去查对应的元素即可。

25.查表会查到比较多的数据，数据一多，就先存储起来，在进行操作。所以定义一个数组，作为临时容器。

26.Math.random 方法将返回一个从 0 到 1 之间（包含0，不包含1）的随机浮点数。用 n 乘以这个浮点数，可以得到从 0 到 n-1 之间的随机数。

 

1.11.5 数组中的数组

1. 格式1：int [ ][ ] arr = new int[3][2]

• 定义了名称为arr的二维数组
• 二维数组中有3个一维数组
• 每一个一维数组中有2个元素
• 一维数组的名称分别为arr[0],arr[1],arr[2]
• 给第一个一维数组1角标位赋值为7写法是：arr[0][1]=7;

格式2：int [ ][ ] arr = new int[3][ ]

• 二维数组中有3个一维数组
• 每一个一维数组都是默认初始化值为null
• 可以分别对这个三个一维数组进行初始化

2.[I@1fb8ee3 @左边是实体的类型。 @右边是实体的哈希值。

3.打印二维数组的长度，其实就是一维数组的个数。

4.二维数组使用场景：数据多的时候用数组存起来，数组多的时候用二维数组存起来。

5.多维数组适用于表示表格或更加复杂的排列形式。

6.和一位数组一样，在调用 new 对多维数组进行初始化之前不能使用声明的多维数组。

7.java 实际上没有多维数组，只有一维数组。多维数组被解释为“数组的数组”。

8.可以构造一个 “不规则” 的数组，即数组的每一行都不一样长。