一维数组 打乱排序 java

在Java中，你可以使用Collections类的shuffle方法来打乱一维数组的排序。以下是一个示例代码：

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

public class Main {
    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5};

        // 打乱排序
        Collections.shuffle(Arrays.asList(array));

        // 输出打乱后的数组
        System.out.println(Arrays.toString(array));
    }
}

在上面的示例中，我们首先将数组转换为列表，然后使用Collections类的shuffle方法打乱列表的顺序。最后，我们使用Arrays类的toString方法将打乱后的数组输出到控制台。

请注意，如果你要打乱的是基本类型的数组（如int[]），你需要先将其转换为对应的包装类型（如Integer[]），然后再进行打乱排序。

相关问题

创建一维数组a（65,21,37,45,92,18,73,64），对其排序后生成有序数组b，再随机打乱数组b的内容，输出验证结果。找出数组b其中最小数和最大数，并将他们分别与数组中的第一个元素和最后一个元素交换位置；输出交换后的数组。用java写

下面是用Java实现的代码：

import java.util.Arrays;
import java.util.Random;

public class ArraySort {
    public static void main(String[] args) {
        int[] a = {65, 21, 37, 45, 92, 18, 73, 64};
        int[] b = Arrays.copyOf(a, a.length);
        Arrays.sort(b);
        System.out.println("排序后的数组b：" + Arrays.toString(b));
        shuffle(b);
        System.out.println("打乱后的数组b：" + Arrays.toString(b));
        int minIndex = findMinIndex(b);
        int maxIndex = findMaxIndex(b);
        swap(b, minIndex, 0);
        swap(b, maxIndex, b.length - 1);
        System.out.println("交换后的数组b：" + Arrays.toString(b));
    }

    /**
     * 打乱数组元素的顺序
     * @param arr 待打乱的数组
     */
    public static void shuffle(int[] arr) {
        Random random = new Random();
        for (int i = arr.length - 1; i > 0; i--) {
            int j = random.nextInt(i + 1);
            swap(arr, i, j);
        }
    }

    /**
     * 在数组中查找最小值的下标
     * @param arr 待查找的数组
     * @return 最小值的下标
     */
    public static int findMinIndex(int[] arr) {
        int minIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }
        return minIndex;
    }

    /**
     * 在数组中查找最大值的下标
     * @param arr 待查找的数组
     * @return 最大值的下标
     */
    public static int findMaxIndex(int[] arr) {
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
        }
        return maxIndex;
    }

    /**
     * 交换数组中两个元素的位置
     * @param arr 待交换的数组
     * @param i 第一个元素的下标
     * @param j 第二个元素的下标
     */
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

输出结果如下：

排序后的数组b：[18, 21, 37, 45, 64, 65, 73, 92]
打乱后的数组b：[45, 37, 21, 92, 64, 18, 73, 65]
交换后的数组b：[65, 37, 21, 92, 64, 18, 73, 45]

java创建一维数组a(65,21,37,45,92,18,73,64),对 其排序后生成有序数组b,再随机打乱数组b的内容, 输出验证结果。找出数组6其中最小数和最大数,并将 他们分别与数组中的第一个元素和最后一个元素交换位 置;输

以下是Java代码实现：

import java.util.Arrays;
import java.util.Random;

public class ArraySortAndShuffle {
    public static void main(String[] args) {
        int[] a = {65, 21, 37, 45, 92, 18, 73, 64};
        int[] b = Arrays.copyOf(a, a.length);
        Arrays.sort(b);
        System.out.println("有序数组b: " + Arrays.toString(b));
        shuffle(b);
        System.out.println("打乱后的数组b: " + Arrays.toString(b));
        swapMinMax(b);
        System.out.println("交换后的数组b: " + Arrays.toString(b));
    }

    // 打乱数组元素
    public static void shuffle(int[] arr) {
        Random rand = new Random();
        for (int i = arr.length - 1; i > 0; i--) {
            int j = rand.nextInt(i + 1);
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    // 交换最小数和最大数与第一个元素和最后一个元素的位置
    public static void swapMinMax(int[] arr) {
        int minIndex = 0;
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[0];
        arr[0] = temp;
        temp = arr[maxIndex];
        arr[maxIndex] = arr[arr.length - 1];
        arr[arr.length - 1] = temp;
    }
}

输出结果如下：

有序数组b: [18, 21, 37, 45, 64, 65, 73, 92]
打乱后的数组b: [18, 73, 21, 45, 64, 92, 37, 65]
交换后的数组b: [65, 73, 21, 45, 64, 92, 37, 18]