XiSun的博客

bit 和 byte

计算机本质是一系列的电路开关。每个开关存在两种状态：开 (on) 和关 (off)。如果电路是开的，它的值是 1，如果电路是关的，它的值是 0。

• 一个 0 或者一个 1 存储为一个比特 (bit)，是计算机中最小的存储单位。

• 计算机中最基本的存储单元是字节 (byte) 。每个字节由 8 个比特构成。

计算机的存储能力是以字节来衡量的。如下：

千字节 (kilobyte，KB) = 1024 B

兆字节 (megabyte，MB) = 1024 KB

千兆字节 (gigabyte，GB) = 1024 MB

万亿字节 (terabyte，TB) = 1024 GB

JDK、JRE 和 JVM

• JDK = JRE + 开发工具集（例如 Javac 编译工具等）

• JRE = JVM + Java SE 标准类库

阶段

编写：编写的 java 代码保存在以 .java 为结尾的源文件中。

在一个 java 源文件中，可以声明多个 class 类，但是，只能最多有一个类声明为 public。而且，声明为 public 的类名，必须与源文件名相同。

编译：使用 javac.exe 命令编译 java 源文件。格式：javac 源文件名.java

编译之后，会生成一个或多个以 .class 结尾的字节码文件，字节码文件的文件名与 java 源文件中的类名相同，二者是一一对应的。

运行：使用 java.exe 命令解释运行字节码文件。格式：java 类名

运行的字节码文件，需要有入口函数 main() 方法，且书写格式是固定的。

编译完源文件后，生成一个或多个字节码文件。然后运行时，使用 JVM 中的类的加载器和解释器，对生成的字节码文件进行解释运行。即：此时，需要将字节码文件对应的类加载到内存中，这个过程涉及到内存解析。

注释

单行注释：// 注释文字

多行注释： /* 注释文字 */

文档注释：/** 注释文字 */

对于单行注释和多行注释，被注释的文字，不会被 JVM 解释执行；

多行注释里面不允许有多行注释嵌套；

文档注释内容可以被 JDK 提供的工具 javadoc 所解析，生成一套以网页文件形式体现该程序的说明文档。

关键字和保留字

关键字 (key word)

定义：被 java 语言赋予了特殊含义，用做专门用途的字符串 (单词)。

特点：关键字中所有字母都为小写。

官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

保留字 (reserved word)

现有 java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字：goto 、const。

标识符

java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

• 由 26 个英文字母大小写，0 - 9，_ 或 $ 组成；

• 数字不可以开头；

• 不可以使用关键字和保留字，但能包含关键字和保留字；

• java 中严格区分大小写，长度无限制；

• 标识符不能包含空格。

如果不遵守以上规则，编译不通过。

名称命名规范：

• 包名：多单词组成时所有字母都小写：xxxyyyzzz；
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz；
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz；
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ。

在命名时，为了提高阅读性，要尽量有意义，做到见名知意。

java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用。

变量

定义

变量是内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化。

变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。

java 中每个变量必须先声明，后使用，使用变量名来访问这块区域的数据。

变量的作用域：其定义所在的一对 { } 内，变量只有在其作用域内才有效，在同一个作用域内，不能定义重名的变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class VariableTest{
    public static void main(String[] args){
        // 变量的定义
        int myAge = 12;
        // 变量的使用
        System.out.println(myAge);
        
        // 编译错误：使用myNumber之前未定义myNumber
        // System.out.println(myNumber);
        
        // 变量的定义
        int myNumber;
        
        // 编译错误：使用myNumber之前未赋值myNumber
        // System.out.println(myNumber);
        
        // 变量的赋值
        myNumber = 1001;
        
        // 变量的使用
        System.out.println(myNumber);
    }
}

按数据类型分类

java 是强类型语言，对于每一种数据都定义了明确的具体数据类型，并在内存中分配了不同大小的内存空间。

基本数据类型

整数类型

java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 java 程序的可移植性。

java 的整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’。java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。

浮点类型

与整数类型类似，java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

float：单精度，尾数可以精确到 7 位有效数字。很多情况下，精度很难满足需求。

double：双精度，精度是float的两倍。通常采用此类型。

java 的浮点型常量默认为 double 型，声明 float 型常量，须后加 ‘f’ 或 ‘F’。

字符类型

char 型数据用来表示通常意义上的 “字符”，占用 2 个字节。char 类型是可以进行运算的。因为它都对应有 Unicode 码。

java 中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：

• 字符常量是用单引号括起来的单个字符。例如：char c1 = 'a'; char c2= '中'; char c3 = '9';。

• java 中还允许使用转义字符 \ 来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; // '\n'表示换行符。常用的转义字符如下：

• 直接使用 Unicode 值来表示字符型常量：’\uXXXX’。其中，XXXX 代表一个十六进制整数。如：\u000a 表示 \n。

布尔类型

boolean 类型用来判断逻辑条件，一般用于程序流程控制。

boolean 类型数据只允许取值 true 和 false，无 null。

java 虚拟机中没有任何供 boolean 值专用的字节码指令，java 语言表达所操作的 boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替：true 用 1 表示，false 用 0 表示。———《java 虚拟机规范 8 版》

基本数据类型之间的转换

自动类型转换：不同数据类型的变量做运算时，容量小的数据类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

此处的容量大小，指的是该数据类型表示数的范围的大和小。

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

• byte，short 和 char 之间不会相互转换，他们三者在计算时首先转换为 int 类型。

• boolean 类型不能与其它数据类型运算。

• 当把任何基本数据类型的值和字符串 (String) 进行连接运算时 (+)，基本数据类型的值将自动转化为字符串 (String) 类型。

强制类型转换：自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出。

• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类，可以实现把字符串转换成基本类型。如：String a = “43”; int i = Integer.parseInt(a);。

• boolean 类型不可以转换为其它的数据类型。

引用数据类型

String

String 不是基本数据类型，属于引用数据类型 (class)。使用方式与基本数据类型一致，例如：String str = “abcd”;。

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：str = str + “xyz” ; int n = 100; str = str + n;。

String 与 8 种基本数据类型做运算时，但只能是连接运算。

按声明位置分类

成员变量：在方法体外，类体内声明的变量。

局部变量：在方法体内部声明的变量。

成员变量和局部变量在初始化值方面的异同：
同：都有生命周期；异：局部变量除形参外，需显式初始化。

进制

所有数字在计算机底层都以二进制形式存在。

对于整数，有四种表示方式：

• 二进制 (binary) ：0 - 1，满 2 进 1，以 0b 或 0B 开头表示。

• 十进制 (decimal) ：0 - 9，满 10 进 1。

• 八进制 (octal) ：0 - 7，满 8 进 1，以数字 0 开头表示。

• 十六进制 (hex) ：0 - 9 及 A - F，满 16 进 1，以 0x 或 0X 开头表示。此处的 A - F 不区分大小写。如：0x21AF +1= 0X21B0。

二进制

java 整数常量默认是 int 类型，当用二进制定义整数时，其第 32 位是符号位；当是 long 类型时，二进制默认占 64 位，第 64 位是符号位。

二进制的整数有如下三种形式：

• 原码：直接将一个数值换成二进制数，最高位是符号位。
• 负数的反码：是对原码按位取反，但最高位 (符号位) 不变，确定为1。
• 负数的补码：其反码加 1。

