0、Java工具包术语

1、Java程序简单规范

1）Java 区分大小写，即对大小写敏感；

2）类名只能是下划线和字母开头，其后可以是下划线、字母和数字；

3）类名命名规范需符合驼峰标识法；

2、三种注释方式

1）// ，行注释；

2）/* */，多行注释；

3）/** */，多行注释，会生成 javadoc 文档；

3、基础数据类型

1）java 中整型范围与平台机器无关；

2）c++ 中整型与机器有关，16位和32位整型范围是不一样的；

3.1、整型（有4种）

1）long 类型需加后缀 L 或 l，小于 int 类型最大值时可以不使用后缀，超过 int 类型最大值时必须加上后缀 L 或 l；

int 类型最大值：2147483647；

2）十六进制需加前缀 0x 或 0X；

3）八进制需加前缀 0；

3）二进制需加前缀 0b 或 0B；

4）数字之间可以加下划线，让人易懂，编译器编译的时候会自动去掉下划线；

下划线不能加在数字最前或最后；

3.2、浮点型（有2种）

1）float 类型数值需加后缀 F 或 f，该类型很少使用，不加后缀默认是 double 类型；

2）double 类型数值可以加后缀 D 或 d；

3）数字之间可以加下划线，让人易懂，编译器编译的时候会自动去掉下划线；

下划线不能加在数字最前或最后；

4）可以十六进制表示浮点型，0x1.0p-3，p表示指数 2，3 表示次方；

0x1.0p-3 表示0x1 * 2的负3次方

0x1.0p3 表示0x1 * 2的3次方

0xap-3 表示0xa * 2的3次方

5）三个常量

正无穷大，Double.POSITIVE_INFINITY / Float.POSITIVE_INFINITY

负无穷大，Double.NEGATIVE_INFINITY / Float.NEGATIVE_INFINITY

不是数字 NaN（Not-a-Number），Double.NaN / Float.NaN

isInfinite(a) / isFinite(a) / Double.isNaN(0.0/0)

3.3、char类型（最好不要使用）

1）用单引号括起来；

2）可以使用十六进制表示

3）\u 是转义字符；

3.4、boolean类型

1）两种可选值true / false；

4、变量

4.1、变量命名规范

1）由字母和数字组成，字母包括一些26个字母之外的字符；

2）如何判断 Unicode 字符是 java 中的字母，使用如下方法：

Character.isJavaIdentifierStart('@')

Character.isJavaIdentifierPart('@')

3）不要在代码中使用 $ 符号来声明变量名称，尽管是可以的；

4）变量名称大小写敏感；

4.2、变量初始化

1）变量需要初始化才能使用；

4.3、常量

1）使用 final 关键字修饰常量，final 表示变量只能赋值一次，赋值后不能再被修改了，也就是常量了；

2）常量名称一般大写；

3）类常量，使用 static final 关键字修饰；

类常量需定义在类中，不能定义在方法内；

5、运算符

1）算术运算符：加（+） 、减（-）、乘（*）、除（/）、求余（% 也叫取模）；

2）进行除（/）运算时：

两个操作数都是整型则是整数除法；

两个操作数有一个是浮点型时，表示浮点除法；

3）strictfp 关键字，表示采用最严格的计算；

strictfp 关键字修饰在方法上时，表示方法内的计算都是采用最严格的计算；

strictfp 关键字修饰在类上时，表示该类中的方法都是采用最严格的计算；

5.1、数学函数与常量

1）java.lang.Math 类

2）java.lang.StrictMath 类

5.2、数值类型之间的转换

1）实心箭头表示无信息丢失的转换；

2）虚线箭头表示可能会有精度损失的转换；

3）两个数值进行二元操作，会先自动转换为同一类型再计算；

5.3、强制类型转换

1）强制类型转换，会将小数部分截断将浮点值转换为整型；

2）对浮点数进行四舍五入，得到最接近的整型；

3）对浮点型数据进行加减乘除计算，小数点前面的 0 可以不写；

5.4、结合赋值和运算

5.5、自增、自减

1）前缀形式：++n / --n，先计算再使用；

2）后缀形式：n++ / n--，先使用再计算；

3）不建议在运算中使用自增、自减运算，容易混淆；

5.6、关系和 boolean 运算符

== / != / > / >= / < / <= / &&（短路与） / ||（短路或）

三目运算符；

5.7、位运算符

1）可以把整型用二进制来表示，能够很清楚的看懂位运算；

2）& 运算符：两个整数进行 &（与）运算，需对应的二进制位都是 1 计算的位值才为 1，其他情况都是 0；

也可用作与运算，类似 &&（短路与），只不过 & 运算符两边都会计算；

3）| 运算符：两个整数进行 |（或）运算，需对应的二进制位有一个是 1 计算的位值才为 1，都是 0 位值才是 0；

