Java 中 `Integer.valueOf()` 和 `Integer.parseInt()` 的区别及实践

在 Java 中，处理字符串与整数的转换时，Integer.valueOf() 和 Integer.parseInt() 是最常用的两个方法。

这两个方法虽然看似相似，但在实际使用中却有一些关键的区别。本文将详细讲解这两个方法的用法、内部实现及其不同之处，并结合实际示例来帮助大家更好地理解和使用。

方法定义和基本用法

1. `Integer.valueOf()`

方法定义：

1 2	public static Integer valueOf(String s) throws NumberFormatException; public static Integer valueOf(int i);

用法：

Integer.valueOf(String s)：将字符串 s 转换为 Integer 对象。
Integer.valueOf(int i)：将基本数据类型 int 转换为 Integer 对象。

示例：

1 2	Integer num1 = Integer.valueOf("123"); // 返回 Integer 对象 Integer num2 = Integer.valueOf(456); // 返回 Integer 对象

注意：valueOf(String s) 方法返回的是一个 Integer 对象，而不是基本数据类型 int。如果传入的字符串无法转换为整数，会抛出 NumberFormatException 异常。

2. `Integer.parseInt()`

方法定义：

1 2	public static int parseInt(String s) throws NumberFormatException; public static int parseInt(String s, int radix) throws NumberFormatException;

用法：

Integer.parseInt(String s)：将字符串 s 转换为基本数据类型 int。
Integer.parseInt(String s, int radix)：将字符串 s 按照指定的 radix（进制）转换为 int。

示例：

1 2	int num1 = Integer.parseInt("123"); // 返回 int 值 int num2 = Integer.parseInt("1A", 16); // 按 16 进制转换，返回 26

注意：parseInt() 方法直接返回基本数据类型 int，不会自动装箱为 Integer 对象。如果字符串无法转换为整数，同样会抛出 NumberFormatException 异常。

`Integer.valueOf()` 与 `Integer.parseInt()` 的区别

功能	`Integer.valueOf()`	`Integer.parseInt()`
返回类型	`Integer`（对象）	`int`（基本数据类型）
是否使用缓存	是	否
支持的进制	默认 10 进制	支持 2 ~ 36 进制
自动装箱	是	否
主要用途	获取 `Integer` 对象	获取基本 `int` 类型

1. 返回类型的区别

Integer.valueOf() 返回的是 Integer 对象。
Integer.parseInt() 返回的是基本数据类型 int。

2. 缓存机制

Integer.valueOf(int i) 方法使用了 Integer 缓存机制，对于 -128 到 127 之间的整数，会返回缓存的 Integer 对象，避免重复创建对象，提高效率。
Integer.parseInt() 直接返回基本类型 int，不涉及缓存。

示例：

Integer a = Integer.valueOf(127);
Integer b = Integer.valueOf(127);
System.out.println(a == b); // 输出 true

Integer c = Integer.valueOf(128);
Integer d = Integer.valueOf(128);
System.out.println(c == d); // 输出 false

内部实现解析

1. `Integer.valueOf()` 源码分析

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

缓存机制：IntegerCache 缓存了 -128 到 127 之间的整数对象，超出此范围则新建 Integer 对象。
优点：减少对象创建，提升性能。

2. `Integer.parseInt()` 源码分析

public static int parseInt(String s, int radix) throws NumberFormatException {
    if (s == null) {
        throw new NumberFormatException("null");
    }
    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix out of range");
    }
    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') {
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+') {
                throw new NumberFormatException(s);
            }
            if (len == 1) {
                throw new NumberFormatException(s);
            }
            i++;
        }
        while (i < len) {
            int digit = Character.digit(s.charAt(i++), radix);
            if (digit < 0) {
                throw new NumberFormatException(s);
            }
            result *= radix;
            result -= digit;
        }
    } else {
        throw new NumberFormatException(s);
    }
    return negative ? result : -result;
}

支持多进制转换：可转换 2 ~ 36 进制的字符串。
处理符号：支持负数和正数的转换。

性能比较

由于 Integer.valueOf() 使用了缓存机制，对于频繁使用的整数转换，性能更优。但在只需要基本数据类型 int 时，parseInt() 更加直接，且没有装箱开销。因此，在以下场景中建议选择不同的方法：

需要频繁转换的整数（尤其是 -128 到 127 之间）：推荐使用 Integer.valueOf()。
需要高效处理基本数据类型：推荐使用 Integer.parseInt()。

实践示例

示例 1：判断两个整数是否相等

public class IntegerComparison {
    public static void main(String[] args) {
        Integer a = Integer.valueOf(100);
        Integer b = Integer.valueOf(100);
        System.out.println(a == b); // true，因为使用了缓存

        Integer c = Integer.valueOf(200);
        Integer d = Integer.valueOf(200);
        System.out.println(c == d); // false，因为超出缓存范围
    }
}

示例 2：多进制转换

public class RadixConversion {
    public static void main(String[] args) {
        System.out.println(Integer.parseInt("1010", 2));   // 输出 10
        System.out.println(Integer.parseInt("A", 16));     // 输出 10
        System.out.println(Integer.valueOf("A", 16));      // 输出 10
    }
}

示例 3：处理异常

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            Integer num = Integer.valueOf("abc");
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format: " + e.getMessage());
        }
    }
}

总结

Integer.valueOf() 返回 Integer 对象，具有缓存机制，适合频繁使用的整数转换。
Integer.parseInt() 返回基本数据类型 int，效率更高，适合处理需要高效转换的场景。
使用 Integer.valueOf() 适合需要对象的场景，而 parseInt() 则更适合处理基本类型的高效计算。

通过理解这两个方法的区别，开发者可以根据实际需求选择合适的方法，从而提升代码的性能和可读性。