0

可能重复：
基于一列对二维数组进行排序

我有数据：

"Something1" "TRUE"
"Something2" "FALSE"
"Something3" "FALSE"
"Something4" "TRUE"

然后我将其存储在一个多维数组中：

String[][] myData = new String[data.length][2];

现在我想对这个数组进行排序，使其首先按“TRUE”排序，所以它变成：

"Something1" "TRUE"
"Something4" "TRUE"
"Something2" "FALSE"
"Something3" "FALSE"

我在看 Arrays.sort(); 但不确定如何实现这一点，或者这是否是最好的方法。

4

3 回答 3

2

使用自定义比较器对数组进行排序：

Arrays.sort(myData , new Comparator<String[]>() {
            @Override
            public int compare(String[] o1, String[] o2) {
                return ((String) o2[1]).compareTo(o1[1]);
            }
        });
于 2012-12-18T12:39:00.937 回答
0

如果您必须使用数组，我会使用带有自定义比较器的Arrays.sort() 。该比较器将对String[]传入的适当元素进行排序。

我可能不会使用多维数组，而是为数组的每一行实现一些对象。这些数据看起来紧密联系在一起，而不仅仅是数组中的元素。您可以适当地键入它 - 目前您将布尔值存储为字符串。

于 2012-12-18T12:40:04.250 回答
0

好的，这给你。您可以从测试主类运行两个独立的示例解决方案。第一个使用多维数组。

    Object values[][] = new Object[][] {
            { "a", Boolean.FALSE }, 
            { "b", Boolean.TRUE }, 
            { "c", Boolean.TRUE },              
    };

    Arrays.sort(values, 
            new Comparator<Object[]>() {
                @Override
                public int compare(Object[] tuple1, Object[] tuple2) {
                    int result = -1*((Boolean) tuple1[1]).compareTo((Boolean) tuple2[1]);
                    if (result == 0) {
                        result = ((String) tuple1[0]).compareTo(((String) tuple2[0]));
                    }                       
                    return result;
                }
            }
    );

    for (Object[] tuple : values) {
        System.out.println(Arrays.toString(tuple));
    }

第二个使用通用（和类型安全）元组。

    class Tuple<A, B> {
        private final A first;
        private final B second;

        public Tuple(A first, B second) {
            this.first = first;
            this.second = second;
        }

        public A getFirst() {
            return this.first;
        }

        public B getSecond() {
            return this.second;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public String toString() {
            return "[first=" + first.toString() + ",second="  + second.toString() + "]";
        }
    };

    Tuple<String, Boolean> values[] = new Tuple[] {
            new Tuple<String, Boolean>("a", Boolean.FALSE), 
            new Tuple<String, Boolean>("b", Boolean.TRUE),
            new Tuple<String, Boolean>("c", Boolean.TRUE),              
    };

    Arrays.sort(values, 
            new Comparator<Tuple<String, Boolean>>() {
                @Override
                public int compare(Tuple<String, Boolean> tuple1, Tuple<String, Boolean> tuple2) {
                    int result = -1*tuple1.getSecond().compareTo(tuple2.getSecond());
                    if (result == 0) {
                        result = tuple1.getFirst().compareTo(tuple2.getFirst());
                    }                       
                    return result;
                }
            }
    );

    for (Tuple<String, Boolean> tuple : values) {
        System.out.println(tuple);
    }
于 2012-12-18T15:27:15.083 回答