Java实现升序元素集合时遭遇‘数组越界’错误求助

Hey there! Let's work through your sorted collection implementation, fix that annoying OutOfBounds error, and build out the rank hierarchy you need.

First, Why the "Out of Bounds" Error Happens #

Most often, this error pops up for two simple reasons:

• You try to access/remove an element from an empty collection (like calling extractMin() when there's nothing in the set)
• You use an invalid index (e.g., trying to access index -1 or an index larger than the collection's size minus 1)

Let's build the solution step by step, starting with the Comparable hierarchy for ranks.

Step 1: Implement the Rank Hierarchy with Comparable #

First, let's create a Rank class (using an enum here for simplicity, since ranks are fixed and ordered) that implements Comparable<Rank> to define clear hierarchy rules:

public enum Rank implements Comparable<Rank> {
    PRIVATE(1),
    CORPORAL(2),
    SERGEANT(3),
    LIEUTENANT(4),
    CAPTAIN(5),
    MAJOR(6),
    COLONEL(7),
    GENERAL(8);

    private final int priority;

    Rank(int priority) {
        this.priority = priority;
    }

    @Override
    public int compareTo(Rank other) {
        // Lower priority number = lower rank (ascending order)
        return Integer.compare(this.priority, other.priority);
    }
}

If you need a regular class instead of an enum (e.g., dynamic rank attributes), you can replicate this logic with a standard class and Comparable implementation.

Step 2: Build the Sorted Collection with Safe Methods #

Now let's create our custom sorted collection class. We'll use an ArrayList to store elements, keep it sorted on every addition, and add critical checks to avoid OutOfBounds errors:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.NoSuchElementException;

public class SortedCollection<T extends Comparable<T>> {
    private final List<T> elements;

    public SortedCollection() {
        elements = new ArrayList<>();
    }

    // Add element while maintaining ascending order
    public void add(T element) {
        if (element == null) {
            throw new IllegalArgumentException("Element cannot be null");
        }
        // Efficient insert: find correct position with binary search instead of full sort
        int insertionIndex = Collections.binarySearch(elements, element);
        if (insertionIndex < 0) {
            insertionIndex = -insertionIndex - 1;
        }
        elements.add(insertionIndex, element);
    }

    // Print all elements in ascending order
    public void printElements() {
        System.out.println("Sorted collection: " + elements);
    }

    // Extract and remove the smallest element (safe from OutOfBounds)
    public T extractMin() {
        // Critical check: don't access elements if the collection is empty
        if (elements.isEmpty()) {
            throw new NoSuchElementException("Cannot extract min from an empty collection");
            // Alternatively, return null if you prefer a non-exception approach:
            // return null;
        }
        // Since list is sorted ascending, first element is the smallest
        return elements.remove(0);
    }

    // Helper to check if collection is empty
    public boolean isEmpty() {
        return elements.isEmpty();
    }
}

Key Fixes for the "Out of Bounds" Error: #

• Empty collection check: In extractMin(), we first verify if the collection is empty before trying to remove index 0. This eliminates the IndexOutOfBoundsException that happens when you call remove(0) on an empty list.
• Safe insertion logic: Using Collections.binarySearch to find the correct insertion index avoids messy index errors that can come from manual sorting.
• Null validation: We added a check for null elements in add() to prevent unexpected behavior later.

Step 3: Test the Implementation #

Let's test our code with the Rank hierarchy to make sure it works and avoids errors:

public class Main {
    public static void main(String[] args) {
        SortedCollection<Rank> rankCollection = new SortedCollection<>();

        // Add ranks in random order
        rankCollection.add(Rank.CAPTAIN);
        rankCollection.add(Rank.PRIVATE);
        rankCollection.add(Rank.SERGEANT);
        rankCollection.add(Rank.LIEUTENANT);

        // Print sorted elements
        rankCollection.printElements(); // Output: Sorted collection: [PRIVATE, SERGEANT, LIEUTENANT, CAPTAIN]

        // Extract min elements one by one
        while (!rankCollection.isEmpty()) {
            Rank minRank = rankCollection.extractMin();
            System.out.println("Extracted min rank: " + minRank);
        }

        // Uncomment below to test safe error handling for empty collection
        // rankCollection.extractMin(); // Throws NoSuchElementException (instead of OutOfBounds)
    }
}

Alternative: Use Java's Built-in TreeSet #

If you don't need to manually implement sorting logic, Java's TreeSet is a built-in sorted collection that uses Comparable<T> automatically. It has safe methods to avoid OutOfBounds errors:

import java.util.TreeSet;

public class RankSetExample {
    public static void main(String[] args) {
        TreeSet<Rank> rankSet = new TreeSet<>();
        rankSet.add(Rank.CAPTAIN);
        rankSet.add(Rank.PRIVATE);
        rankSet.add(Rank.SERGEANT);

        System.out.println("Sorted ranks: " + rankSet);
        System.out.println("Extracted min rank: " + rankSet.pollFirst()); // Returns null if empty (safe!)
        System.out.println("Remaining ranks: " + rankSet);
    }
}

Final Notes #

The core fix for your OutOfBounds error is always validating the collection's state before accessing elements. Whether you build your own collection or use a built-in one like TreeSet, checking if the collection is empty first will prevent this frustrating error.

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