用Java对2d对象数组进行排序（java.lang.Object）

Question

I have an ArrayList:

ArrayList<Object[][]> parents;

Where column 1 contains an ArrayList of Integers and column 2 contains a single int. I have cased parents as an ArrayList of Objects as the two objects inside it derive from Class Objects, rather than converting.

This is where I've gotten a problem, now I need to sort parents by column two, the ints, but have ran into the issue with using java.util.Arrays.sort as I get the following error:

The method sort(T[], Comparator<? super T>) in the type Arrays is not applicable for the arguments (ArrayList<Object[][]>, new Comparator<Integer[]>(){})

is there any way around this to cast that second column as an Integer? The error us coming from the ArrayList containing the more general Object

If this isn't possible, what is the best way to go about changing in the code so the array can be sorted?

Please don't mark as duplicate from the sorting of int[][] questions as I haven't seen this issue on here before.

Thank you!

EDIT - as requested this is an example of my ArrayList

[50, 50, 50, 100, 50, 80, 50], 925
[80, 100, 100, 50, 80, 100], 1300
[50, 100, 100, 50, 100, 100], 1200

Ignoring the first column, I'd like to sort it by the second, like so:

[50, 50, 50, 100, 50, 80, 50], 925
[50, 100, 100, 50, 100, 100], 1200
[80, 100, 100, 50, 80, 100], 1200

For context the first column is an array referencing items a player has in a game, and the second column is their cost (smaller is better). I'd like to sort the players by this cost column (2), and of course their items will move with them to the same sorted row. The results are sorted smallest first, so in a tournament selection (this is a genetic algorithm), I can 'kill' the players with the highest costs by trimming the ArrayList.

Answer 1

First of all, this is not really the right way to do this. As @JB Nizet mentioned in the comments, you should create a class with appropriate members and then create a List of that class. The elements of those lists then can be compared in a safe way.

But if you should do it this way, here is a solution:

parents.sort(new Comparator<Object[][]>() {
            @Override
            public int compare(Object[][] o1, Object[][] o2) {
                return Integer.compare((int) o1[0][1], (int)o2[0][1]);
            }
        });

The error message you have reported is actually directing you to create a comparator which is compatible with the object being passed to sort .

This is not safe at all. The objects need to exactly have the format you have indicated they would have, otherwise all hell will break loose. Of course, you can add checks to the overriden compare method to ensure format is correct. But why burden yourself with all that complexity when you can use simple OO design patterns and have a nice meaningful class to solve your problem?