也可用作或运算，类似 ||（短路或），只不过 | 运算符两边都会计算；

4）^ 运算符：异或运算，对应的二进制位值相同则为 0，不同则为 1；

5）整型转二进制的方法，Integer.toBinaryString(13)

6）介绍 ~ 非运算之前，先了解原码、反码、补码；

int 类型是32位，表示二进制时有32位；

long 类型是 64 位，表示二进制时有 64 位；

> 二进制前面的 0 不显示，左边第一位是符号位，1表示负数，0表示正数；

> 正数 5 对应的：

原码：00000000 00000000 00000000 00000101

反码：00000000 00000000 00000000 00000101（和原码一样）

补码：00000000 00000000 00000000 00000101（和原码一样）

> 负数 -5 对应的：

原码：10000000 00000000 00000000 00000101

反码：11111111 11111111 11111111 11111010（除符号位外各位在原码基础上取反）

补码：11111111 11111111 11111111 11111011（反码+1）

> 计算机内部是使用补码来存储和表示值的；

> 计算机硬件只有加数器，正数和负数、负数和负数相加时使用补码二进制实现加减计算；

7）~ 运算符，非运算，原位取反；

非运算计算过程：

1）正数 3 的补码：00000000 00000000 00000000 00000011

2）非运算原位取反：11111111 11111111 11111111 11111100（补码）

3）补码对应多少整型数值呢？自解析：

补码转反码：11111111 11111111 11111111 11111011（补码-1）

反码转原码：10000000 00000000 00000000 00000100（符号位不变）

我们发现原码对应的是整型数值 -4；

8）<< 运算符，位左移，右边补0

> 正数左移，2 << 3 = 16（相当于在2的基础上扩大了2的3次方倍，即2*8=16）

正数左移，2 << 3 = 16（相当于在2的基础上扩大了2的3次方倍，即2*8=16）：

2 的补码：00000000 00000000 00000000 00000010（与原码一致）

左移 3 位：00000000 00000000 00000000 00010000

> 负数左移，-2 << 3 = -16（相当于在-2的基础上扩大了2的3次方倍，即-2*8=16）

负数左移，-2 << 3 = -16：

-2的原码：10000000 00000000 00000000 00000010

-2的反码：11111111 11111111 11111111 11111101

-2的补码：11111111 11111111 11111111 11111110

左移 3 位的补码：11111111 11111111 11111111 11110000

对应反码：11111111 11111111 11111111 11101111

对应原码：10000000 00000000 00000000 00010000

> 移动位数需要先进行 32 位取模，即求余（long 类型需要 64 位取模）；

9）>> 运算符，位右移；

> 正数右移，125 >> 3 = 15，左边补 0；

> 负数右移，-125 >> 3 = -16，左边补 1；

10）>>> 运算符，无符号位右移，正负数都是左边补 0；

? 正数右移，125 >> 3 = 15，左边补 0

? 负数右移，-125 >> 3 = -16，左边补 0

5.8、括号与运算符优先级

1）不使用括号时，是按照优先级来计算的；

2）同一级别的运算符是按出现的顺序从左至右进行计算的，右结合运算符除外；

3）右结合运算符是先计算右边的；

6、Math 类和 StrictMath 类

6.1、random() 方法

1）随机返回 [0, 1) 之间的 double 类型的值；

6.2、floor() 方法

1）Math.floor(1.2) 向下舍取整，保留一位小数；

6.3、floorDiv() 方法

1）求商，Math.floorDiv(13, 3) 求商，返回 int 或 long 型，下舍取整；

6.4、floorMod() 方法

1）求余，Math.floorMod(17, 6)，求余；

6.5、其他方法

