Java基础语法合集（上篇）

---

前言

本人第一次写博客，主要还是为了回顾以前学过的知识，若有不好或有错误的地方欢迎指出！！

该博客合集可适用于课前预习，课后复习，考前知识点复习，由于篇幅问题，因此部分知识点不会进行深度解释，例如：栈，堆，递归等概念。在未来会制作相应的博客进行讲解。

一、 初识Java

1.Java语言特性

• 简单性、面向对象、分布式（微服务）、健壮性、安全性、体系结构中立、可移植性、解释性、高性能、多线程、多态性

2.JDK、JRE、JVM之间的关系

• JDK(Java Development Kit)： Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。

• JRE(Java Runtime Environment): Java运行时的环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境

• JVM： Java虚拟机，运行Java代码

3.标识符

标识符指在程序中有用户给类名、方法名或者变量名所取得名字
标识符可以包含：字母、数字以及下划线和$符号等等。
注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。

标识符的创建建议：
类名：每个单词的首字母大写（大驼峰）
方法名：首字母小写，后面每个单词的首字母大写（小驼峰）
变量名：与方法名规则相同

4.关键字

关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字（用户不能使用关键字定义标识符
Java中部分常用的关键字：

二、 数据类型

1.字面常量

字面常量的分类：

1. 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
2. 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
3. 浮点数常量：程序中直接写的小数，比如：3.14、0.49
4. 字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’
5. 布尔常量：只有两种true和false
6. 空常量：null

注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

2.数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型

基本数据类型有四类八种：
1.四类：整形、浮点型、字符型、布尔型
2.八种：

注意：

• 无论是在16位系统还是32位系统中，int都占用4个字节，long都占用8个字节
• 整型和浮点型都是带有符号的
• 整型默认为int型，浮点型默认为double
• 字符串属于引用类型

3.类型转换

自动类型转换（隐式）
自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行

System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double

int a = 100;
long b = 10L;

b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全

float f = 3.14F;
double d = 5.12;

d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全

byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

强制类型转换（显式）
强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。

示例：

int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败

float f = 3.14F;
double d = 5.12;
d = f; // float-->double，数据范围由小到大，隐式转换
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败

a = d; // 报错，类型不兼容
a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃

byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错

boolean flag = true;
a = flag; // 编译失败：类型不兼容
flag = a; // 编译失败：类型不兼容

注意事项
1.不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型
2.如果需要把范围大的类型复制给范围小的，需要进行强制类型转换，但是可能精度丢失
3.将一个字面值常量进行赋值的时候，Java会自动针对数字范围进行检查
4.强制类型转换不一定能成功，不相干的类型不能互相转换

4.类型提升

不同类型的数据之间相互运算时。数据类型小的会被提升到数据类型大的

4.1 int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

4.2 byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
/* 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;
^
*/

结论： byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

三、 运算符

1.算数运算符

1.1 基本四则运算符：加减乘除模（= - * / % ）

int a = 20;
int b = 100;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 ---->求余数

注意:

• 基本四则运算符都是二元运算符，使用时必须要有左右两个操作数
• int / int 结果还是int类型，而且会向下取整（即小数点之后全部舍弃掉了）
• 做除法和取模时，右操作数不能为0
• % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

System.out.println(10.5 % 2.0);
// 运行结果
0.5

• 两侧操作数类型不一致时，向类型大的提升

System.out.println(1+0.5); 
// +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.5

1.2 增量运算符：（+=、-=、*=、%= ）该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

			int a = 1;
			
            a += 2; // 相当于 a = a + 2
            System.out.println(a); // 输出3

            a -= 1; // 相当于 a = a - 1
            System.out.println(a); // 输出2

            a *= 3; // 相当于 a = a * 3
            System.out.println(a); // 输出6

            a /= 3; // 相当于 a = a / 3
            System.out.println(a); // 输出2

            a %= 3; // 相当于 a = a % 2
            System.out.println(a); // 输出2

注意：只有变量才能使用该运算符，常量不能使用。

1.3 自增/自减运算符（++、–）
++是给变量的值+1，–是给变量的值-1。

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

• 如果单独使用，【前置++】和【后置++】没有任何区别
• 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1
• 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

2.关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

注意：当需要多次判断时，要使用逻辑运算符，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

3.逻辑运算符(重点)

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

3.1 逻辑与 &&
语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
相当于现实生活中的且，比如：如果是学生，并且 带有学生证 才可以享受半票优惠。
两个表达式都为真，结果才是真，只要有一个是假，结果就是假

