能否结合Collections.sort()在compareTo()中比较Integer？编译报错求助

Hey there! Let's break this down and fix that compile error for you.

First off, your approach of trying to override compareTo() on the Integer class won't work—and that's exactly why you're hitting a compile failure. The Integer class in Java is marked final, which means you can't extend it or override any of its built-in methods (including compareTo()). The compiler is throwing an error because it sees you trying to do something explicitly forbidden by Java's language design.

So how do you get that descending numeric sort you want? Here are a couple of straightforward, valid ways to make it happen:

1. Sort a List<Integer> directly with a custom Comparator #

You don't need to mess with Integer's native behavior at all. Just pass a reverse-order comparator to Collections.sort():

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;

public class DescendingSortExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2);
        
        // Option 1: Use a lambda to reverse natural comparison
        Collections.sort(numbers, (a, b) -> b.compareTo(a));
        
        // Option 2: Use Java's built-in reverse comparator (cleaner!)
        Collections.sort(numbers, Comparator.reverseOrder());
        
        System.out.println(numbers); // Output: [9, 5, 4, 3, 2, 1, 1]
    }
}

2. If you're working with a custom class containing an Integer field #

Suppose you have your own class and want to sort instances based on an Integer property in descending order. In this case, implement Comparable on your custom class and reverse the comparison logic inside compareTo():

public class Product implements Comparable<Product> {
    private String name;
    private Integer price;

    // Constructor, getters, setters omitted

    @Override
    public int compareTo(Product other) {
        // Reverse the comparison to sort by price in descending order
        return other.getPrice().compareTo(this.getPrice());
        // Alternate approach: return this.getPrice().compareTo(other.getPrice()) * -1;
    }
}

Then sorting your list is as simple as:

List<Product> products = new ArrayList<>();
// Add products to the list...
Collections.sort(products); // Will sort by price descending

The key takeaway here is that Integer's behavior is fixed (thanks to being final), but you don't need to modify it to get the sort order you want—Java's Comparator system gives you all the flexibility you need.

内容的提问来源于stack exchange，提问作者user9249390