java Integer.compare比较两个 `int` 值的静态方法

Integer.compare() 是 Java 中用于比较两个 int 值的静态方法，它提供了类型安全、简洁且高效的整数比较方式，特别适用于排序和比较器（Comparator）场景。

---

方法定义

public static int compare(int x, int y)

• 所属类: java.lang.Integer
• 参数:
  • x - 要比较的第一个 int 值
  • y - 要比较的第二个 int 值
• 返回类型: int
• 访问修饰符: public static
• 自 JDK 版本: 1.5

---

功能说明

Integer.compare(x, y) 比较两个 int 值并返回一个三值比较结果（signum 函数）：

• 返回 1：如果 x > y
• 返回 0：如果 x == y
• 返回 -1：如果 x < y

这个返回值模式广泛用于排序算法和 Comparator 接口，能直接用于升序或降序排列。

✅ 核心优势：避免了手动相减可能引起的整数溢出问题。

---

示例代码

1. 基本比较

System.out.println(Integer.compare(5, 3));   // 输出: 1  (5 > 3)
System.out.println(Integer.compare(2, 7));   // 输出: -1 (2 < 7)
System.out.println(Integer.compare(4, 4));   // 输出: 0  (4 == 4)

2. 用于 Comparator 排序

List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);

// 升序排序
numbers.sort(Integer::compare);
System.out.println(numbers); // [1, 2, 5, 8, 9]

// 降序排序
numbers.sort((a, b) -> Integer.compare(b, a));
System.out.println(numbers); // [9, 8, 5, 2, 1]

3. 比较 Integer 对象（避免自动拆箱陷阱）

Integer a = 1000;
Integer b = 2000;

// 推荐：使用 compare 比较值
int result = Integer.compare(a, b); // 安全，返回 -1

// 避免：a - b 可能溢出（虽然此处不会，但模式危险）
// int diff = a - b; // 不推荐用于比较逻辑

4. 在自定义对象中使用

public class Person {
    private String name;
    private int age;

    // 构造函数、getter 省略...

    public static Comparator<Person> byAge() {
        return (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());
    }
}

// 使用
List<Person> people = ...;
people.sort(Person.byAge());

---

使用技巧

1. 替代 a - b 比较模式

// ❌ 危险：可能溢出
// return x - y;

// ✅ 安全：使用 compare
return Integer.compare(x, y);

2. 与 Comparator 链式组合

Comparator<Person> byAgeThenName = 
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName);

// 内部使用了 Integer.compare

3. 处理负数和边界值

System.out.println(Integer.compare(Integer.MAX_VALUE, Integer.MIN_VALUE)); // 1
System.out.println(Integer.compare(-1, 1)); // -1
System.out.println(Integer.compare(0, -5)); // 1

---

常见错误

❌ 1. 误用于 null 的 Integer 对象

Integer a = null;
Integer b = 5;
// int result = Integer.compare(a, b); // 编译错误！

原因：compare(int, int) 参数是基本类型，null 无法自动拆箱。

✅ 正确方式（处理 null）：

Comparator<Integer> nullSafe = Comparator.nullsFirst(Integer::compare);
int result = nullSafe.compare(null, 5); // 返回 -1

❌ 2. 与 compareTo() 混淆

Integer a = 5;
// a.compareTo(3) 是实例方法，功能相同
// Integer.compare(5, 3) 是静态方法，更灵活

---

注意事项

1. ✅ 参数是 int 基本类型：传入 Integer 对象会自动拆箱，但 null 会导致 NullPointerException。

2. ⚠️ 不能处理 null：静态 compare() 方法本身不支持 null 值比较，需结合 Comparator.nullsFirst() 或 nullsLast()。

3. 🔒 线程安全：该方法是纯函数，无副作用，线程安全。

4. 🚀 性能优秀：内部实现简单高效，无对象创建，适合高频调用。

5. 🔄 对称性：Integer.compare(x, y) == -Integer.compare(y, x)（当 x ≠ y 时）

---

最佳实践与性能优化

1. ✅ 优先使用 Integer.compare() 而非 a - b

// 推荐
return Integer.compare(score1, score2);

// 不推荐（潜在溢出）
// return score1 - score2;

2. ✅ 在 Comparator 中使用方法引用

list.sort(Integer::compare); // 清晰、简洁

3. ✅ 结合 Comparator 工具类处理 null

Comparator<Integer> comp = Comparator
    .nullsFirst(Integer::compare); // null 值排在前面

4. ✅ 用于三元条件判断

int result = Integer.compare(a, b);
if (result > 0) {
    System.out.println("a > b");
} else if (result < 0) {
    System.out.println("a < b");
} else {
    System.out.println("a == b");
}

5. ✅ 在自定义比较器中复用

public static Comparator<MyClass> byField() {
    return (o1, o2) -> Integer.compare(o1.getValue(), o2.getValue());
}

---

与其他比较方式对比

比较方式	是否安全	是否推荐	说明
Integer.compare(a, b)	✅ 安全	✅ 推荐	无溢出，语义清晰
a - b	❌ 可能溢出	❌ 不推荐	Integer.MAX_VALUE - (-1) 溢出为负数
a > b ? 1 : (a < b ? -1 : 0)	✅ 安全	⚠️ 可用	冗长，可读性差
Integer.valueOf(a).compareTo(b)	✅ 安全	⚠️ 可用	创建对象，性能略差

---

总结

Integer.compare(int x, int y) 是 Java 中进行整数比较的最佳实践方法，具有以下核心优势：

• ✅ 安全：避免整数相减溢出问题
• ✅ 简洁：一行代码完成三值比较
• ✅ 高效：无对象创建，性能优秀
• ✅ 标准：广泛用于 JDK 排序和比较器
• ✅ 语义清晰：返回值明确表示大小关系