表达式1	表达式2	结果
真	真	真
真	假	假
假	真	假
假	假	假

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

3.2 逻辑 ||
语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。
相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，
否则站一边去。

表达式1	表达式2	结果
真	真	真
真	假	真
假	真	真
假	假	假

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

注意：左右表达式至少有一个位真，则结果为真

3.3逻辑非 !
语法规则：! 表达式
真变假，假变真。

表达式1	结果
真	真
真	真

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

3.4 短路求值
&& 和 || 遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值

注意:

• 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式
• 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式
• & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

4.位运算符

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二
进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。
位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位
的每一位依次进行计算

4.1 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0

int a = 10;
int b = 20;
System.out.println(a & b);

进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100

4.2 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

int a = 10;
int b = 20;
System.out.println(a | b);

运算方式和按位于类似.

注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算

4.3 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

int a = 0xf;
System.out.printf("%x\n", ~a)

注意:

• 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4个二进制位.

• 0xf 表示 10 进制的 15, 也就是二进制的 1111

• printf 能够格式化输出内容, %x 表示按照十六进制输出.

• \n 表示换行符

4.4 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);

注意：如果两个数相同，则异或的结果为0

5.移位运算

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

5.1 左移 <<: 最左侧位不要了, 最右侧补 0.

int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20

注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数

5.2 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
8
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果(注意, 是按十六进制打印的)
ffff8000

5.3 无符号右移 >>>: 最右侧位不要了, 最左侧补 0

int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
7fffffff

注意:

• 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
• 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
• 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
• 移动负数位或者移位位数过大都没有意义

6.条件运算符(三目运算符)

表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.printf(max);
//运行结果20

注意：
表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换

int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;

表达式不能单独存在，其产生的结果必须要被使用

int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句

7.运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

优先级	运算符
1	. 、[ ] 、( )
2	+、-、++、–、！、~
3	New(类型)
4	*、/、%
5	+、-
6	>>、>>>、<<
7	>、<、>=、<=、instanceof
8	==、!=
9	&
10	^
11	|
12	&&
13	||
14	? :
15	=、+=、-=、*=、/=、%=、%=、^=
16	&=、|=、<<=、>>=、>>>=

四、逻辑控制

1.顺序结构

按照代码书写的顺序一行一行执行，如果调整代码的书写顺序，则执行顺序也发生变化

System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");
// 运行结果
aaa
bbb
ccc

2.分支结构

2.1 if 语句
若布尔表达式结果为 true ，则执行 if 中的语句，否则执行 else 中的语句
语法格式1:

if(布尔表达式){
// 语句
}

语法格式2:

if(布尔表达式){
// 语句1
}else{
// 语句2
}

语法格式3:

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}

2.2 switch 语句

执行流程：
1.先计算表达式的值
2.和 case 依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到 break 时结束
3.当表达式的值没有所列项匹配时,执行 default 中的语句
代码实例:

int day = 1;
switch(day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
}

注意:

• break 不要遗漏,否则程序会一直进行下去,直至结束
• 多个case后的常量值不可以重复
• switch的括号内只能是以下类型的表达式：
• • 基本类型：byte、char、short、int，注意不能是long类型
• • 引用类型：String常量串、枚举类型

3.循环结构

3.1 while循环
循环条件为 true ,则执行循环语句,否则结束循环
语法格式:

while(循环条件){
循环语句;
}

示例:计算1—100的和

int n = 1;
int result = 0;
while (n <= 100) {
result += n;
n++;
}
System.out.println(num);
// 执行结果
5050

注意:

1. if 与 while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
2. if 与 while 后面的 { 建议和 while 写在同一行.
3. if 与 while 后面不要多写 分号, 否则可能导致循环不能正确执行.

3.2 break
break的功能是让循环提前结束
示例:找到100 - 200 中第一个 3 的倍数

int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
System.out.println("找到了 3 的倍数, 为:" + num);
break;
}
num++;
}
// 执行结果
找到了 3 的倍数, 为:102

当程序执行到break时就会让该循环结束

3.3 continue
continue 的功能是跳过本次循环,立即进入下次循环
示例:找到100 - 200 中所有3的倍数

int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
num++; // 这里的 ++ 不要忘记! 否则会死循环.
continue;
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}

执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句.

3.4 for 循环
语法格式:

for(表达式1;布尔表达式2;表达式3){
表达式4;
}

• 表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
• 表达式2: 循环条件，满则循环继续，否则循环结束
• 表达式3: 循环变量更新方式

执行顺序:①②③④④—>②③④—>②③④—>②③④—>②③④—>②③④—>…—>当②为false，循环结束。

示例: 计算 1! + 2! + 3! + 4! + 5!

int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
}
sum += tmp;
}
System.out.println("sum = " + sum)

注意:

1. 和 while 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
2. 和 while 类似, for 后面的 { 建议和 while 写在同一行.
3. 和 while 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.
4. 和while循环一样，结束单趟循环用continue，结束整个循环用break

3.5 do while 循环
先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。
语法格式:

do{
循环语句;
}while(循环条件);

示例:打印 1 - 10

int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);

注意:

1. do while 循环最后的分号不要忘记
2. 一般 do while 很少用到, 更推荐使用 for 和 while.

4.输入输出

4.1 输出到控制台
语法格式:

System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

println 输出的内容自带 \n, print 不带 \n
printf 的格式化输出方式和 C 语言的 printf 是基本一致的

System.out.println("hello world");
int x = 10;
System.out.printf("x = %d\n", x)

4.2 格式化字符串

转换符	类型	举例	输出
d	十进制整数	(“%d”,100)	100
x	十六进制整数	(“%x”,100)	64
o	八进制整数	(“%o”,100)	144
f	定点浮点数	(“%f”,100f)	100.000000
e	指数浮点数	(“%e”, 100f)	100.000
a	十六进制浮点数	(“%a”, 100)	0x1.9p6
s	字符串	(“%s”, 100)	100
c	字符	(“%c”, ‘1’)	1
b	布尔值	(“%b”, 100)	true
h	散列码	(“%h”, 100)	64
%	百分号	(“%.2f%%”, 2/7f)	0.29%

4.3 从键盘输入
使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner; // 需要导入 util 包
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法
// 执行结果
请输入你的姓名：
张三
请输入你的年龄：
18
请输入你的工资：
1000
你的信息如下：
姓名: 张三
年龄：18
工资：1000.0

注意:当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl+ d).

五 、方法的使用

1.方法的概念及使用

1.1 什么是方法(method)
方法就是一个代码片段. 类似于 C 语言中的 “函数”。方法存在的意义(不要背, 重在体会):

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.

1.2 方法的定义

语法格式：

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
[return 返回值];
}

示例：实现一个两个整数相加的方法

public class Method{
// 方法的定义
public static int add(int x, int y) {
return x + y;
}
}

注意：

1. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
2. 方法名字：采用小驼峰命名
3. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
4. 方法体：方法内部要执行的语句
5. 在java当中，方法必须写在类当中
6. 在java当中，方法不能嵌套定义
7. 在java当中，没有方法声明一说
8. 定义的方法可以没有返回值，没有时返回值类型必须写成void

1.3 方法调用的执行过程
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下
执行

2.方法的重载

在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了

public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}

注意：

1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关
4. 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

六、数组的定义与使用

1.数组的创建及初始化

1.1 数组的创建
语法格式：

T[] 数组名 = new T[N];

T：表示数组中存放元素的类型
T[ ]：表示数组的类型
N：表示数组的长度

1.2 数组的初始化
数组的初始化主要分为动态初始化以及静态初始化

• 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];

• 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

注意：

• 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
• 静态初始化时, {}中数据类型必须与[]前数据类型一致。
• 静态初始化可以简写，省去后面的new T[ ]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

• 数组也可以按照如下C语言个数创建，不推荐

/*
该种定义方式不太友好，容易造成数组的类型就是int的误解
[]如果在类型之后，就表示数组类型，因此int[]结合在一块写意思更清晰
*/
int arr[] = {1, 2, 3};

• 静态和动态初始化也可以分为两步，但是省略格式不可以

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

• 如果没有对数组进行初始化，数组中元素有其默认值

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false

• 如果数组中存储元素类型为引用类型，默认值为 null

2.数组的使用

2.1 数组中元素访问
数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过
下标访问其任意位置的元素。

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0]);

注意：

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界.

2.2 遍历数组

在数组中可以通过 数组对象**.length** 来获取数组的长度

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}

也可以使用 for-each 遍历数组

int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错

3.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组
语法格式：

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

示例：

int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
// 执行结果
1 2 3 4
5 6 7 8
9 10 11 12

同理，还存在 “三维数组”, “四维数组” 等更复杂的数组, 只不过出现频率都很低