public static void main(String[] args) {
    int abs = Math.abs(-10);
    System.out.println("Math.abs(-10) 绝对值=" + abs);
    
    int addExact = Math.addExact(20, -3);
    System.out.println("Math.addExact(20, -3) 两数相加=" + addExact);
    
    double ceil1 = Math.ceil(-1.4);
    double ceil2 = Math.ceil(-1.5);
    double ceil3 = Math.ceil(1.5);
    double ceil4 = Math.ceil(1.4);
    System.out.println("Math.ceil(-1.4) 返回大于或等于指定浮点数中，最小的整数对应的浮点数=" + ceil1);
    System.out.println("Math.ceil(-1.5) 返回大于或等于指定浮点数中，最小的整数对应的浮点数=" + ceil2);
    System.out.println("Math.ceil(1.5) 返回大于或等于指定浮点数中，最小的整数对应的浮点数=" + ceil3);
    System.out.println("Math.ceil(1.4) 返回大于或等于指定浮点数中，最小的整数对应的浮点数=" + ceil4);
    
    double floor1 = Math.floor(-1.4);
    double floor2 = Math.floor(-1.5);
    double floor3 = Math.floor(1.5);
    double floor4 = Math.floor(1.4);
    System.out.println("Math.floor(-1.4) 返回小于或等于指定浮点数中，最大的整数对应的浮点数=" + floor1);
    System.out.println("Math.floor(-1.5) 返回小于或等于指定浮点数中，最大的整数对应的浮点数=" + floor2);
    System.out.println("Math.floor(1.5) 返回小于或等于指定浮点数中，最大的整数对应的浮点数=" + floor3);
    System.out.println("Math.floor(1.4) 返回小于或等于指定浮点数中，最大的整数对应的浮点数=" + floor4);
    
    int floorDiv1 = Math.floorDiv(17, 5);
    int floorDiv2 = Math.floorDiv(-17, 5);
    System.out.println("Math.floorDiv(17, 5) 返回小于或等于代数商中，最大的整数=" + floorDiv1);
    System.out.println("Math.floorDiv(-17, 5) 返回小于或等于代数商中，最大的整数=" + floorDiv2);
    
    int floorMod1 = Math.floorMod(17, 5);
    int floorMod2 = Math.floorMod(-17, 5);
    System.out.println("Math.floorMod(17, 5) 取模公式[x - (floorDiv(x, y) * y)]，结果=" + floorMod1);
    System.out.println("Math.floorMod(-17, 5) 取模公式[x - (floorDiv(x, y) * y)]，结果=" + floorMod2);
    
    int incrementExact1 = Math.incrementExact(17);
    int incrementExact2 = Math.incrementExact(-17);
    System.out.println("Math.incrementExact(17) 返回指定参数加+1=" + incrementExact1);
    System.out.println("Math.incrementExact(-17) 返回指定参数加+1=" + incrementExact2);
    
    int max1 = Math.max(18, 17);
    int max2 = Math.max(-18, 17);
    int max3 = Math.max(-18, -17);
    System.out.println("Math.max(18, 17) 取最大值=" + max1);
    System.out.println("Math.max(-18, 17) 取最大值=" + max2);
    System.out.println("Math.max(-18, -17) 取最大值=" + max3);
    
    int multiplyExact1 = Math.multiplyExact(3, 5);
    int multiplyExact2 = Math.multiplyExact(3, -5);
    int multiplyExact3 = Math.multiplyExact(-3, -5);
    System.out.println("Math.multiplyExact(3, 5) 两个指定参数相乘=" + multiplyExact1);
    System.out.println("Math.multiplyExact(3, -5) 两个指定参数相乘=" + multiplyExact2);
    System.out.println("Math.multiplyExact(-3, -5) 两个指定参数相乘=" + multiplyExact3);
    
    double pow1 = Math.pow(3, 2);
    double pow2 = Math.pow(-3, 2);
    System.out.println("Math.pow(3, 2) a的b次方=" + pow1);
    System.out.println("Math.pow(-3, 2) a的b次方=" + pow2);
    
    double random1 = Math.random();
    System.out.println("Math.random() 返回[0, 1)之间的随机数=" + random1);
    
    long round1 = Math.round(1.4);
    long round2 = Math.round(1.5);
    long round3 = Math.round(-1.4);
    long round4 = Math.round(-1.5);
    long round5 = Math.round(-1.6);
    System.out.println("Math.round(1.4) 返回最接近指定参数的整数=" + round1);
    System.out.println("Math.round(1.5) 返回最接近指定参数的整数=" + round2);
    System.out.println("Math.round(-1.4) 返回最接近指定参数的整数=" + round3);
    System.out.println("Math.round(-1.5) 返回最接近指定参数的整数（负数时注意小数点后的5）=" + round4);
    System.out.println("Math.round(-1.6) 返回最接近指定参数的整数=" + round5);
}

7、控制流程

7.1、块作用域

7.2、循环

7.3、多重选择 swithc/case

1）case 标签可以是如下：

char / byte / int / short 常量表达式；

枚举常量；

字符串字面量；

7.4、中断流程，跳出循环

1）带标签 break；

2）这种标签可以放置在任何地方，可以被任何流程控制块使用；

8、数组

8.1、声明数组

8.2、数组拷贝

1）Arrays.copyOf 方法是拷贝数组元素到新的数组中；

8.3、数组排序

1）Arrays.sort() 排序方法采用的是快速排序算法，该方法适用于数值类型的数组；

8.4、java.util.Arrays 类

1）Arrays.toString(arr) 数组转字符串；

2）Arrays.copyOf 数组拷贝；

3）Arrays.sort() 数组排序；

4）Arrays.binarySearch(a, 12)，使用二分查找算法，在数组中查找指定元素，查到则返回下标，没查到则返回负值；

5）Arrays.fill(a, 2) 填充数组中所有元素为指定值；

8.5、多维数组

8.6、不规则数组