在有限的符号中，我们揭示无限的真理。

前言

这里是分享 Java 相关内容的专刊，每日一更。

本期将为大家带来以下内容：

1. Java 的整数类型
2. 基本的整数运算符
3. 整数除法与取模
4. 自增与自减运算
5. 整数的进制表示
6. 整数溢出问题
7. 位运算
8. 整数的优化技巧
9. 类型自动提升（Type Promotion）
10. 强制类型转换（Type Casting）

Java 的整数类型

Java 是一种强类型语言，变量在声明时必须指定类型。对于整数运算，Java 提供了以下几种基本数据类型：

类型	大小	最小值	最大值
byte	1 字节	-128	127
short	2 字节	-32,768	32,767
int	4 字节	$-2^{31}$	$2^{31}-1$
long	8 字节	$-2^{63}$	$2^{63}-1$

这些类型主要区别在于存储的整数范围。最常用的整数类型是 int，它足够处理大多数普通整数运算。如果需要处理更大范围的整数，long 是合适的选择。

基本的整数运算符

Java 中的基本整数运算符与其他主流编程语言类似，支持的操作包括加、减、乘、除等。以下是 Java 支持的整数运算符：

• + ：加法
• - ：减法
• * ：乘法
• / ：除法
• % ：取模（求余）

int a = 10;
int b = 3;
System.out.println("加法: " + (a + b));  // 输出: 13
System.out.println("减法: " + (a - b));  // 输出: 7
System.out.println("乘法: " + (a * b));  // 输出: 30
System.out.println("除法: " + (a / b));  // 输出: 3
System.out.println("取模: " + (a % b));  // 输出: 1

整数除法与取模

整数除法运算会舍去小数部分，返回一个整数结果。例如，10 / 3 的结果是 3 而不是 3.333。如果需要得到除法运算后的余数，可以使用取模运算符 %。

int result = 10 / 3;    // 结果是 3
int remainder = 10 % 3; // 余数是 1

这种整数除法与取模的组合常常用于循环控制、数据分段等场景。

自增与自减运算

Java 提供了自增（++）与自减（--）运算符，用于对整数进行快速的加 1 或减 1 操作。这些运算符有两种形式：前置 和 后置 ，它们的执行顺序有所不同。

• 前置运算符（++x 或 --x）：先对变量进行加 1 或减 1 操作，然后再返回修改后的值。
• 后置运算符（x++ 或 x--）：先返回当前变量的值，然后再进行加 1 或减 1 操作。

int x = 5;
int y = ++x;  // 先将 x 加 1（x 变为 6），然后将结果赋值给 y，所以 y 的值为 6
int z = x--;  // 先将 x 的当前值（6）赋给 z，然后再将 x 减 1（x 变为 5）

整数的进制表示

Java 支持多种进制表示方法：

• 十进制：常规的数字表示，例如 100。
• 二进制：用 0b 开头表示，例如 0b1101 表示十进制的 13。
• 八进制：用 0 开头表示，例如 012 表示十进制的 10。
• 十六进制：用 0x 开头表示，例如 0x1F 表示十进制的 31。

int decimal = 100;   // 十进制
int binary = 0b1101; // 二进制
int octal = 012;     // 八进制
int hex = 0x1F;      // 十六进制

整数溢出问题

由于整数类型的有限存储空间，超出范围的运算可能会导致 溢出。Java 不会在整数溢出时抛出异常，而是默默地将值“环绕”到最小值。例如，int 的最大值是 2147483647，如果加 1，结果会变成 -2147483648。

int maxValue = Integer.MAX_VALUE;
System.out.println(maxValue + 1);  // 输出: -2147483648

为了解决溢出问题，Java 提供了 java.lang.Math 类中的一些方法，如 Math.addExact()，它在检测到溢出时会抛出 ArithmeticException 异常。

int result = Math.addExact(Integer.MAX_VALUE, 1);

位运算

Java 提供了位运算符，允许直接操作整数的二进制位。这些运算包括按位与、按位或、按位异或、位移操作等。

• & ：按位与
• | ：按位或
• ^ ：按位异或
• ~ ：按位取反
• << ：左移
• >> ：右移
• >>> ：无符号右移

int a = 5;   // 二进制 0101
int b = 3;   // 二进制 0011
System.out.println(a & b);  // 结果 1（二进制 0001）
System.out.println(a | b);  // 结果 7（二进制 0111）
System.out.println(a ^ b);  // 结果 6（二进制 0110）
System.out.println(~a);     // 结果 -6

位运算常用于性能敏感的场景，比如加密算法、位掩码操作等。

整数的优化技巧

• 使用合适的类型：对于小范围的整数运算，尽量使用 byte 或 short 以节省内存。
• 溢出检测：在关键的整数运算场景下，使用 Math.addExact() 等方法来检测溢出。
• 位运算替代普通运算：在某些高性能场景中，位运算可以比普通算术运算更高效。例如，左移 << 相当于乘以 2，右移 >> 相当于除以 2。

类型自动提升（Type Promotion）

类型自动提升是指在表达式中，当参与运算的不同数据类型不一致时，Java 自动将较小的类型提升为较大的类型，以避免数据丢失。通常，这种提升遵循从低精度到高精度的顺序：

byte → short → int → long → float → double

int a = 10;
long b = 20L;
long result = a + b;  // a 自动提升为 long 类型
System.out.println(result);  // 输出 30

在上面的示例中，int 类型的变量 a 在与 long 类型的 b 进行加法运算时，a 会自动提升为 long 类型。Java 将较小的类型（int）提升为较大的类型（long），以确保运算结果的准确性。

强制类型转换（Type Casting）

强制类型转换是将一个数据类型的值显式转换为另一个类型的过程。这通常用于将高精度的类型转换为低精度类型（比如将 double 转换为 int），或者在需要进行特定的类型转换时使用。强制转换可能会导致数据丢失，因此需要格外小心。

long largeValue = 100L;
int smallerValue = (int) largeValue;  // 强制转换为 int
System.out.println(smallerValue);     // 输出 100

在上述示例中，long 类型的 largeValue 被强制转换为 int，因为 long 的范围大于 int，因此这种转换必须显式进行。强制转换需要用括号显式指定目标类型，以表明开发者已经意识到可能的风险。

本期小知识

位移运算是一种高效的数学运算，在 Java 中可以用来替代乘除法。比如，左移运算符 << 相当于乘以 2，右移运算符 >> 相当于除以 2。

int a = 4;
System.out.println(a << 1);  // 输出: 8，相当于 4 * 2
System.out.println(a >> 1);  // 输出: 2，相当于 4 / 2