Question

我有n个相同length的数组（比如m）。数组表示相同m逻辑对象的不同属性，我想根据一个（或多个）属性对所有数组进行排序。在Java中，这是一个惯用的或者无论如何紧凑的方式吗？我想出了下面的内容，这非常详细。

要想知道我在寻找什么，在Python中你可以说zip(size, weight).sort，其他语言允许你获得关键数组的等级，然后你可以适用于所有阵列。

使用广泛的实用程序，如Apache Commons欢迎，但显然基于Java库的解决方案将是首选。

import java.util.*;

class Box {
  public int size;
  public int weight;

  Box( int size, int weight ){
    this.size = size;
    this.weight = weight;
  }
}

class SizeComparator implements Comparator<Box> {
  @Override
  public int compare(Box a, Box b) {
    return a.size < b.size ? -1 : a.size == b.size ? 0 : 1;
  }
}

public class SortArrays {
  public static void main(String[] args) {
    int[] size   = {5,3,6,2,4,4,2};
    int[] weight = {9,7,8,3,5,2,5};

    List<Box> boxes = new ArrayList<Box>();
    for( int i = 0; i < size.length; ++i ) {
      boxes.add( new Box( size[i], weight[i] ) );
    }

    Collections.sort( boxes, new SizeComparator() );
    int[] sortedSizes = getSizes( boxes );
    int[] sortedWeights = getWeights( boxes );

    System.out.println(Arrays.toString(sortedSizes));
    System.out.println(Arrays.toString(sortedWeights));
  }

  private static int[] getSizes( List<Box> boxes ) {
    int[] result = new int[boxes.size()];
    for( int i = 0; i < boxes.size(); ++i ) {
      result[i] = boxes.get(i).size;
    }
    return result;
  }

  private static int[] getWeights( List<Box> boxes ) {
    int[] result = new int[boxes.size()];
    for( int i = 0; i < boxes.size(); ++i ) {
      result[i] = boxes.get(i).weight;
    }
    return result;
  }
}

Answer 1

除非您只想包装数组，否则无需创建包含对象。

public static void sortMultiArrays(int[] ... index) {
  // merge arrays
  List<int[]> zip = new ArrayList<int[]>(index[0].length);
  for(int i = 0; i<index[0].length;i++){
    int[] e = new int[index.length];
    for(int j = 0; j<index.length;j++){
      e[j] = index[j][i];
    }
    zip.add(e);
  }
  // sort by first index
  Collections.sort(zip,new ArrayComparator());

  // demerge arrays
  for(int i = 0; i<zip.size();i++) {
    int[] ints = zip.get(i);
    for (int j = 0;j<ints.length;j++) {
      index[j][i] = ints[j];
    }
  }
}

private static class ArrayComparator implements Comparator<int[]>{

  @Override
  public int compare(int[] a, int[] b) {
    return a[0] < b[0] ? -1 : a[0] == b[0] ? 0 : 1;
  }

}

根据一个数组对相同大小的数组进行排序

1 个答案: