在 Java 中，将一个对象（Object）转换为基本数据类型 int 是一个常见操作，但需要注意一些关键点，特别是处理 null 值和类型不匹配的情况。

核心思路是：

1. 检查 null：如果传入的对象是 null，直接转换会抛出 NullPointerException，必须先处理这种情况。
2. 类型检查与转换：对象必须是 Number 类的子类（如 Integer, Long, Double, Float, BigDecimal 等），或者是一个可以解析为数字的 String。
3. 调用相应方法：对于 Number 对象，调用其 intValue() 方法，对于 String 对象，使用 Integer.parseInt() 或 Integer.valueOf() 进行解析。
4. 异常处理：如果类型不匹配（尝试将一个 List 转为 int）或字符串格式不正确（"abc"），会抛出异常，需要妥善处理。

下面我将介绍几种最常见和推荐的方法。

使用 instanceof 进行类型检查（最安全、最推荐）

这是最健壮的方法,因为它可以处理 null、类型检查和转换，并且可以自定义异常处理逻辑。

转换为 int 原始类型

如果对象是 Integer，可以直接强制转换，如果是其他 Number 类型（如 Long, Double），intValue() 方法会进行截断取整。

public static int convertToInt(Object obj) {
    // 1. 处理 null 值
    if (obj == null) {
        // 根据业务需求决定如何处理，例如返回默认值 0 或抛出异常
        // return 0; 
        throw new IllegalArgumentException("Input object cannot be null");
    }
    // 2. 处理 Integer 类型（可以直接强转）
    if (obj instanceof Integer) {
        return (Integer) obj;
    }
    // 3. 处理其他 Number 类型（如 Long, Double, Float 等）
    if (obj instanceof Number) {
        return ((Number) obj).intValue(); // intValue() 会进行截断取整
    }
    // 4. 处理可以解析为数字的 String 类型
    if (obj instanceof String) {
        try {
            return Integer.parseInt((String) obj);
        } catch (NumberFormatException e) {
            // 如果字符串格式不正确，抛出异常或返回默认值
            throw new IllegalArgumentException("Cannot convert String '" + obj + "' to int", e);
        }
    }
    // 5. 如果类型不匹配，抛出异常
    throw new IllegalArgumentException("Object of type " + obj.getClass().getName() + " cannot be converted to int");
}
// --- 使用示例 ---
public static void main(String[] args) {
    System.out.println(convertToInt(123));              // 输出: 123 (Integer)
    System.out.println(convertToInt(123L));             // 输出: 123 (Long)
    System.out.println(convertToInt(123.45));           // 输出: 123 (Double, 截断)
    System.out.println(convertToInt("456"));             // 输出: 456 (String)
    System.out.println(convertToInt(new BigDecimal("789.0"))); // 输出: 789 (BigDecimal)
    // System.out.println(convertToInt(null));          // 抛出 IllegalArgumentException
    // System.out.println(convertToInt("abc"));          // 抛出 IllegalArgumentException
    // System.out.println(convertToInt(new Object()));   // 抛出 IllegalArgumentException
}

转换为 Integer 对象

如果你需要一个 Integer 对象而不是 int 原始类型，逻辑类似。

public static Integer convertToInteger(Object obj) {
    if (obj == null) {
        return null; // 或者 return 0; 根据业务需求
    }
    if (obj instanceof Integer) {
        return (Integer) obj;
    }
    if (obj instanceof Number) {
        return ((Number) obj).intValue();
    }
    if (obj instanceof String) {
        try {
            return Integer.valueOf((String) obj);
        } catch (NumberFormatException e) {
            return null; // 或者抛出异常
        }
    }
    return null; // 或者抛出异常
}

使用 Apache Commons Lang 或 Spring Utils（简化代码）

在大型项目中,通常会引入成熟的工具库来简化这类操作，避免重复编写样板代码。

使用 Apache Commons Lang NumberUtils

需要添加依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- 使用最新版本 -->
</dependency>

