核心概念：数据类型范围

理解 int 转 short 的关键在于了解它们的数据范围：

• int (整数): 32位，有符号，范围是 -2,147,483,648 到 2,147,483,647。
• short (短整型): 16位，有符号，范围是 -32,768 到 32,767。

short 的存储空间（16位）比 int（32位）小，当一个 int 值超出了 short 的表示范围时，直接转换就会导致数据溢出，得到一个不正确的结果。

转换方法

在 Java 中，主要有两种方式进行 int 到 short 的转换。

强制类型转换

这是最直接、最常用的方法，通过在变量前加上目标类型 (short) 来告诉编译器你明确知道要进行转换，并愿意承担可能的风险。

语法:

short shortValue = (short) intValue;

工作原理: Java 会执行截断操作，它会将 int 的 32 位二进制数的低 16 位保留下来，作为 short 的值，而高 16 位则被直接丢弃。

示例 1：在范围内的值（安全转换） int 的值在 short 的范围内，转换是安全的，数据不会丢失。

int intValue = 100;
short shortValue = (short) intValue;
System.out.println("原始 int 值: " + intValue);      // 输出: 100
System.out.println("转换后 short 值: " + shortValue); // 输出: 100
System.out.println("值是否相等: " + (intValue == shortValue)); // 输出: true

示例 2：超出范围的值（溢出） int 的值超出了 short 的范围，就会发生溢出，结果会是取低 16 位后重新解释的值。

// int 值超出了 short 的最大值 32767
int intValue1 = 32768; 
short shortValue1 = (short) intValue1;
// 32768 的二进制是 0000 0000 0000 0000 1000 0000 0000 0000
// 取低 16 位: 1000 0000 0000 0000
// 这个 16 位有符号数的十进制值是 -32768
System.out.println("原始 int 值: " + intValue1);       // 输出: 32768
System.out.println("转换后 short 值: " + shortValue1); // 输出: -32768  <-- 溢出！
// int 值超出了 short 的最小值 -32768
int intValue2 = -32769;
short shortValue2 = (short) intValue2;
// -32769 的二进制是 1111 1111 1111 1111 0111 1111 1111 1111
// 取低 16 位: 0111 1111 1111 1111
// 这个 16 位有符号数的十进制值是 32767
System.out.println("原始 int 值: " + intValue2);       // 输出: -32769
System.out.println("转换后 short 值: " + shortValue2); // 输出: 32767  <-- 溢出！

通过 Short 包装类

short 是一个基本数据类型，而 java.lang.Short 是它的包装类，你也可以利用包装类进行转换。

语法:

short shortValue = Short.valueOf(intValue);

工作原理: Short.valueOf(int i) 方法内部会自动进行强制类型转换 (short)i，所以它的行为和强制类型转换完全一样，同样会发生溢出。

示例:

int intValue = 32768;
// 底层实现等同于 (short) 32768
short shortValue = Short.valueOf(intValue); 
System.out.println("通过 Short.valueOf 转换: " + shortValue); // 输出: -32768 (同样会溢出)

在 int 转 short 的场景下，Short.valueOf() 只是强制类型转换的“语法糖”，没有本质区别。

注意事项和最佳实践

1. 必须处理溢出风险 强制类型转换会绕过编译器的类型检查，所以你必须自己确保 int 的值在 short 的范围内，如果你不确定，就必须进行校验。

2. 如何安全地转换（防止溢出） 在进行转换前，先用 if 语句判断值是否在范围内。

   public static int safeIntToShort(int intValue) {
       // 检查是否在 short 的范围内
       if (intValue >= Short.MIN_VALUE && intValue <= Short.MAX_VALUE) {
           return (short) intValue; // 安全转换
       } else {
           // 处理溢出情况，
           // 1. 抛出一个异常
           throw new ArithmeticException("int 值 " + intValue + " 超出 short 范围，无法转换！");
           // 2. 返回一个默认值或错误码
           // return -1; 
           // 3. 截断到最大/最小值
           // return intValue > 0 ? Short.MAX_VALUE : Short.MIN_VALUE;
       }
   }
   // 使用示例
   try {
       int myInt = 50000;
       short myShort = safeIntToShort(myInt);
       System.out.println("安全转换成功: " + myShort);
   } catch (ArithmeticException e) {
       System.err.println(e.getMessage());
   }

3. 为什么需要这种转换？ 虽然有溢出的风险，但在某些特定场景下，这种转换是必要的：

   • 硬件交互/底层协议: 当你需要与只接受 16 位数据的硬件设备通信，或者遵循一个只使用 16 位整数的网络协议时。
   • 节省内存: 如果你确定一个数值永远不会超过 32,767，并且在一个需要存储大量 int 的数组或集合中，使用 short 可以节省一半的内存空间。
   • API 调用: 某些 Java API 或第三方库的方法参数就是 short 类型，你必须提供 short 值。

记住这个核心原则：int 转 short 是有损操作，必须由开发者明确控制并承担风险。