java数组从大到小排序

可以使用 Java 中的 Arrays 类提供的 sort 方法来对数组进行排序。默认情况下，sort 方法会按升序对数组进行排序。如果要按降序排序，可以使用 Comparator.reverseOrder() 方法作为 sort 方法的参数。

以下是一个示例代码，可以将一个 int 类型的数组按降序排序：

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};

        // 降序排序
        Arrays.sort(arr, Comparator.reverseOrder());

        // 打印排序后的数组
        System.out.println(Arrays.toString(arr));
    }
}

输出结果为：

[9, 6, 5, 5, 2, 1]

相关问题

JAVA 数组从大到小排序

可以使用 Arrays.sort() 方法将数组从小到大排序，然后使用 Collections.reverseOrder() 方法将其反转，即可得到从大到小排序的数组。

示例代码如下：

import java.util.Arrays;
import java.util.Collections;

public class ArraySort {
    public static void main(String[] args) {
        Integer[] arr = {5, 3, 8, 2, 7};
        Arrays.sort(arr, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }
}

输出结果：

[8, 7, 5, 3, 2]

java数组从大到小排序,插入数据仍保持有序

要将Java数组从大到小排序，并且插入新数据后仍然保持有序，可以使用以下步骤：

1. 首先，创建一个整数类型的数组并初始化。
2. 使用冒泡排序算法对数组进行从大到小排序。冒泡排序算法会比较相邻的元素并交换它们的位置，直到整个数组按照降序排序。
3. 定义一个新的整数变量，用于存储要插入的数据。
4. 创建一个新的数组，其长度比原数组大1。
5. 遍历原数组，将原数组的元素复制到新数组中，同时找到新数据需要插入的位置。
6. 插入数据到新数组的正确位置。
7. 返回已排序并插入新数据的新数组。

下面是一个示例代码实现：

public class ArraySorting {
    public static void main(String[] args) {
        int[] originalArray = {5, 2, 8, 1, 9};  // 原始数组

        int[] sortedArray = bubbleSort(originalArray);  // 从大到小排序

        int newData = 4;  // 要插入的数据

        int[] newArray = insertData(sortedArray, newData);  // 插入数据并保持有序

        // 输出排序后并插入新数据的数组
        for (int num : newArray) {
            System.out.print(num + " ");
        }
    }

    // 冒泡排序函数
    public static int[] bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] < array[j + 1]) {
                    // 交换元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }

    // 插入数据并保持有序函数
    public static int[] insertData(int[] array, int newData) {
        int n = array.length;
        int[] newArray = new int[n + 1];

        int i;
        for (i = 0; i < n; i++) {
            if (array[i] < newData) {
                newArray[i] = array[i];
            } else {
                break;
            }
        }

        newArray[i] = newData;

        for (; i < n; i++) {
            newArray[i + 1] = array[i];
        }

        return newArray;
    }
}

该代码首先对原始数组进行冒泡排序，然后再将要插入的数据插入到正确的位置，最后返回排序并插入新数据后的新数组。