import org.apache.commons.lang3.math.NumberUtils;
public class CommonsLangExample {
    public static void main(String[] args) {
        // NumberUtils.toInt() 方法已经内置了 null 检查
        // obj 为 null 或转换失败，则返回指定的默认值 0
        int int1 = NumberUtils.toInt(null, 0); // 返回 0
        int int2 = NumberUtils.toInt("123", 0); // 返回 123
        int int3 = NumberUtils.toInt("123.45", 0); // 返回 123 (自动截断)
        int int4 = NumberUtils.toInt("abc", 0); // 返回 0 (转换失败，返回默认值)
        int int5 = NumberUtils.toInt(100L, 0); // 返回 100
        System.out.println(int1); // 0
        System.out.println(int2); // 123
        System.out.println(int3); // 123
        System.out.println(int4); // 0
        System.out.println(int5); // 100
    }
}

优点：代码极其简洁，null 安全，并提供默认值。

使用 Spring Framework NumberUtils

如果你已经在使用 Spring Framework，可以直接使用其工具类。

import org.springframework.util.NumberUtils;
public class SpringUtilsExample {
    public static void main(String[] args) {
        // Spring 的 NumberUtils 要求提供默认值
        Integer int1 = NumberUtils.convertNumberToNumberIfNecessary(null, Integer.class);
        Integer int2 = NumberUtils.convertNumberToNumberIfNecessary("123", Integer.class);
        Integer int3 = NumberUtils.convertNumberToNumberIfNecessary(123L, Integer.class);
        System.out.println(int1); // null
        System.out.println(int2); // 123
        System.out.println(int3); // 123
    }
}

注意：Spring 的这个方法返回的是 Number 的子类（这里是 Integer），并且如果转换失败或输入 null，它会返回 null 而不是抛出异常。

使用 Java 8 的 Optional（函数式风格）

这种方法更现代,可以优雅地处理 null 值，但代码相对冗长，适用于喜欢函数式编程风格的场景。

import java.util.Optional;
public class OptionalExample {
    public static Optional<Integer> convertToIntSafely(Object obj) {
        return Optional.ofNullable(obj)
                .filter(o -> o instanceof Number || o instanceof String)
                .map(o -> {
                    if (o instanceof Number) {
                        return ((Number) o).intValue();
                    } else { // o is String
                        try {
                            return Integer.parseInt((String) o);
                        } catch (NumberFormatException e) {
                            return null; // 解析失败，返回 null，导致 Optional 变为 empty
                        }
                    }
                });
    }
    public static void main(String[] args) {
        // 使用方式
        convertToIntSafely("123").ifPresent(val -> System.out.println("Success: " + val)); // Success: 123
        convertToIntSafely(null).ifPresent(val -> System.out.println("This won't be printed")); // 不会执行
        convertToIntSafely("abc").ifPresent(val -> System.out.println("This won't be printed")); // 不会执行
        // 可以获取默认值
        int result = convertToIntSafely(null").orElse(0);
        System.out.println("Result or default: " + result); // Result or default: 0
    }
}

优点：将 null 和转换失败的情况都封装进了 Optional，强制调用者处理可能为空的结果，使代码更安全。 缺点：对于简单的转换，代码量比 instanceof 检查要多。

总结与最佳实践

核心建议：

1. 首选 NumberUtils.toInt() (Apache Commons Lang)：如果项目允许引入依赖，这是最简单、最安全、最符合 Java 惯例的选择。
2. 次选 instanceof 手动转换：如果项目不能引入依赖，或者转换逻辑非常特殊（只接受 Integer 而不接受 Long），这是最可靠的基础方法。
3. 永远不要直接 (Integer) obj：这样会直接抛出 ClassCastException，obj 不是 Integer，并且无法处理 null。
4. 考虑业务需求：当遇到 null 或转换失败时，是应该返回一个默认值（如 0），还是应该抛出异常让上层处理？这取决于你的业务逻辑。