Hey there! It looks like your insertion sort for sorting Movie2 objects by title (with ascending/descending support) isn’t working as expected. Since you only shared the main method code, I can’t spot the exact bug in your sortTitles method directly—but let’s walk through common pitfalls and share a working example to help you debug your code.

Common Reasons Your Sort Might Fail #

• Incorrect Title Comparison: If you’re using equals() instead of compareTo()/compareToIgnoreCase(), you won’t get proper ordering. Also, forgetting to handle case sensitivity (e.g., "Shrek" vs "shrek") can lead to unexpected results.
• Reversed Sort Logic: Mixing up the conditions for ascending vs descending order (e.g., using > when you should use < for ascending) will flip your sort results or break it entirely.
• Mishandling Object Movement: If you’re only manipulating title strings instead of shifting the entire Movie2 objects in the array, your sort won’t actually reorder the movie entries.
• Boundary Condition Errors: Starting the loop at the wrong index (e.g., 0 instead of 1) or not stopping the while loop correctly can cause index out-of-bounds errors or incomplete sorting.

Working Example Implementation #

Here’s a complete, tested version of the code you’re trying to build—including a simplified Movie2 class, the sortTitles method with proper ascending/descending logic, and the printMovies helper:

// Simplified Movie2 class (adjust to match your actual implementation)
class Movie2 {
    private String title;
    private int year;
    private String studio;

    public Movie2(String title, int year, String studio) {
        this.title = title;
        this.year = year;
        this.studio = studio;
    }

    // Getter for title (critical for sorting)
    public String getTitle() {
        return title;
    }

    @Override
    public String toString() {
        return String.format("%s (%d) - %s", title, year, studio);
    }
}

public class MovieTitleSorter {
    public static void main(String[] args) {
        Movie2[] myMovies = {
            new Movie2("The Muppets Take Manhattan", 2001, "Columbia Tristar"),
            new Movie2("Mulan Special Edition", 2004, "Disney"),
            new Movie2("Shrek 2", 2004, "Dreamworks"),
            new Movie2("Finding Nemo", 2003, "Pixar"),
            new Movie2("Monsters, Inc.", 2001, "Pixar")
        };

        System.out.println("Original Movie List:");
        printMovies(myMovies);

        // Test ascending sort
        sortTitles(myMovies, true);
        System.out.println("\nSorted Ascending by Title:");
        printMovies(myMovies);

        // Test descending sort
        sortTitles(myMovies, false);
        System.out.println("\nSorted Descending by Title:");
        printMovies(myMovies);
    }

    public static void sortTitles(Movie2[] movies, boolean ascending) {
        // Edge case: no need to sort empty or single-element arrays
        if (movies == null || movies.length <= 1) {
            return;
        }

        for (int i = 1; i < movies.length; i++) {
            Movie2 currentMovie = movies[i];
            String currentTitle = currentMovie.getTitle();
            int j = i - 1;

            // Adjust comparison logic based on sort order
            while (j >= 0) {
                String sortedTitle = movies[j].getTitle();
                boolean shouldShift = ascending 
                    ? currentTitle.compareToIgnoreCase(sortedTitle) < 0 
                    : currentTitle.compareToIgnoreCase(sortedTitle) > 0;

                if (!shouldShift) {
                    break; // Current movie is in the right position
                }

                // Shift the sorted movie to the right to make space
                movies[j + 1] = movies[j];
                j--;
            }

            // Place the current movie in its correct sorted position
            movies[j + 1] = currentMovie;
        }
    }

    public static void printMovies(Movie2[] movies) {
        for (Movie2 movie : movies) {
            System.out.println(movie);
        }
    }
}

Key Details in This Implementation #

• Case-Insensitive Comparison: Uses compareToIgnoreCase() so "Mulan" and "mulan" sort correctly. If you need case-sensitive sorting, replace it with compareTo().
• Dynamic Sort Order: The ascending parameter flips the comparison condition to handle both sort directions.
• Proper Object Shifting: Moves entire Movie2 objects in the array, not just title strings, ensuring the full movie data stays aligned.
• Edge Case Handling: Skips sorting for empty or single-element arrays to avoid unnecessary work.

Next Steps to Fix Your Code #

1. Compare your sortTitles method against the example above—check for mismatches in comparison logic or object movement.
2. If you’re still stuck, share your full sortTitles method code, and I can help you pinpoint the exact bug!

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