繁体   English   中英

Java 数组降序排序?

Java Array Sort descending?

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

是否有任何简单的方法可以按降序对数组进行排序,例如在Arrays class中如何按升序排序?

还是我必须停止懒惰并自己做:[

27 个回复

您可以使用它对所有类型的对象进行排序

sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

Arrays.sort()不能直接用于按降序对原始数组进行排序。 如果您尝试通过传递Collections.reverseOrder()定义的反向 Comparator 来调用Arrays.sort()方法,则会抛出错误

找不到适合 sort(int[],comparator) 的方法

这将适用于“对象数组”,例如整数数组,但不适用于原始数组,例如 int 数组。

按降序对原始数组进行排序的唯一方法是,首先按升序对数组进行排序,然后将数组原地反转。 对于二维原始数组也是如此。

一份清单

Collections.sort(list, Collections.reverseOrder());

对于数组

Arrays.sort(array, Collections.reverseOrder());

你可以使用这个:

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder()使用逆自然顺序返回一个Comparator 您可以使用Collections.reverseOrder(myComparator)获得您自己的比较器的反转版本。

另一种可能是(对于数字!!!)

  1. 将数组乘以 -1
  2. 种类
  3. 再次乘以-1

字面意思:

array = -Arrays.sort(-array)

没有显式比较器:

Collections.sort(list, Collections.reverseOrder());

使用显式比较器:

Collections.sort(list, Collections.reverseOrder(new Comparator()));

使用Arrays.sort()Collections.reverseOrder()不能直接对原始数组(即int[] arr = {1, 2, 3}; )进行反向排序,因为这些方法需要引用类型( Integer )原始类型 ( int )。

但是,我们可以使用 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]

爪哇 8:

Arrays.sort(list, comparator.reversed());

更新: reversed()反转指定的比较器。 通常,比较器按升序排列,因此这会将顺序更改为降序。

首先,您需要使用以下方法对数组进行排序:

Collections.sort(myArray);

然后,您需要使用以下方法将顺序从升序反转为降序:

Collections.reverse(myArray);

对于包含基元元素的数组,如果有org.apache.commons.lang(3)可以使用,那么反转数组(排序后org.apache.commons.lang(3)的简单方法是使用:

ArrayUtils.reverse(array);

我不知道您的用例是什么,但是除了这里的其他答案之外,另一个(懒惰的)选项仍然是按照您的指示按升序排序,然后以相反的顺序迭代。

另一个解决方案是,如果您使用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的属性。 这是按大小以相反的顺序对我定义的类频率进行排序。 因此,为了更正该问题,您可以切换<>返回的值。 这为您提供以下内容:

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) ,它会给你排序的数组freq [] mFreq

这个解决方案的美妙之处(在我看来)在于它可以用于对用户定义的类进行排序,甚至比按特定属性对它们进行排序还多。 如果 Comparable 接口的实现对您来说听起来令人生畏,我鼓励您不要那样想,实际上并非如此。 这个关于如何实现可比性的链接让我更容易。 希望大家能用上这个方案,希望你们的快乐和我的一样。

array.sort(function(a, b) {return b - a;}); //descending 

要么

array.sort(function(a, b) {return a - b;}); //ascending

对于上面的讨论,这里有一个简单的例子来按降序对原始数组进行排序。

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

我知道这是一个很旧的线程,但这里是整数和 Java 8 的更新版本:

Arrays.sort(array, (o1, o2) -> o2 - o1);

请注意,对于正常的升序(或 Comparator.comparingInt()),它是“o1 - o2”。

这也适用于任何其他类型的对象。 说:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

这里有很多混乱 - 人们建议非原始值的解决方案,尝试从地面实施一些排序算法,提供涉及额外库的解决方案,炫耀一些黑客等。原始问题的答案是 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

当数组是 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();

对于按降序排序的二维数组,您只需翻转参数的位置

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

这对我有用:

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
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 条件中将 ">=" 更改为 "<=" 以使顺序升序。

您可以将操作( 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 等)。

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

比较器的另一种方式

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

有时我们练习一个例子很好,这是一个完整的例子:

排序描述文件

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

来源

有一种方法可能会更长一点,但效果很好。 这是一种对 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;
    
}

我有以下工作解决方案

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

我知道这里有很多答案,但仍然认为,他们都没有尝试使用核心 java。 并且使用 collection api ,你最终会浪费这么多内存和剩余资源。

这是纯核心概念的尝试,是的,如果您更关心内存占用,这可能是更好的方法。

    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.

也喜欢向你学习!

这是我对原始类型 int 数组进行排序的方式。

int[] intArr = new int[] {9,4,1,7};
Arrays.sort(nums);
Collections.reverse(Arrays.asList(nums));

结果:

[1, 4, 7, 9]

在这里为几个不同的场景添加我的答案对于一个数组

Arrays.sort(a, Comparator.reverseOrder());

FWIW 列表

Lists.reverse(a);

任何和所有 Collections

Collections.reverse(a);
1 将Java中的数组按降序排序

我在玩数组和枚举,我想知道创建Comparator类以按降序对这些日期排序的最有效方法是什么。 这是我的代码。 使用以下语句,我可以按创建顺序打印数组。 您如何创建Comparator类以按降序对这些日期进行排序? 理想情况下,我希望它对数组进行排序,无论它是按顺序排列还是按 ...

2 Java:按降序对未排序的数组进行排序

我有未分类的对象数组。 我需要知道如何根据对象内的最大值按降序对数组进行排序。 我需要使用for循环来完成此操作,而不是简单的方法。 我已经这样做了,但似乎有一个问题: 我应该如何使用for循环? ...

2010-04-18 18:17:40 5 4803   java
3 Java:未排序的数组到降序的数组

我是一个学习Java的初学者,我正尝试将数组中的变量按降序传输到另一个数组。 这是我的代码: 当我输入213、45、1234、765、23、5作为数组时,它输出:排序后的数组1234765213213213213213 我不确定我的错误在哪里,请帮忙! ...

2017-05-15 13:05:19 3 59   java
4 在java中按降序对数组进行排序

我试图按降序对一个名为效率的数组进行排序,如下所示: 但是,它抛出一个异常,表示没有找到合适的方法。 然后我检查了文档,发现实际上有方法 那有什么问题? ...

5 Java中对象数组的降序选择排序

我目前正在开发一个银行账户程序,它接受用户输入并将其输入数组。 它执行存款,取款,搜索等操作。我目前正在使用基于每个账户余额的选择排序。 程序应根据从最高到最低的平衡对帐户进行排序,并将结果打印到屏幕上。 这是我第一次使用选择排序和我最初几次使用数组之一。 我理解选择排序的概念以及如 ...

6 JAVA:按降序对数组进行排序

我正在尝试以降序对数组进行排序,我知道有很多在线进行数组排序的示例,但是我只是想尝试以自己的方式进行操作(只是尝试测试算法是否可以正常工作)。 但是由于某些原因,我无法输出存储结果的数组,我尝试使用System.out.println(Arrays.toString(myList)); 并一 ...

2017-05-04 11:55:16 4 441   java
7 已排序? 检查数组是否在 Java 中按升序或降序排序

有人可以帮我检查我的代码是否正确或帮助我知道是否有其他方法可以解决这个问题我试图检查一个数组是按升序还是降序排列,如果不是,则返回 1,然后返回 0; 起初,我创建了一些以递增顺序和顺序对数组进行排序的方法以及另一种用于递减的方法,然后我使用这些方法与原始数组进行比较,如果它已排序。 我使用了下面的 ...

8 选择按降序排序-JAVA

我实现了选择排序,以对随机整数数组进行排序。 我希望用户在升序或降序之间进行选择。 升序排序可以完美地工作,尽管降序没有。 这是我的选择排序的样子: 我看到了一些与我的问题类似的问题,尽管我所看到的所有问题都没有像这样设置他们的选择排序,所以我无法实现他们的解决方案。 ...

9 数组排序降序

我是java的新程序员,一直在使用这个网站来学习方法。 今天我偶然发现了另一个问题,即我正在为练习做的一个项目。 我有一个数组: 然后,用户通过Scanner对象询问此数组的值: 我设法对值“scores []”进行升序排序: 但我希望排序按降序排列。 当我把 ...

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2022 STACKOOM.COM