Java 每日一刊(第6期):整数运算


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

前言

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

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

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

Java 的整数类型

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

类型大小最小值最大值
byte1 字节-128127
short2 字节-32,76832,767
int4 字节 − 2 31 -2^{31} 231 2 31 − 1 2^{31} - 1 2311
long8 字节 − 2 63 -2^{63} 263 2 63 − 1 2^{63} - 1 2631

这些类型主要区别在于存储的整数范围。最常用的整数类型是 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

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

整数的优化技巧

  • 使用合适的类型:对于小范围的整数运算,尽量使用 byteshort 以节省内存。
  • 溢出检测:在关键的整数运算场景下,使用 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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值