Question

我有一个对象数组，假设每个对象都是Grid类型。

每个网格对象都有x和y坐标，

Grid temp = new Grid(3, 5);
// temp.x returns x, temp.y returns y.

现在我有一些Grid

阵列

Grid[] theArray1 = new Grid[5];
Grid[] theArray2 = new Grid[5];
Grid[] theArray3 = new Grid[5];

我用Grid对象填充数组并使用Arrays.sort对它们进行排序。

我现在加入已排序的数组以形成长度为5 + 5 + 5 = 15的阵列。

我现在想要通过“子阵列”的第一个元素（在阵列中的元素0,5和10）对theArray进行排序

我怎么能这样做？此外，如果有一种更简单的方法来实现相同的结果，那将是很好的。但是我必须从3个数组开始，因为它们是通过for循环的迭代得到的。

修改

示例：假设我按X协调排序，先缩小。为简单起见，我将使每个Grid []的长度为3而不是5。

Grid[] theArray1 = new Grid[]{new Grid(2, 1), new Grid(4, 1), new Grid(0, 1)};
Grid[] theArray2 = new Grid[]{new Grid(4, 2), new Grid(3, 1), new Grid(7, 1)};
Grid[] theArray3 = new Grid[]{new Grid(1, 7), new Grid(5, 3), new Grid(10, 1)};

我最终想要的是一个阵列/ arraylist，打印时，打印出这样的：

for (int i = 0; i <= theArray.length-2; i++) {
    StdOut.println(theArray[i] + ", " + theArray[i+1] + ", " + theArray[i+2] + "\n");
}

// Output:

(0, 1), (2, 1), (4, 1) //this is theArray1
(1, 7), (5, 3), (10, 1) //this is theArray3
(3, 1), (4, 2), (7, 1) //this is theArray2

首先我对每个阵列（1,2和3）进行排序，使得x坐标最低的元素是第一个，然后是第二个最小的元素，然后是最大的。

然后我按照每个数组的第一个元素的大小排列这些数组。 theArray3在theArray2之前，因为第一个元素的x坐标是1但在theArray2中是3

Answer 1

您可以创建一个2d数组而不是3个单独的数组。然后你可以先对2d数组进行排序，使它们相互依次排列，然后加入它们。

    Grid[][] twoD;

    /* ... */

    // sort each array separately
    for(int i=0; i<twoD.length; i++){
        Arrays.sort(twoD[i], /* COMPARATOR */);
    }

    // sort the arrays based on x coordinate of first element
    Arrays.sort(twoD, new Comparator<Grid[]>() {
        public int compare(Grid[] a, Grid[] b) {
            return Integer.compare(a[0].x, b[0].x);
        }
    });

    /* NOW JOIN THEM */

如果确实只有3个阵列，你可以真正检查哪个是最小的，先添加，等等。

Answer 2

假设Grid实现Comparable<Grid>，对每个数组进行排序并添加到2d-array。然后使用Arrays.sort(Grid[][], GridArrayComparator)对网格数组进行排序，其中GridArrayComparator的示例如下：

class GridArrayComparator implements Comparator<Grid[]> {
   public int compare(Grid[] grids1, Grid[] grids2) {
       if (grids1.length > 0 && grids1.length > 0) {
           return grids1[0].compareTo(grids2[0]);
       } else if (grids1.length > 0) {
           return 1;
       } else if (grids2.length > 0) {
           return -1;
       } else {
           return 0;
       }
   }
}

然后将二维数组复制到一维数组。

Answer 3

这可能有点重量级，但有效。假设你的数组已合并，必须进行排序（theArray），你可以在你的数组上创建一个特殊的列表视图：

private static class BlockBasedListView<T> extends AbstractList<T[]> {

    private int blockSize;
    private T[] array;

    public BlockBasedListView(T[] array, int blockSize) {
        this.array = array;
        this.blockSize = blockSize;
    }

    @Override
    public T[] get(int index) {
        return Arrays.copyOfRange(array, index * blockSize, index * blockSize + blockSize);
    }

    @Override
    public T[] set(int index, T[] element) {
        T[] previousElement = get(index);
        System.arraycopy(element, 0, array, index * blockSize, blockSize);
        return previousElement;
    }

    @Override
    public int size() {
        return array.length / blockSize;
    }

}

这是一个简单的列表实现，其中一个元素是原始数组的元素块（大小为blockSize）。请注意，这是数组的视图：写入此列表会影响原始数组。

然后，您创建一个Grid块的比较器：

private static class CompareByFirstElement implements Comparator<Grid[]> {

    @Override
    public int compare(Grid[] o1, Grid[] o2) {
        return o1[0].x - o2[0].x;
    }
}

最后，您可以按如下方式对theArray进行排序：

BlockBasedListView<Grid> blockBasedList = new BlockBasedListView<Grid>(theArray, 5);
Collections.sort(blockBasedList, new CompareByFirstElement());

Answer 4

当您加入已排序的数组时，您将创建一个大小为15的新数组。新数组具有添加到其中的值，但与子数组无关。因此，如果您应用sort，它将在整个数组上。如果需要排序，则必须使用另一个大小为5的数组变量，对其进行排序，然后写回主数组。

Answer 5

你可以使用Comparable，也许这有帮助..

import java.util.Arrays;

public class Grid implements Comparable<Grid> {

    public static void main(String[] args) {
        Grid a = new Grid( 2, 15 ); // 3
        Grid b = new Grid( 1, 1 ); // 2
        Grid c = new Grid( 0, -13 ); // 1
        Grid d = new Grid( 4, 0 ); // 4

        Grid gridArray[] = new Grid[] { a, b, c, d };
        System.out.println( "Printing non sorted:" );
        for ( Grid grid : gridArray ) {
            System.out.println( grid.getX() + ", " + grid.getY() );
        }
        System.out.println( "Sorting..." );
        Arrays.sort( gridArray );

        System.out.println( "Printing sorted:" );
        for ( Grid grid : gridArray ) {
            System.out.println( grid.getX() + ", " + grid.getY() );
        }
    }

    private int x, y;

    public Grid(int x, int y) {
        this.setX( x );
        this.setY( y );
    }

    @Override
    public int compareTo(Grid grid) {
        // ascending order
        return this.getX() - grid.getX();
        // descending order
        // return grid.getX()-this.getX();
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

}

现在Arrays.sort将使用自然排序（Comparable），请参阅： http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html#sort（java.lang.Object中[]）

这是执行给定主方法后的输出：

Printing non sorted:
2, 15
1, 1
0, -13
4, 0
Sorting...
Printing sorted:
0, -13
1, 1
2, 15
4, 0

根据第一个元素对子数组进行排序

5 个答案: