有什么简单的方法可以按降序对数组进行排序，就像它们在Arrays 类中按升序排序一样？
还是我必须停止懒惰并自己做这个：[
问问题
588780 次
25 回答
397
您可以使用它对所有类型的对象进行排序
sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());
Arrays.sort()不能直接用于按降序对原始数组进行排序。如果您尝试Arrays.sort()通过传递定义的反向比较器来调用该方法Collections.reverseOrder()，则会抛出错误
没有找到适合 sort(int[],comarator) 的方法
这适用于“对象数组”，例如整数数组，但不适用于原始数组，例如 int 数组。
按降序对原始数组进行排序的唯一方法是，首先按升序对数组进行排序，然后将数组反转到位。对于二维原始数组也是如此。
于 2009-11-07T23:12:15.233 回答
108
列表
Collections.sort(list, Collections.reverseOrder());
对于一个数组
Arrays.sort(array, Collections.reverseOrder());
于 2013-06-25T04:31:58.693 回答
88
你可以使用这个：
Arrays.sort(data, Collections.reverseOrder());
Collections.reverseOrder()Comparator使用逆自然顺序返回 a 。您可以使用Collections.reverseOrder(myComparator).
于 2009-11-08T02:14:01.313 回答
78
另一种可能是（对于数字！！！）
- 将数组乘以 -1
- 种类
- 再次乘以 -1
字面意思：
array = -Arrays.sort(-array)
于 2014-09-05T16:58:28.983 回答
52
没有明确的比较器：
Collections.sort(list, Collections.reverseOrder());
使用显式比较器：
Collections.sort(list, Collections.reverseOrder(new Comparator()));
于 2014-10-18T01:08:18.463 回答
18
不能直接使用and对原始数组（即int[] arr = {1, 2, 3};）进行反向排序，因为这些方法需要引用类型（）而不是原始类型（）。Arrays.sort()Collections.reverseOrder()Integerint
但是，我们可以使用 Java 8 Stream 来首先将数组装箱以进行逆序排序：
// an array of ints
int[] arr = {1, 2, 3, 4, 5, 6};
// an array of reverse sorted ints
int[] arrDesc = Arrays.stream(arr).boxed()
.sorted(Collections.reverseOrder())
.mapToInt(Integer::intValue)
.toArray();
System.out.println(Arrays.toString(arrDesc)); // outputs [6, 5, 4, 3, 2, 1]
于 2019-06-19T18:26:59.973 回答
13
首先，您需要使用以下命令对数组进行排序：
Collections.sort(myArray);
然后，您需要使用以下命令将顺序从升序反转为降序：
Collections.reverse(myArray);
于 2016-02-26T19:35:49.933 回答
11
爪哇 8：
Arrays.sort(list, comparator.reversed());
更新：
reversed()反转指定的比较器。通常，比较器按升序排列，因此这会将顺序更改为降序。
于 2015-09-26T23:11:12.617 回答
5
对于包含基元元素的数组，如果可以org.apache.commons.lang(3)使用简单的方法来反转数组（在对其进行排序之后）是使用：
ArrayUtils.reverse(array);
于 2014-02-27T10:27:43.943 回答
4
我不知道您的用例是什么，但是除了此处的其他答案之外，另一个（惰性）选项仍然是按照您的指示按升序排序，然后以相反的顺序进行迭代。
于 2014-02-27T10:51:42.263 回答
4
对于上面的讨论，这是一个按降序对原始数组进行排序的简单示例。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
Arrays.sort(nums);
// reverse the array, just like dumping the array!
// swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
// swap(2nd, 2nd-last) <= 2nd: i++, 2nd-last: j--
// swap(3rd, 3rd-last) <= 3rd: i++, 3rd-last: j--
//
for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
// dump the array (for Java 4/5/6/7/8/9)
for (int i = 0; i < nums.length; i++) {
System.out.println("nums[" + i + "] = " + nums[i]);
}
}
}
输出：
nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0
于 2019-10-10T05:51:05.067 回答
4
当数组是 Integer 类的类型时，您可以在下面使用：
Integer[] arr = {7, 10, 4, 3, 20, 15};
Arrays.sort(arr, Collections.reverseOrder());
当数组是 int 数据类型时，您可以在下面使用：
int[] arr = {7, 10, 4, 3, 20, 15};
int[] reverseArr = IntStream.rangeClosed(1, arr.length).map(i -> arr[arr.length-i]).toArray();
于 2021-01-17T17:15:35.570 回答
3
另一个解决方案是，如果您使用Comparable接口，您可以切换您在 compareTo(Object bCompared) 中指定的输出值。
例如 ：
public int compareTo(freq arg0)
{
int ret=0;
if(this.magnitude>arg0.magnitude)
ret= 1;
else if (this.magnitude==arg0.magnitude)
ret= 0;
else if (this.magnitude<arg0.magnitude)
ret= -1;
return ret;
}
在我的程序中，幅度是数据类型为double的属性。这是按其大小以相反的顺序对我定义的类频率进行排序。因此，为了更正这一点，您可以切换<and返回的值>。这为您提供以下内容：
public int compareTo(freq arg0)
{
int ret=0;
if(this.magnitude>arg0.magnitude)
ret= -1;
else if (this.magnitude==arg0.magnitude)
ret= 0;
else if (this.magnitude<arg0.magnitude)
ret= 1;
return ret;
}
要使用此 compareTo，我们只需调用Arrays.sort(mFreq)which 将为您提供排序数组freq [] mFreq。
这个解决方案的美妙之处（在我看来）在于它可以用于对用户定义的类进行排序，甚至可以通过特定属性对它们进行排序。如果 Comparable 接口的实现听起来让您望而生畏，我鼓励您不要那样想，实际上并非如此。这个关于如何实现可比性的链接让我的事情变得容易多了。希望人们可以利用这个解决方案，你的快乐甚至可以和我的一样。
于 2016-05-11T06:51:27.643 回答
3
对于要按降序排序的 2D 数组，您只需翻转参数的位置
int[][] array= {
{1, 5},
{13, 1},
{12, 100},
{12, 85}
};
Arrays.sort(array, (a, b) -> Integer.compare(a[1], b[1])); // for ascending order
Arrays.sort(array, (b, a) -> Integer.compare(a[1], b[1])); // for descending order
降序输出
12, 100
12, 85
1, 5
13, 1
于 2021-01-22T08:21:37.793 回答
1
我知道这是一个相当古老的线程，但这里是整数和 Java 8 的更新版本：
Arrays.sort(array, (o1, o2) -> o2 - o1);
请注意，对于正常升序（或 Comparator.comparingInt()），它是“o1 - o2”。
这也适用于任何其他类型的对象。说：
Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
于 2018-01-03T18:13:17.650 回答
1
这里发生了很多混乱 - 人们建议非原始值的解决方案，尝试从地面实现一些排序算法，提供涉及其他库的解决方案，展示一些 hacky 等等。原始问题的答案是 50 /50。对于那些只想复制/粘贴的人：
// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};
// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++)
arrOfObjects[i] = new Integer(arrOfPrimitives[i]);
// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());
arrOfObjects现在是{6,5,4,3,2,1}。如果您有一个非整数数组 - 使用相应的对象而不是Integer.
于 2019-10-08T12:01:26.373 回答
1
对 int 数组进行降序排序的简单方法：
private static int[] descendingArray(int[] array) {
Arrays.sort(array);
int[] descArray = new int[array.length];
for(int i=0; i<array.length; i++) {
descArray[i] = array[(array.length-1)-i];
}
return descArray;
}
于 2019-10-11T21:09:24.130 回答
0
这对我有用：
package doublearraysort;
import java.util.Arrays;
import java.util.Collections;
public class Gpa {
public static void main(String[] args) {
// initializing unsorted double array
Double[] dArr = new Double[] {
new Double(3.2),
new Double(1.2),
new Double(4.7),
new Double(3.3),
new Double(4.6),
};
// print all the elements available in list
for (double number : dArr) {
System.out.println("GPA = " + number);
}
// sorting the array
Arrays.sort(dArr, Collections.reverseOrder());
// print all the elements available in list again
System.out.println("The sorted GPA Scores are:");
for (double number : dArr) {
System.out.println("GPA = " + number);
}
}
}
输出：
GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2
于 2018-03-24T20:11:17.727 回答
0
public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length; j++) {
if (array[i] >= array[j]) {
double x = array[i];
array[i] = array[j];
array[j] = x;
}
}
}
return array;
}
只需使用此方法对 double 类型的数组进行降序排序，您可以使用它对任何其他类型的数组（如 int、float 等）进行排序，只需更改“返回类型”、“参数类型”和变量“x”类型为对应的类型。您还可以在 if 条件中将 ">=" 更改为 "<=" 以使顺序升序。
于 2018-04-29T07:57:02.517 回答
0
您可以将流操作（Collections.stream()）与Comparator.reverseOrder()一起使用。
例如，假设你有这个集合：
List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");
要以“自然”顺序打印项目，您可以使用sorted()方法（或将其省略并获得相同的结果）：
items.stream()
.sorted()
.forEach(item -> System.out.println(item));
或者要以降序（反向）顺序打印它们，您可以使用采用 Comparator 的sorted方法并反转顺序：
items.stream()
.sorted(Comparator.reverseOrder())
.forEach(item -> System.out.println(item));
请注意，这要求集合已实现 Comparable（如 Integer、String 等）。
于 2019-04-28T22:07:17.167 回答
0
比较器的另一种方式
import java.util.Arrays;
import java.util.Comparator;
...
Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder() );
于 2019-11-21T19:06:43.527 回答
0
有时候我们练习一个例子很好，这是一个完整的例子：
sortdesc.java
import java.util.Arrays;
import java.util.Collections;
class sortdesc{
public static void main(String[] args){
// int Array
Integer[] intArray=new Integer[]{
new Integer(15),
new Integer(9),
new Integer(16),
new Integer(2),
new Integer(30)};
// Sorting int Array in descending order
Arrays.sort(intArray,Collections.reverseOrder());
// Displaying elements of int Array
System.out.println("Int Array Elements in reverse order:");
for(int i=0;i<intArray.length;i++)
System.out.println(intArray[i]);
// String Array
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};
// Sorting String Array in descending order
Arrays.sort(stringArray,Collections.reverseOrder());
// Displaying elements of String Array
System.out.println("String Array Elements in reverse order:");
for(int i=0;i<stringArray.length;i++)
System.out.println(stringArray[i]);}}
编译它...
javac sortdec.java
叫它...
java sortdesc
输出
Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA
如果你想尝试一个字母数字数组......
//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};
//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};
你会得到如下输出：
50AA
20AA
10FF
于 2020-06-22T21:13:18.043 回答
0
有一种方法可能会更长一些，但效果很好。这是一种对 int 数组进行降序排序的方法。
希望有一天这会对某人有所帮助：
public static int[] sortArray (int[] array) {
int [] sortedArray = new int[array.length];
for (int i = 0; i < sortedArray.length; i++) {
sortedArray[i] = array[i];
}
boolean flag = true;
int temp;
while (flag) {
flag = false;
for (int i = 0; i < sortedArray.length - 1; i++) {
if(sortedArray[i] < sortedArray[i+1]) {
temp = sortedArray[i];
sortedArray[i] = sortedArray[i+1];
sortedArray[i+1] = temp;
flag = true;
}
}
}
return sortedArray;
}
于 2020-07-27T04:44:00.893 回答
0
我有以下工作解决方案
public static int[] sortArrayDesc(int[] intArray){
Arrays.sort(intArray); //sort intArray in Asc order
int[] sortedArray = new int[intArray.length]; //this array will hold the sorted values
int indexSortedArray = 0;
for(int i=intArray.length-1 ; i >= 0 ; i--){ //insert to sortedArray in reverse order
sortedArray[indexSortedArray ++] = intArray [i];
}
return sortedArray;
}
于 2020-12-23T23:56:16.000 回答
-1
我知道这里有很多答案，但仍然认为，他们都没有尝试使用核心 java。并且使用 collection api ，你最终会浪费这么多内存和 reeduals。
这是纯核心概念的尝试，是的，如果您更关心内存占用，这可能是更好的方法。
int[] elements = new int [] {10,999,999,-58,548,145,255,889,1,1,4,5555,0,-1,-52};
//int[] elements = null;
if(elements != null && elements.length >1)
{
int max = 0, index = 0;
for(int i =0;i<elements.length;i++)//find out what is Max
{
if(elements[i] > max)
{
max = elements[i];
index = i;
}
}
elements[index] = elements[0];//Swap the places
elements[0] = max;
for(int i =0;i < elements.length;i++)//loop over element
{
for(int j = i+1;j < elements.length;j++)//loop to compare the elements
{
if(elements[j] > elements[i])
{
max = elements[j];
elements[j] = elements[i];
elements[i] = max;
}
}
}
}//i ended up using three loops and 2 extra variables
System.out.println(Arrays.toString(elements));//if null it will print null
// still love to learn more, please advise if we can do it better.
也喜欢向你学习！
于 2021-08-12T11:05:18.323 回答