正数的原码、反码、补码都相同。

计算机以二进制补码的形式保存所有的整数。

原码到补码的转换：

不同进制间转换

十进制转二进制：除 2 取余的逆。

二进制和八进制、十六进制转换：

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符

如果对负数取模，可以把模数负号忽略不记，如：5 % -2 = 1。 如果被模数是负数，则不可忽略，如： -5 % 2 = -1。此外，取模运算的结果不一定总是整数。

对于除号 “/“，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：int x = 3510; x = x / 1000 * 1000;，x 的结果是 3000。

“+” 除字符串相加功能外，还能把非字符串转换成字符串。例如：System.out.println("5 + 5 = " + 5 + 5); ，打印结果是：5 + 5 = 55 。

赋值运算符

符号：=。当 “=” 两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。

扩展赋值运算符： +=，-=，*=，/=，%=。这几个赋值运算符不会改变变量本身的数据类型。

1
2
3
4
5

int i = 1;
i *= 0.1;
System.out.println(i);// 0
i++;
System.out.println(i);// 1

1
2
3
4
5

int m = 2;
int n = 3;
n *= m++;// n = n * m++;
System.out.println("m = " + m);// 3
System.out.println("n = " + n);// 6

1
2
3

int n = 10;
n += (n++) + (++n);// n = n + (n++) + (++n); → n = 10 + 10 + 12;
System.out.println(n);// 32

比较运算符 (关系运算符)

比较运算符的结果都是 boolean 型。

逻辑运算符

&：逻辑与，|：逻辑或，!：逻辑非。
&&：短路与，||：短路或，^：逻辑异或。

• 逻辑运算符用于连接布尔型表达式，在 java 中不可以写成 3 < x < 6，应该写成 x > 3 & x < 6。

• “&” 和 “&&” 的区别：& 表示，左边无论真假，右边都进行运算；&& 表示，如果左边为真，右边参与运算，如果左边为假，右边不参与运算。

• “|” 和 “||” 的区别同理：| 表示，左边无论真假，右边都进行运算；||表示，如果左边为假，右边参与运算，如果左边为真，右边不参与运算。

• 异或 (^) 与或 (|) 的不同之处是：当左右都为 true 时，结果为 false。即：异或，追求的是异!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int x = 1;
int y = 1;
if (x++ == 2 & ++y == 2) {
    x = 7;
}
System.out.println("x = " + x + ", y = " + y);// x = 2, y = 2

x = 1;
y = 1;
if (x++ == 2 && ++y == 2) {
    x = 7;
}
System.out.println("x = " + x + ", y = " + y);// x = 2, y = 1

x = 1;
y = 1;
if (x++ == 1 | ++y == 1) {
    x = 7;
}
System.out.println("x = " + x + ", y = " + y);// x = 7, y = 2

x = 1;
y = 1;
if (x++ == 1 || ++y == 1) {
    x = 7;
}
System.out.println("x = " + x + ", y = " + y);// x = 7, y = 1

1
2
3
4
5
6
7
8
9
10

boolean x = true;
boolean y = false;
short z = 42;
if ((z++ == 42) && (y = true)) {
    z++;
}
if ((x = false) || (++z == 45)) {
    z++;
}
System.out.println("z = " + z);// z = 46

位运算符

无 <<<。

位运算是直接对整数的二进制进行的运算。

• << ：在一定范围内，每向左移一位，相当于乘以 2。

• >>：在一定范围内，每向右移一位，相当于除以2。

面试题：最高效的计算 2 * 8。利用：2 << 3，或者 8 << 1。

交换两个数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

int num1 = 10;
int num2 = 20;
System.out.println(num1 + ", " + num2);

// 方式一
int temp;
temp = num1;
num1 = num2;
num2 = temp;
System.out.println(num1 + ", " + num2);

// 方式二
num1 = 10;
num2 = 20;
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
System.out.println(num1 + ", " + num2);

// 方式三
num1 = 10;
num2 = 20;
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println(num1 + ", " + num2);

// 方式四
num1 = 10;
num2 = 20;
num1 = num1 << 1;
num2 = num2 >> 1;
System.out.println(num1 + ", " + num2);

三元运算符

格式：

• 表达式 1 和表达式 2 要求类型是一致的，因为要与接受的参数类型相同。

凡是可以使用三元运算符的地方，都可以改写为 if - else 结构，反之，不成立。如果既可以使用三元运算符，又可以使用 if - else 结构，优先使用三元运算符，因为更简洁、效率更高。

三元运算符与 if - else 的联系与区别：

• 三元运算符可简化 if - else 语句。
• 三元运算符要求必须返回一个结果。
• if 后的代码块可有多个语句。

运算符的优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如上表，上一行运算符总优先于下一行。
• 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

程序流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

• 顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转。
• 分支结构：根据条件，选择性地执行某段代码。有 if - else 和 switch - case 两种分支语句。
• 循环结构：根据循环条件，重复性的执行某段代码。有while、do - while、for三种循环语句。

注：JDK 1.5 提供了 foreach 循环，方便遍历集合、数组元素。

if - else 结构

switch - case 结构

• switch (表达式) 中表达式的值，必须是下述几种类型之一：byte ，short，char，int，枚举类 (jdk 5.0)，String 类 (jdk 7.0)。
• case 子句中的值必须是常量，不能是变量名或不确定的表达式值。
• 同一个 switch 语句，所有 case 子句中的常量值互不相同。
• break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果没有 break，程序会顺序执行到 switch 结尾。
• default 子句是可任选的。同时，位置也是灵活的。当没有匹配的 case 时，执行 default。
• 如果多个 case 的执行语句相同，则可以将其合并。
• 同等情况下，switch - case 结构比 if - else 结构的效率稍高。

1
2
3
4
5
6
7
8
9
10
11
12

Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
switch (num) {
    case 0:
        System.out.println(0);
    case 1:
        System.out.println(1);
    case 2:
        System.out.println(2);
    default:
        System.out.println("other");
}

添加 break 和不添加 break 的结果是不同的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
switch (num) {
    case 0:
        System.out.println(0);
        break;
    case 1:
        System.out.println(1);
        break;
    case 2:
        System.out.println(2);
        break;
    default:
        System.out.println("other");
        break;// default位于最后，此break可以不添加。
}

键盘输入一个月份和天数，判断其是一年中的第几天：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入month：");
    int month = scanner.nextInt();
    System.out.println("请输入day：");
    int day = scanner.nextInt();
    int sumDays = 0;

    switch (month) {
        case 12:
            sumDays += 30;
        case 11:
            sumDays += 31;
        case 10:
            sumDays += 30;
        case 9:
            sumDays += 31;
        case 8:
            sumDays += 31;
        case 7:
            sumDays += 30;
        case 6:
            sumDays += 31;
        case 5:
            sumDays += 30;
        case 4:
            sumDays += 31;
        case 3:
            sumDays += 28;
        case 2:
            sumDays += 31;
        case 1:
            sumDays += day;
    }

    System.out.println(month + "月" + day + "日，是当年的第" + sumDays + "天。");
}

