Question

我的问题可能看起来很复杂，但我看到了几个问题，无法满足我的追求。

我有这样的数据：

index value
  1    220
  2    123
  3    11123
  4    440
  5    3400

我已将其保存到String[] data= new String[5];中，如下所示：

data[0]= 1 + " " + 220;
data[1]= 2 + " " + 123;
...

现在我做的是：

Arrays.sort(data);

它做的是排序，但是w.r.t.第1栏。

我希望这个能为我做这件事w.r.t.第二栏。

有可能或者我错了吗？

此外，我不确定这是否是我用来保存此类数据的正确方法？

如果我想使用int（s）来保存这些值，怎么样呢？

即。从保存数据到按正式Java样式排序？

编辑：这是一个两列案例，我已经说过index和value。我对具有两列以上和不同数据类型的案例特别感兴趣。应该在哪里进行分类w.r.t.指定的任何列的元素。

Answer 1

创建一个类，将两个相关的数据元素（索引和值）保存为字段（可能是getter和setter）。编写两个Comparator类，一个按索引排序，另一个按值排序。我可能会在类中创建工厂方法来获取这些比较器。

您可以创建新类的数组，而不是创建String数组。构造您的类实例并分配给数组。

您可以在阵列上使用Arrays.sort，无论哪种比较器都适合对阵列进行有效排序。这也使您可以轻松访问各个字段。

兄弟 - 这里有一些代码可以帮助你入门......

public class Bro {
    private int index;
    private int value;
    public Bro (int index, int value) {
        this.index = index;
        this.value = value;
    }
    public static Comparator<Bro> getIndexComparator() {
        return new Comparator<Bro>() {
            public int compare(Bro o1, Bro o2) {
                return o1.index - o2.index;
            }
        }
    }
}
Bro[] bros = new Bro[5];
bros[0] = new Bro(1, 220);
...
Arrays.sort(bros, Bro.getIndexComparator());

Java提供了两个类似的接口：Comparator和Comparable。如果类具有自然排序顺序，则可以实现Comparable。如果您需要以多种方式对类进行排序，则将为所需的每个排序顺序实现Comparator。

Answer 2

我建议使用Tuple类来保存键/值，然后使用比较器基于键/值排序。像下面这样的东西。它是用Java 8编写的。

class Main {

  public static void main(String[] args) {
    Tuple[] data = new Tuple[5];
    data[0] = new Tuple(1, 220);
    data[1] = new Tuple(2, 123);
    data[2] = new Tuple(3, 11123);
    data[3] = new Tuple(4, 440);
    data[4] = new Tuple(5, 3400);

    Arrays.sort(data, (t1, t2) -> t1.value - t2.value);
   }
}


class Tuple {
   int key;
   int value;

   public Tuple(int key, int value) {
     this.key = key;
     this.value = value;
   }

   @Override
   public String toString() {
    return "(" + key + ", " + value + ")";
   }
}

关于一般情况，我担心在Java中你无法定义具有未知数量的泛型类型的类型。但如果您事先知道有多少列，您可以执行以下操作：

class Tuple<T1 extends Comparable<T1>, T2 extends Comparable<T2>, ..., Tn extends Comparable<Tn>> {
   T1 col_1;
   T2 col_2;
   ...
   Tn col_n;

   public Tuple(T1 col_1, T1 col_2, ..., Tn col_n) {
     this.col_1 = col_1;
     this.col_2 = col_2;
     ...
     this.col_n = col_n;
   }

   @Override
   public String toString() {
    return "(" + col_1 + ", " + ... +  col_n + ")";
   }
}

然后根据列号进行排序，如下所示：

Arrays.sort(data, (t1, t2) -> t.col_i.compareTo(t2.col_i))

基本上，每个列类型都知道如何将自己与自己的类型进行比较。

Answer 3

您可能需要考虑使用Map来获取此类数据。以index为密钥，value为与密钥关联的数据。

如果你想主要使用value进行排序，那么反之亦然。

类似的东西：

TreeMap<Integer, Integer> dataMap = new TreeMap<>(); //sorts the entries according to key
dataMap.add(220, 1);
dataMap.add(123, 2);
...

您可以进一步查找一堆方法来迭代TreeMap here。

Answer 4

您可以使用自定义比较器仅在比较期间重新分割字符串，并使用int值进行比较。所以不要使用

Arrays.sort(data);

您应该使用：

Arrays.sort(data, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            int val1 = Integer.valueOf(o1.split(" ")[1]);
            int val2 = Integer.valueOf(o2.split(" ")[1]);
            // Ascending
            if (val1 > val2) {
                return 1;
            } else if (val1 == val2) {
                return 0;
            }
            return -1;
        }    
});

如何对w.r.t的对象数组进行排序使用Java的关键？

4 个答案: