Java，按关键字对多维数组排序

可能重复：

我有以下数据：

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

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

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

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

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

---

我在看数组。sort（）；但不确定如何实现，或者这是否是最好的方法。

使用自定义比较器对阵列进行排序：

Arrays.sort(myData , new Comparator<String[]>() {
            @Override
            public int compare(String[] o1, String[] o2) {
                return ((String) o2[1]).compareTo(o1[1]);
            }
        });

Arrays.sort（myData，新的Comparator（）{
@凌驾
公共整数比较（字符串[]o1，字符串[]o2）{
返回（（字符串）o2[1]）。比较（o1[1]）；
}
});

如果必须使用数组，我会使用自定义比较器。该比较器将根据传入的

字符串[]

的相应元素进行排序

---

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

好的，给您。可以从测试主类运行的两个自包含示例解决方案。第一种是使用多维数组

    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));
    }

对象值[][]=新对象[][]{
{“a”，Boolean.FALSE}，
{“b”，Boolean.TRUE}，
{“c”，Boolean.TRUE}，
};
数组。排序（值，
新比较器（）{
@凌驾
公共整数比较（对象[]tuple1，对象[]tuple2）{
int result=-1*（（布尔）tuple1[1]）。比较（（布尔）tuple2[1]）；
如果（结果==0）{
结果=（（字符串）tuple1[0]）。比较（（字符串）tuple2[0]）；
}                       
返回结果；
}
}
);
for（对象[]元组：值）{
System.out.println（Arrays.toString（tuple））；
}

第二个使用泛型（和类型更安全）元组

类元组{
私人决赛第一名；
私人决赛B秒；
公共元组（A第一，B第二）{
this.first=first；
这个秒=秒；
}
公共A getFirst（）{
先把这个还给我；
}
公共B getSecond（）{
把这个还给我；
}
/**
*{@inheritardoc}
*/
@凌驾
公共字符串toString（）{
返回“[first=“+first.toString（）+”，second=“+second.toString（）+””；
}
};
元组值[]=新元组[]{
新元组（“a”，布尔值.FALSE），
新元组（“b”，布尔值.TRUE），
新元组（“c”，布尔值.TRUE），
};
数组。排序（值，
新比较器（）{
@凌驾
公共int比较（元组tuple1，元组tuple2）{
int result=-1*tuple1.getSecond（）.compareTo（tuple2.getSecond（））；
如果（结果==0）{
结果=tuple1.getFirst（）.compareTo（tuple2.getFirst（））；
}                       
返回结果；
}
}
);
for（元组：值）{
System.out.println（元组）；
}

你应该使用

YourClass[]

而不是

String[]

你应该使用

YourClass[]

其中

YourClass

是你自己编写的一个类，它包含所需的信息并且

实现了可比性
感谢它现在排序，不管排序是假是真，你知道如何反向排序吗？@ubergam3r你可以使用
return（（String）o1[1]）。与（o2[1]）相比当然是愚蠢的我。。。。。。对不起，我的大脑有点油炸。谢谢你的帮助
    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);
    }