键盘输入一个年份、月份和天数，判断其是该年中的第几天：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入year：");
    int year = scanner.nextInt();
    System.out.println("请输入month：");
    int month = scanner.nextInt();
    System.out.println("请输入day：");
    int day = scanner.nextInt();
    int sumDays = 0;

    switch (month) {
        case 12:
            sumDays += 30;
        case 11:
            sumDays += 31;
        case 10:
            sumDays += 30;
        case 9:
            sumDays += 31;
        case 8:
            sumDays += 31;
        case 7:
            sumDays += 30;
        case 6:
            sumDays += 31;
        case 5:
            sumDays += 30;
        case 4:
            sumDays += 31;
        case 3:
            if ((year % 4 == 0 && year % 100 != 0) ||
                    year % 400 == 0) {
                sumDays += 29;// 闰年2月29天
            } else {
                sumDays += 28;// 平年2月28天
            }
        case 2:
            sumDays += 31;
        case 1:
            sumDays += day;
    }

    System.out.println(year + "年" + month + "月" + day + "日，是当年的第" + sumDays + "天。");
}

判断一年是否是闰年的标准：

1）可以被 4 整除，但不可被 100 整除。

或

2）可以被 400 整除。

for 循环

语法格式：

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ….. - ②

说明：

• ② 循环条件部分为 boolean 类型表达式，当值为 false 时，退出循环。
• ① 初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔。
• ④ 迭代部分可以有多个变量更新，用逗号分隔。

键盘输入两个正整数，求他们的最大公约数和最小公倍数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入第一个正整数：");
    int firstNum = scanner.nextInt();
    System.out.println("请输入第二个正整数：");
    int secondNum = scanner.nextInt();
    int min = Math.min(firstNum, secondNum);
    int max = Math.max(firstNum, secondNum);

    // 最大公约数
    for (int i = min; i >= 1; i--) {
        if (firstNum % i == 0 && secondNum % i == 0) {
            System.out.println(firstNum + "和" + secondNum + "的最大公约数为：" + i);
            break;
        }
    }

    // 最小公倍数
    for (int i = max; i <= firstNum * secondNum; i++) {
        if (i % firstNum == 0 && i % secondNum == 0) {
            System.out.println(firstNum + "和" + secondNum + "的最小公倍数为：" + i);
            break;
        }
    }
}

请输入第一个正整数：
12
请输入第二个正整数：
20
12和20的最大公约数为：4
12和20的最小公倍数为：60

while 循环

语法格式：

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ….. - ②

说明：

• 注意不要忘记声明 ④ 迭代部分。否则，循环将不能结束，变成死循环。
• for 循环和 while 循环可以相互转换。

do - while 循环

语法格式：

执行过程：① - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ….. - ②

说明：

• do - while 循环至少执行一次循环体 。

嵌套循环

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do - while 均可以作为外层循环或内层循环。
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开
  始下一次的循环。
• 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m * n 次。

九九乘法表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public static void main(String[] args) {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j + " * " + i + " = " + (j * i) + "\t");
        }
        System.out.println();
    }
}

1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	

10000 以内所有的质数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 方式一
public static void main(String[] args) {
    // 质数：素数，只能被1和它本身整除的自然数，2是最小的质数。
    int count = 0;
    boolean ifFlag = true;
    for (int i = 2; i <= 100000; i++) {
        // 优化一：使用Math.sqrt(i)代替i，减少循环的次数
        // i除以一个从2开始的小数，会得到一个从i-1开始的大数，因此，除以2开始的小数与除以从i-1开始的大数，
        // 可以省略一个，以减少次数，这样计算的中点是i开方的值。
        for (int j = 2; j <= Math.sqrt(i); j++) {
            if (i % j == 0) {
                ifFlag = false;
                // 优化二：使用break，跳出不必要的循环
                break;
            }
        }
        if (ifFlag) {
            // 优化三：不打印，i越大，打印的耗时越长
            // System.out.println("质数：" + i);
            count++;
        }
        // 重置
        ifFlag = true;
    }
    System.out.println("质数的个数有：" + count);// 质数的个数有：9592
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 方式二
public static void main(String[] args) {
    // 质数：素数，只能被1和它本身整除的自然数，2是最小的质数。
    int count = 0;
    label:
    for (int i = 2; i <= 100000; i++) {
        // 优化一：使用Math.sqrt(i)代替i，减少循环的次数
        // i除以一个从2开始的小数，会得到一个从i-1开始的大数，因此，除以2开始的小数与除以从i-1开始的大数，
        // 可以省略一个，以减少次数，这样计算的中点是i开方的值。
        for (int j = 2; j <= Math.sqrt(i); j++) {
            if (i % j == 0) {
                continue label;
            }
        }
        count++;
    }
    System.out.println("质数的个数有：" + count);// 质数的个数有：9592
}

break 和 continue

• break 使用在 switch - case 结构或者循环结构中。

• continue 只能使用在循环结构中。

• break 语句用于终止某个语句块的执行，跳出当前循环，continue 语句用于跳过其所在循环语句块的当次执行，继续下一次循环。

  1 2 3 4 5 6 7 8 9

  public static void main(String[] args) { for (int i = 1; i <= 10; i++) { if (i % 4 == 0) { break;// 输出结果：1 2 3 continue;// 输出结果：1 2 3 5 6 7 9 10 } System.out.print(i + "\t"); } }

• break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块 (默认跳出包裹 break 最近的一层循环)：

• continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 (默认跳出包裹 continue 最近的一层循环)。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  public static void main(String[] args) { label: for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 10; j++) { if (j % 4 == 0) { break label;// 结束指定标识label层的当前循环 continue label;// 结束指定标识label层的当次循环 } System.out.print(j); } System.out.println(); } } break label输出结果： 1 2 3 continue label输出结果： 1 2 3 2 3 1 2 3 1 2 3

• break 和 continue 关键字后面不能直接声明执行语句。

随机数

获取 [a, b] 之间的随机数：

1

int v = (int) (Math.random() * (b - a + 1) + a);

如获取 [10, 99] 之间的随机数：

1

int v = (int) (Math.random() * 90 + 10);

数组

数组 (Array)，是多个相同类型数据按一定顺序排列的集合，使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的相关概念：

• 数组名
• 元素
• 下标 (或索引)
• 数组的长度

数组的特点：

• 数组是有序排列的。
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
• 数组本身是引用数据类型的变量，而数组中的元素可以是任何数据类型，既可以是基本数据类型，也可以是引用数据类型。
• 可以直接通过下标 (或索引) 的方式调用指定位置的元素，速度很快。
• 数组的长度一旦确定，就不能修改。

数组的分类：

• 按照维度：一维数组、二维数组、三维数组、…
• 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组 (即对象数组)。

一维数组

声明方式：type var[] 或 type[] var;。例如：int a[]; int[] a1; double b[]; String[] c;// 引用类型变量数组。

不同写法：int[] x;，int x[];。

java 语言中声明数组时，不能指定其长度 (数组中元素的数)， 例如：int a[5];// 非法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public static void main(String[] args) {
    // 1-1.静态初始化，方式一
    int[] ids = new int[]{1001, 1002, 1003, 1004, 1005};
    
    // 1-2.静态初始化，方式二，类型推断
    int[] ids2 = {1001, 1002, 1003, 1004, 1005};

    // 2.动态初始化
    String[] names = new String[5];
    names[0] = "Student A";
    names[1] = "Student B";
    names[2] = "Student C";
    names[3] = "Student D";
    names[4] = "Student E";

    // 3.数组的长度
    System.out.println("ids 的长度：" + ids.length);// 5
    System.out.println("names 的长度：" + names.length);// 5

    // 4.遍历数组
    for (int i = 0; i < ids.length; i++) {
        System.out.println(ids[i]);
    }

    for (int i = 0; i < names.length; i++) {
        System.out.println(names[i]);
    }

    // 5.简写方式遍历数组
    for (int id : ids) {
        System.out.println(id);
    }

    for (String name : names) {
        System.out.println(name);
    }

    // 6.数组元素的默认初始化值
    int[] arrs = new int[5];
    for (int arr : arrs) {
        System.out.println(arr);// 0
    }

    String[] arrs2 = new String[5];
    for (String arr2 : arrs2) {
        System.out.println(arr2);// null
    }
}

• 静态初始化：数组的初始化，和数组元素的赋值操作同时进行。

• 动态初始化 ：数组的初始化，和数组元素的赋值操作分开进行。

• 定义数组并用运算符 new 为之分配空间后，才可以引用数组中的每个元素。

• 数组元素的引用方式：数组名[数组元素下标]。

• 数组元素下标从 0 开始，长度为 n 的数组的合法下标取值范围：0 — n-1。如：int a[] = new int[3];，则可引用的数组元素为 a[0]、a[1] 和 a[2]。

• 数组元素下标可以是整型常量或整型表达式。如 a[3]，b[i]，c[6*i]。

• 数组一旦初始化完成，其长度也随即确定，且长度不可变。每个数组都有一个属性 length 指明它的长度，例如：a.length 指明数组 a 的长度 (元素个数)。

• 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。然后，再根据实际代码设置，将数组相应位置的元素进行赋值，即显示赋值。

  

  对于基本数据类型而言，默认的初始化值各有不同；对于引用数据类型而言，默认的初始化值为 null。

  char 类型的默认值是 0，不是 ‘0’，表现的是类似空格的一种效果。

• 一维数组内存解析：

  

• 一个计算联系方式的数组：

  1 2 3 4 5 6 7 8 9

  public static void main(String[] args) { int[] arr = new int[]{8, 2, 1, 0, 3}; int[] index = new int[]{2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3}; String tel = ""; for (int i = 0; i < index.length; i++) { tel += arr[index[i]]; } System.out.println("联系方式：" + tel);// 联系方式：18013820100 }

二维数组

java 语言里提供了支持多维数组的语法。如果把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。

对于二维数组的理解，可以看成是一维数组 array1，作为另一个一维数组 array2 的元素而存在。其实，从数组底层的运行机制来看，没有多维数组。

不同写法：int[][] x;，int[] x[];，int x[][];。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

public static void main(String[] args) {
    // 1-1.静态初始化，方式一
    int[][] arr = new int[][]{{3, 8, 2}, {2, 7}, {9, 0, 1, 6}};

    // 1-2.静态初始化，方式二，类型推断
    int[][] arr2 = {{3, 8, 2}, {2, 7}, {9, 0, 1, 6}};
    System.out.println(arr2[2][3]);

    // 2-1.动态初始化，方式一
    /*
    定义了名称为arr3的二维数组，二维数组中有3个一维数组，内层每一个一维数组中有2个元素
    内层一维数组的名称分别为arr3[0]，arr3[1]，arr3[2]，返回的是地址值
    给内层第一个一维数组1脚标位赋值为78写法是：arr3[0][1] = 78;
     */
    int[][] arr3 = new int[3][2];
    arr3[0][1] = 78;
    System.out.println(arr3[0]);// [I@78308db1
    System.out.println(arr3[0][1]);// 78

    // 2-2.动态初始化，方式二
    /*
    二维数组arr4中有3个一维数组，内层每个一维数组都是默认初始化值null(注意：区别于格式2-1)
    可以对内层三个一维数组分别进行初始化
     */
    int[][] arr4 = new int[3][];
    // 初始化第一个
    arr4[0] = new int[3];
    // 初始化第二个
    arr4[1] = new int[1];
    // 初始化第三个
    arr4[2] = new int[2];
    
    // 3.特殊写法
    int[] x, y[];// x是一维数组，y是二维数组
    x = new int[3];
    y = new int[3][2];
    
    // 4.获取数组长度
    System.out.println("arr的长度：" + arr.length);// 3
    System.out.println("arr第一个元素的长度：" + arr[0].length);// 3

    // 5.遍历二维数组
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + "\t");// 3	8 2	2 7	9 0	1 6
        }
    }
    System.out.println();

    // 6.简写遍历二维数组
    for (int[] valueArr : arr) {
        for (int value : valueArr) {
            System.out.print(value + "\t");// 3	8 2	2 7	9 0	1 6
        }
    }
    System.out.println();
    
    // 7.二维数组元素的默认初始化值
    int[][] arr5 = new int[3][2];
    System.out.println(arr5);// [[I@27c170f0
    System.out.println(arr5[1]);// [I@5451c3a8
    System.out.println(arr5[1][1]);// 0

    String[][] arr6 = new String[3][2];
    System.out.println(arr6);// [[Ljava.lang.String;@2626b418
    System.out.println(arr6[1]);// [Ljava.lang.String;@5a07e868
    System.out.println(arr6[1][1]);// null

    String[][] arr7 = new String[3][];
    System.out.println(arr7[1]);// null，因为内层数组未初始化
    System.out.println(arr7[1][1]);// NullPointerException
}

• 动态初始化方式一，初始化时直接规定了内层一维数组的长度，动态初始化方式二，可以在使用过程中根据需要另行初始化内层一维数组的长度。利用动态初始化方式二时，必须要先初始化内层一维数组才能对其使用，否则报空指针异常。

• int[][] arr = new int[][3]; 的方式是非法的。

• 注意特殊写法情况：int[] x,y[];// x是一维数组，y是二维数组。

• java 中多维数组不必都是规则矩阵形式。

• 数组元素的默认初始化值：针对形如 int[][] arr = new int[4][3]; 的初始化方式，外层元素的初始化值为地址值，内层元素的初始化值与一维数组初始化情况相同；针对形如 int[][] arr = new int[4][]; 的初始化方式，外层元素的初始化值为 null，内层元素没有初始化，不能调用。

• 二维数组内存解析：

  

• 杨辉三角：

  使用二维数组打印一个 10 行杨辉三角。

  

  提示：1. 第一行有 1 个元素，第 n 行有 n 个元素；2. 每一行的第一个元素和最后一个元素都是 1；3. 从第三行开始，对于非第一个元素和最后一个元
  素的元素，有：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  public static void main(String[] args) { // 1.声明二维数组并初始化 int[][] arrs = new int[10][]; for (int i = 0; i < arrs.length; i++) { System.out.print("[" + i + "]\t"); // 2.初始化内层数组，并给内层数组的首末元素赋值 arrs[i] = new int[i + 1]; arrs[i][0] = 1; arrs[i][arrs[i].length - 1] = 1; for (int j = 0; j < arrs[i].length; j++) { // 3.给从第三行开始内层数组的非首末元素赋值 if (i >= 2 && j > 0 && j < arrs[i].length - 1) { arrs[i][j] = arrs[i - 1][j - 1] + arrs[i - 1][j]; } System.out.print(arrs[i][j] + "\t"); } System.out.println(); } System.out.print("\t"); for (int i = 0; i < arrs.length; i++) { System.out.print("[" + i + "]\t"); } }

数组中涉及到的常见算法

数组元素的赋值 (杨辉三角、回形数等)

• 创建一个长度为 6 的 int 型数组，要求数组元素的值都在 1 - 30 之间，且是随机赋值。同时，要求元素的值各不相同。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  public static void main(String[] args) { int[] arr = new int[6]; for (int i = 0; i < arr.length; i++) { // 获取一个1-30之间的随机数 arr[i] = (int) (Math.random() * 30 + 1); // 判断是否有相同的值 for (int item : arr) { if (item == arr[i]) { i--; break; } } } // 遍历数组 for (int value : arr) { System.out.println(value); } }

• 回形数

  从键盘输入一个 1 - 20 的整数，然后以该数字为矩阵的大小，把 1，2，3 … n*n 的数字按照顺时针螺旋的形式填入其中。例如：

  输入数字 2，则程序输出：

  

  输入数字 3，则程序输出：

  

  输入数字 4， 则程序输出：

  

  方式一：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

  public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("输入一个数字"); int len = scanner.nextInt(); int[][] arr = new int[len][len]; int s = len * len; /* * k = 1：向右，k = 2：向下，k = 3：向左，k = 4：向上 */ int k = 1; int i = 0, j = 0; for (int m = 1; m <= s; m++) { if (k == 1) { if (j < len && arr[i][j] == 0) { arr[i][j++] = m; } else { k = 2; i++; j--; m--; } } else if (k == 2) { if (i < len && arr[i][j] == 0) { arr[i++][j] = m; } else { k = 3; i--; j--; m--; } } else if (k == 3) { if (j >= 0 && arr[i][j] == 0) { arr[i][j--] = m; } else { k = 4; i--; j++; m--; } } else if (k == 4) { if (i >= 0 && arr[i][j] == 0) { arr[i--][j] = m; } else { k = 1; i++; j++; m--; } } } // 遍历数组 for (int m = 0; m < arr.length; m++) { for (int n = 0; n < arr[m].length; n++) { System.out.print(arr[m][n] + "\t"); } System.out.println(); } }

  方式二：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

  public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("输入一个数字"); int n = scanner.nextInt(); int[][] arr = new int[n][n]; int count = 0;// 要显示的数据 int maxX = n - 1;// x轴的最大下标 int maxY = n - 1;// Y轴的最大下标 int minX = 0;// x轴的最小下标 int minY = 0;// Y轴的最小下标 while (minX <= maxX) { // 向右 for (int x = minX; x <= maxX; x++) { arr[minY][x] = ++count; } minY++; // 向下 for (int y = minY; y <= maxY; y++) { arr[y][maxX] = ++count; } maxX--; // 向左 for (int x = maxX; x >= minX; x--) { arr[maxY][x] = ++count; } maxY--; // 向上 for (int y = maxY; y >= minY; y--) { arr[y][minX] = ++count; } minX++; } // 遍历数组 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length; j++) { String space = (arr[i][j] + "").length() == 1 ? "0" : ""; System.out.print(space + arr[i][j] + " "); } System.out.println(); } }

求数值型数组中元素的最大值、最小值、平均数、总和等

• 定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来 。要求：所有随机数都是两位数。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  public static void main(String[] args) { // 初始化及赋值 int[] arr = new int[10]; int length = arr.length; for (int i = 0; i < length; i++) { int value = (int) (Math.random() * 90 + 10); arr[i] = value; } // 遍历 for (int value : arr) { System.out.print(value + "\t"); } System.out.println(); // 计算 int max = arr[0]; int min = arr[0]; int sum = 0; double average = 0; for (int value : arr) { max = max < value ? value : max; min = min > value ? value : min; sum += value; } average = sum / (length * 1.0); System.out.println("最大值：" + max); System.out.println("最小值：" + min); System.out.println("和值：" + sum); System.out.println("平均值：" + average); }

数组的复制、反转、查找 (线性查找、二分法查找)

• 复制

  虚假的复制：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

  public static void main(String[] args) { // 声明arr1和arr2 int[] arr1, arr2; arr1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19}; // 遍历arr1 for (int value : arr1) { System.out.print(value + "\t"); } System.out.println(); // 赋值arr2变量等于arr1 // 不能称作数组的复制，实际上是把arr1指向的地址(以及其他一些信息)赋给了arr2，堆空间中只有一个数组对象 arr2 = arr1; // 遍历arr2 for (int value : arr2) { System.out.print(value + "\t"); } System.out.println(); // 更改arr2 for (int i = 0; i < arr1.length; i++) { if (i % 2 == 0) { arr2[i] = i; continue; } arr2[i] = arr1[i]; } // 遍历arr2 for (int value : arr2) { System.out.print(value + "\t"); } System.out.println(); // 遍历arr1 for (int value : arr1) { System.out.print(value + "\t"); } System.out.println(); } 输出结果： 2 3 5 7 11 13 17 19 2 3 5 7 11 13 17 19 0 3 2 7 4 13 6 19 0 3 2 7 4 13 6 19

  arr1 和 arr2 地址值相同，都指向了堆空间中唯一的一个数组实体：

  

  真实的复制：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

  public static void main(String[] args) { // 声明arr1和arr2 int[] arr1, arr2; arr1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19}; // 遍历arr1 for (int value : arr1) { System.out.print(value + "\t"); } System.out.println(); // 数组的复制 arr2 = new int[arr1.length]; for (int i = 0; i < arr1.length; i++) { arr2[i] = arr1[i]; } // 遍历arr2 for (int value : arr2) { System.out.print(value + "\t"); } System.out.println(); // 更改arr2 for (int i = 0; i < arr1.length; i++) { if (i % 2 == 0) { arr2[i] = i; continue; } arr2[i] = arr1[i]; } // 遍历arr2 for (int value : arr2) { System.out.print(value + "\t"); } System.out.println(); // 遍历arr1 for (int value : arr1) { System.out.print(value + "\t"); } System.out.println(); } 输出结果： 2 3 5 7 11 13 17 19 2 3 5 7 11 13 17 19 0 3 2 7 4 13 6 19 2 3 5 7 11 13 17 19

  arr1 和 arr2 地址值不同，指向了堆空间中两个不同的数组实体：

  

• 反转

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  public static void main(String[] args) { String[] arr = {"A", "B", "C", "D", "E", "F", "G"}; // 遍历arr for (String value : arr) { System.out.print(value + "\t"); } System.out.println(); // 反转，方式一 for (int i = 0; i < arr.length / 2; i++) { String temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } for (String value : arr) { System.out.print(value + "\t"); } System.out.println(); // 反转，方式二 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } for (String value : arr) { System.out.print(value + "\t"); } System.out.println(); }

• 线性查找

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  public static void main(String[] args) { String[] arr = {"A", "B", "C", "D", "E", "F", "G"}; // 遍历arr for (String value : arr) { System.out.print(value + "\t"); } System.out.println(); String dest = "D"; boolean isFlag = true; for (int i = 0; i < arr.length; i++) { if (dest.equals(arr[i])) { System.out.println("找到了指定的元素：" + dest + "，位置为：" + i); isFlag = false; break; } } if (isFlag) { System.out.println("没找到指定的元素：" + dest); } } 输出结果： A B C D E F G 找到了指定的元素：D，位置为：3

• 二分法查找，前提：所要查找的数组必须有序。

  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

  public static void main(String[] args) { int[] arr = {2, 5, 7, 8, 10, 15, 18, 20, 22, 25, 28}; // 遍历arr for (int value : arr) { System.out.print(value + "\t"); } System.out.println(); int dest = 10; // 初始的首索引 int head = 0; // 初始的末索引 int end = arr.length - 1; boolean isFlag = true; while (head <= end) { int middle = (head + end) / 2; if (dest == arr[middle]) { System.out.println("找到了指定的元素：" + dest + "，位置为：" + middle); isFlag = false; break; } else if (dest < arr[middle]) { end = middle - 1; } else {// dest2 > arr2[middle] head = middle + 1; } } if (isFlag) { System.out.println("没找到指定的元素：" + dest); } } 输出结果： 2 5 7 8 10 15 18 20 22 25 28 找到了指定的元素：10，位置为：4

数组元素的排序算法

排序：假设含有 n 个记录的序列为 {R1, R2, …, Rn}，其相应的关键字序列为 {K1, K2, …, Kn}。将这些记录重新排序为 {Ri1, Ri2, …, Rin}，使得相应的关键字值满足条 Ki1<= Ki2 <= … <= Kin，这样的一种操作称为排序。通常来说，排序的目的是快速查找。

衡量排序算法的优劣：

1. 时间复杂度：分析关键字的比较次数和记录的移动次数。

2. 空间复杂度：分析排序算法中需要多少辅助内存。

3. 稳定性：若两个记录 A 和 B 的关键字值相等，但排序后 A、B 的先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类：内部排序和外部排序。

• 内部排序：整个排序过程不需要借助于外部存储器 (如磁盘等)，所有排序操作都在内存中完成。

• 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器 (如磁盘等)。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序算法：

排序算法性能对比：

• 从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
• 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于 Shell 排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
• 从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排序、快速排序、 Shell 排序和堆排序是不稳定排序。
• 从待排序的记录数 n 的大小看，n 较小时，宜采用简单排序；而 n 较大时宜采用改进排序。

排序算法的选择：

• 若 n 较小 (如 n ≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
• 若文件初始状态基本有序 (指正序)，则应选用直接插入、 冒泡或随机的快速排序为宜。
• 若 n 较大，则应采用时间复杂度为 O(nlgn) 的排序方法： 快速排序、 堆排序或归并排序。

冒泡排序

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

排序思想：

1. 比较相邻的元素。如果第一个比第二个大 (升序)，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public static void main(String[] args) {
    int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};

    // 遍历arr
    for (int value : arr) {
        System.out.print(value + "\t");
    }
    System.out.println();

    // 冒泡排序
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 遍历arr
    for (int value : arr) {
        System.out.print(value + "\t");
    }
    System.out.println();
}
输出结果：
43	32	76	-98	0	64	33	-21	32	99
-98	-21	0	32	32	33	43	64	76	99

快速排序

快速排序通常明显比同为 O(nlogn) 的其他算法更快，因此常被采用，而且快速排序采用了分治法的思想，所以在很多笔试面试中能经常看到快速排序的影子，可见掌握快速排序的重要性。

快速排序 (Quick Sort) 由图灵奖获得者 Tony Hoare 发明，被列为 20 世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。

快速排序属于冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为 O(nlog(n))。

排序思想：

1. 从数列中挑出一个元素，称为”基准” (pivot)。
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面 (相同的数可以到任一边)。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区 (partition) 操作。
3. 递归地 (recursive) 把小于基准值元素的子数列和大于基准值元素的子数列排序。
4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 (iteration) 中，它至少会把一个元素摆到它最后的位置去。

Arrays 工具类的使用

java.util.Arrays 类为操作数组的工具类，包含了用来操作数组 (比如排序和搜索) 的各种方法。常用的方法有：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static void main(String[] args) {
    // 1.boolean equals(int[] a,int[] b)：判断两个数组是否相等
    int[] arr1 = new int[]{1, 2, 3, 4};
    int[] arr2 = new int[]{1, 3, 2, 4};
    boolean isEquals = Arrays.equals(arr1, arr2);
    System.out.println("arr1和arr2是否相等：" + isEquals);

    // 2.String toString(int[] a)：遍历数组信息
    System.out.println("arr1：" + Arrays.toString(arr1));

    // 3.void fill(int[] a,int val)：将指定值填充到数 组之中
    Arrays.fill(arr1, 10);
    System.out.println("arr1填充后：" + Arrays.toString(arr1));

    // 4.void sort(int[] a)：对数组进行排序，底层使用的是快速排序
    System.out.println("arr2排序前：" + Arrays.toString(arr2));
    Arrays.sort(arr2);
    System.out.println("arr2排序后：" + Arrays.toString(arr2));

    // 5.int binarySearch(int[] a,int key)：对排序后的数组进行二分法检索指定的值
    int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
    int dest = 211;
    int index = Arrays.binarySearch(arr3, dest);
    if (index >= 0) {
        System.out.println(dest + "在数组中的位置为：" + index);
    } else {
        System.out.println(dest + "在数组中未找到：" + index);
    }
}
输出结果：
arr1和arr2是否相等：false
arr1：[1, 2, 3, 4]
arr1填充后：[10, 10, 10, 10]
arr2排序前：[1, 3, 2, 4]
arr2排序后：[1, 2, 3, 4]
211在数组中未找到：-10

数组中的常见异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public static void main(String[] args) {
    // ArrayIndexOutOfBoundsException
    int[] arr = new int[]{7, 10};
    System.out.println(arr[2]);// 数组脚标越界
    System.out.println(arr[-1]);// 访问了数组中不存在的脚标

    // NullPointerException：空指针异常，arr引用没有指向实体，却被操作实体中的元素
    // 情形一
    int[] arr2 = null;
    System.out.println(arr2[0]);
    // 情形二
    int[][] arr3 = new int[4][];
    System.out.println(arr3[0]);// null
    System.out.println(arr3[0][0]);// NullPointerException
    // 情形三
    String[] arr4 = new String[]{"AA", "BB", "CC"};
    arr4[0] = null;
    System.out.println(arr4[0].toString());// 对null调用了方法
}

ArrayIndexOutOfBoundsException 和 NullPointerException，在编译时，不报错！！

面向对象

三条主线：

1. java 类及类的成员：属性、方法、构造器、代码块、内部类。
2. 面向对象的三大特征：封装性、继承性、多态性、(抽象性)。
3. 其他关键字：this、super、static、final、abstract、interface、package、import等。

面向过程 (POP) 与面向对象 (OOP)：

• 二者都是一种思想，面向对象是相对于面向过程而言的。
• 面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
• 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

例如，人把大象装进冰箱：

面向对象的三大特征：

• 封装 (Encapsulation)
• 继承 (Inheritance)
• 多态 (Polymorphism)

面向对象的思想概述：

1. 程序员从面向过程的执行者转化成了面向对象的指挥者。
2. 面向对象分析方法分析问题的思路和步骤：
   • 根据问题需要，选择问题所针对的现实世界中的实体。
   • 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
   • 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
   • 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

java基本元素：类和对象

类 (Class) 和对象 (Object) 是面向对象的核心概念。

• 类是对一类事物的描述，是抽象的、概念上的定义。

• 对象是实际存在的该类事物的每个个体，因而也称为实例 (instance)。

常见的类的成员有：

• 属性：对应类中的成员变量。

• 方法：对应类中的成员方法。

类的成员构成 version 1.0：

类的成员构成 version 2.0：

类的语法格式：

创建 java 自定义类步骤：

1. 定义类：考虑修饰符、类名。
2. 编写类的属性：考虑修饰符、属性类型、属性名、初始化值。
3. 编写类的方法：考虑修饰符、返回值类型、方法名、形参等。

类的访问机制：

• 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。例外：static 方法访问非 static 属性，编译不通过。

• 在不同类中的访问机制： 先创建要访问类的对象， 再用对象访问类中定义的成员。

对象的创建和使用：

• 创建对象语法：

  

• 使用 对象名.对象成员 的方式访问对象成员，包括属性和方法。

• 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性 (非 static 的)，即：修改一个对象的属性 a，不影响另外一个对象属性 a 的值。

对象的产生：

对象的使用：

对象的生命周期：

对象的内存解析：

例如，下面一段代码的内存图如下：

匿名对象：

• 不定义对象的句柄，而直接调用这个对象的方法，这样的对象叫做匿名对象。如：new Person().shout();。

• 使用情况：如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。我们经常将匿名对象作为实参传递给一个方法调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

/**
 * 二、创建类的对象 = 类的实例化
 */
public class PersonTest {
    public static void main(String[] args) {
        // 1.创建Person类的对象
        Person person = new Person();

        // 2.调用对象的结构：属性和方法
        // 2-1.调用属性："对象.属性"
        person.name = "Tom";
        person.isMale = true;
        System.out.println("年龄：" + person.age);// 1
        // 2-2.调用方法："对象.方法"
        person.eat();// 人可以吃饭
        person.sleep();// 人可以睡觉
        person.talk("Chinese");// 人可以说话，语言是：Chinese

        // 3.创建一个新的Person类的对象
        Person person2 = new Person();
        System.out.println(person2.name);// null，非Tom

        // 4.将person变量保存的地址值赋值给person3，此时，二者指向堆空间中的同一个对象实体
        // 修改person和person3，效果相同
        Person person3 = person;
        System.out.println(person3.name);// Tom
        person3.age = 10;
        System.out.println(person.age);// 10
    }
}

/**
 * 一、类的设计，其实就是类的成员的设计：
 * 属性 = 成员变量 = Field = 域、字段
 * 方法 = 成员方法 = 函数 = Method
 */
class Person {
    // 属性
    String name;
    int age = 1;
    boolean isMale;

    // 方法
    public void eat() {
        System.out.println("人可以吃饭");
    }

    public void sleep() {
        System.out.println("人可以睡觉");
    }

    public void talk(String language) {
        System.out.println("人可以说话，语言是：" + language);
    }
}

类的成员之一：属性 (field)

语法格式：

• 常用的权限修饰符有：private、缺省、protected、public。其他修饰符：static、final。

• 数据类型：任何基本数据类型 (如 int、boolean 等) 或任何引用数据类型。

• 属性名：属于标识符，符合命名规则和规范即可。

属性 (成员变量) 与局部变量的区别：

• 成员变量的默认初始化值：当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型。

  

• 局部变量的默认初始化值：局部变量声明后，没有默认初始化值，必须显式赋值，方可使用。特别的，形参在调用时，赋值即可。

• 成员变量 vs 局部变量的内存位置：

  

属性赋值的方式和先后顺序：

• 赋值的方式：

  • ① 默认初始化
  • ② 显示初始化
  • ③ 构造器中初始化
  • ④ 通过 “对象.属性” 或 “对象.方法” 的方式赋值

• ⑤ 在代码块中初始化

• 赋值的先后顺序：① - ② / ⑤ - ③ - ④

• ② 和 ⑤，谁定义在前，谁先赋值：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  public class Test { public static void main(String[] args) { Order order = new Order(); System.out.println(order.orderId);// 4 } } class Order { int orderId = 3; { orderId = 4; } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  public class Test { public static void main(String[] args) { Order order = new Order(); System.out.println(order.orderId);// 3 } } class Order { { orderId = 4; } int orderId = 3; }

• 总结：程序中成员变量赋值的执行顺序

  

类的成员之二：方法 (method)

什么是方法 (method 、函数)：

• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
• 将功能封装为方法的目的是，可以实现代码重用，简化代码。
• java 里的方法不能独立存在，所有的方法必须定义在类里。

声明格式：

• 权限修饰符：public，缺省，private，protected 等。

• 返回值类型：

  • 没有返回值：使用void。
  • 有返回值：在方法声明时，必须指定返回值的类型，同时，方法体中需要使用 return 关键字返回指定类型的变量或常量。

• 方法名 ：属于标识符，命名时遵循标识符命名规则和规范，能够见名知意。

• 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用 “,” 隔开。

• 方法体程序代码：方法功能的具体实现。

• 返回值：方法在执行完毕后返还给调用它的程序的数据。

方法的分类：按照是否有形参及返回值。

方法的调用：

• 方法通过方法名被调用，且只有被调用才会执行。

• 方法调用的过程：

  

• 方法被调用一次，就会执行一次。

• 没有具体返回值的情况，返回值类型用关键字 void 表示，此时方法体中可以不必使用 return 语句。如果使用，表示用来结束方法。

• 定义方法时，方法的结果应该返回给调用者，交由调用者处理。

• 方法中可以调用当前类的属性或方法，不可以在方法内部定义方法。

方法的重载 (overload)

• 概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

• 特点：与方法的权限修饰符、返回值类型、形参变量名、方法体都无关，只看参数列表，且参数列表 (参数个数或参数类型) 必须不同。调用时，根据方法参数列表的不同来区别。

• 如果方法一不存在，main 方法依然正常执行，此时涉及到的是自动类型转换：

  1 2 3 4 5 6 7 8 9 10 11 12 13

  // 方法一 public static int getSum(int m, int n) { return m + n; } // 方法二 public static double getSum(double m, double n) { return m + n; } public static void main(String[] args) { System.out.println(getSum(1, 2)); }

可变个数的形参：

• JavaSE 5.0 中提供了 Varargs (variable number of arguments) 机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

  

• 声明格式：方法名(参数的类型名 … 参数名)

• 可变参数：方法参数部分指定类型的参数个数是可变多个 — 0个，1个或多个。

• 可变个数形参的方法与同名的方法之间，彼此构成重载。

• 可变参数方法的使用与方法参数部分使用数组是一致的，二者不共存。如下所示，方法二与方法三是相同的，不共存：

  1 2 3 4 5 6 7 8 9

  // 方法二 public static void show(int... m) { System.out.println(Arrays.toString(m));// m参数等同于数组，与数组的使用方法相同。 } // 方法三 public static void show(int[] m) { System.out.println(m); }

• 方法的参数部分有可变形参，需要放在形参声明的最后。

  1 2 3 4 5 6 7 8 9

  // 合法 public static void show(String str, int... m) { System.out.println(Arrays.toString(m)); } // 不合法 public static void show(int... m, String str) { System.out.println(Arrays.toString(m)); }

• 在一个方法的形参位置，最多只能声明一个可变个数形参。

方法参数的值传递机制

• 方法，必须由其所在类或对象调用才有意义。若方法含有参数：

  • 形参：方法声明时的参数。
  • 实参：方法调用时实际传给形参的数据。

• java 的实参值如何传入方法呢？

  • java 里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本 (复制品) 传入方法内，而参数本身不受影响。
    • 形参是基本数据类型：将实参基本数据类型变量的 “数据值” 传递给形参。
    • 形参是引用数据类型：将实参引用数据类型变量的 “地址值” 传递给形参。

• 形参时基本数据类型与引用数据类型之间的区别:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  public class ValueTransferTest { public static void main(String[] args) { System.out.println("***************基本数据类型***************"); int m = 10; int n = m; System.out.println("m = " + m + ", n = " + n); n = 20; System.out.println("m = " + m + ", n = " + n); System.out.println("***************引用数据类型***************"); Order o1 = new Order(); o1.orderId = 1001; Order o2 = o1;// 赋值后, o1和o2的地址值相同, 都指向了堆空间中的同一个实体 System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId); o2.orderId = 1002; System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId); } } class Order { int orderId; } 输出结果： ***************基本数据类型*************** m = 10, n = 10 m = 10, n = 20 ***************引用数据类型*************** o1.orderId = 1001, o2.orderId = 1001 o1.orderId = 1002, o2.orderId = 1002

• 对于基本数据类型，两个不同方法内的局部变量，互不影响，不因变量名相同而改变，因为是将实参基本数据类型变量的 “数据值” 传递给形参：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

  public class ValueTransferTest { public void swap(int m, int n) { System.out.println("swap方法中, 交换之前: m = " + m + ", n = " + n); int temp = m; m = n; n = temp; System.out.println("swap方法中, 交换之后: m = " + m + ", n = " + n); } public static void main(String[] args) { int m = 10; int n = 20; System.out.println("main方法中, 交换之前: m = " + m + ", n = " + n); // 能够交换m和n的值 int temp = m; m = n; n = temp; System.out.println("main方法中, 交换之后: m = " + m + ", n = " + n); // 不能够交换m和n的值 ValueTransferTest valueTransferTest = new ValueTransferTest(); System.out.println("main方法中, 调用swap方法之前: m = " + m + ", n = " + n); valueTransferTest.swap(m, n);// // swap方法调用完成后, 该方法内的局部变量temp, 形参m和n从栈内存中弹出回收 System.out.println("main方法中, 调用swap方法之后: m = " + m + ", n = " + n); } } 输出结果： main方法中, 交换之前: m = 10, n = 20 main方法中, 交换之后: m = 20, n = 10 main方法中, 调用swap方法之前: m = 20, n = 10 swap方法中, 交换之前: m = 20, n = 10 swap方法中, 交换之后: m = 10, n = 20 main方法中, 调用swap方法之后: m = 20, n = 10

  内存解析图参考：

  

• 对于引用数据类型，两个不同方法的局部变量，会互相影响，因为是将实参引用数据类型变量的 “地址值” 传递给形参，二者指向的是堆内存中的同一个对象：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

  public class ValueTransferTest { public void swap(Data data) { System.out.println("swap方法中, 交换之前: data.m = " + data.m + ", data.n = " + data.n); int temp = data.m; data.m = data.n; data.n = temp; System.out.println("swap方法中, 交换之后: data.m = " + data.m + ", data.n = " + data.n); } public static void main(String[] args) { Data data = new Data(); data.m = 10; data.n = 20; System.out.println("main方法中, 交换之前: data.m = " + data.m + ", data.n = " + data.n); // 能够交换m和n的值 int temp = data.m; data.m = data.n; data.n = temp; System.out.println("main方法中, 交换之后: data.m = " + data.m + ", data.n = " + data.n); // 能够交换m和n的值 ValueTransferTest valueTransferTest = new ValueTransferTest(); System.out.println("main方法中, 调用swap方法之前: data.m = " + data.m + ", data. = " + data.n); valueTransferTest.swap(data);// swap方法调用完成后, 该方法内的局部变量temp和形参data从栈内存中弹出回收 System.out.println("main方法中, 调用swap方法之后: data.m = " + data.m + ", data.n = " + data.n); } } class Data { int m; int n;java } 输出结果： main方法中, 交换之前: data.m = 10, data.n = 20 main方法中, 交换之后: data.m = 20, data.n = 10 main方法中, 调用swap方法之前: data.m = 20, data. = 10 swap方法中, 交换之前: data.m = 20, data.n = 10 swap方法中, 交换之后: data.m = 10, data.n = 20 main方法中, 调用swap方法之后: data.m = 10, data.n = 20

  内存解析图参考：

  

• 实例一：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  public class ValueTransferTest { public void first() { int i = 5; Value v = new Value(); v.i = 25; second(v, i); System.out.println(v.i);// 20 } public void second(Value v, int i) { i = 0; v.i = 20; Value val = new Value(); v = val; System.out.println(v.i + " " + i);// 15 0 } public static void main(String[] args) { ValueTransferTest test = new ValueTransferTest(); test.first(); } } class Value { int i = 15; }

  

• 实例二：

  

  方法一：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  public class Test { public static void method(int a, int b) { System.out.println("a = " + a * 10); System.out.println("b = " + b * 20); System.exit(0); } public static void main(String[] args) { int a = 10; int b = 10; method(a, b); System.out.println("a = " + a); System.out.println("b = " + b); } }

  方法二：重写 PrintStream 的 println 方法。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  public class Test { public static void method(int a, int b) { PrintStream printStream = new PrintStream(System.out) { @Override public void println(String x) { if ("a = 10".equals(x)) { x = "a = 100"; } else if ("b = 10".equals(x)) { x = "b = 200"; } super.println(x); } }; System.setOut(printStream); } public static void main(String[] args) { int a = 10; int b = 10; method(a, b); System.out.println("a = " + a); System.out.println("b = " + b); } }

• 实例三：

  定义一个 int 型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};，让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值，然后遍历新的数组。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  public class Test { public static void main(String[] args) { int[] arr = new int[]{12, 3, 3, 34, 56, 77, 432}; System.out.println("计算前: " + Arrays.toString(arr)); // 正确写法一 int temp = arr[0]; for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] / temp; } // 正确写法二 for (int i = arr.length - 1; i >= 0; i--) { arr[i] = arr[i] / arr[0]; } // 错误写法 /*for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] / arr[0]; }*/ System.out.println("计算后: " + Arrays.toString(arr)); } }

• 实例四：

  1 2 3 4 5 6 7 8 9 10 11 12

  public class Test { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3}; System.out.println(arr);// 地址值 char[] arr1 = new char[]{'a', 'b', 'c'}; System.out.println(arr1);// 传入char数组时，println方法体内是遍历这个数组 } } 输出结果： [I@78308db1 abc