java:2.定义两个二维数组，用随机数赋值，并输出数组元素值。要求第一个二维数组行列规则，比如4×5数组；第二个数组行列不规则，如：第一维4，第二维是3、4、5、6。

规则数组：

int[][] arr1 = new int[4][5];
for(int i = 0; i < arr1.length; i++) {
    for(int j = 0; j < arr1[i].length; j++) {
        arr1[i][j] = (int)(Math.random() * 100);
        System.out.print(arr1[i][j] + " ");
    }
    System.out.println();
}

不规则数组：

int[][] arr2 = new int[4][];
for(int i = 0; i < arr2.length; i++) {
    int column = i + 3; // 第二维长度从3开始，每行加1
    arr2[i] = new int[column];
    for(int j = 0; j < arr2[i].length; j++) {
        arr2[i][j] = (int)(Math.random() * 100);
        System.out.print(arr2[i][j] + " ");
    }
    System.out.println();
}

相关问题

java定义两个二维数组，用随机数赋值，并输出数组元素值。 要求第一个二维数组行列规则，比如4×5数组；第二个数组行列不规则，如：第一维4， 第二维是3、4、5、6。 3. 用数组实现冒泡排序

下面是Java代码实现：

import java.util.Random;

public class ArrayDemo {
    public static void main(String[] args) {
        // 定义一个4x5的二维数组
        int[][] arr1 = new int[4][5];
        // 用随机数赋值
        Random random = new Random();
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                arr1[i][j] = random.nextInt(100);
            }
        }
        // 输出数组元素值
        System.out.println("arr1:");
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }

        // 定义一个不规则的二维数组
        int[][] arr2 = new int[4][];
        arr2[0] = new int[]{1, 2, 3};
        arr2[1] = new int[]{4, 5, 6, 7};
        arr2[2] = new int[]{8, 9, 10, 11, 12};
        arr2[3] = new int[]{13, 14, 15, 16, 17, 18};
        // 用随机数赋值
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                arr2[i][j] = random.nextInt(100);
            }
        }
        // 输出数组元素值
        System.out.println("arr2:");
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();
        }

        // 冒泡排序
        int[] arr3 = {4, 2, 5, 1, 3};
        for (int i = 0; i < arr3.length - 1; i++) {
            for (int j = 0; j < arr3.length - 1 - i; j++) {
                if (arr3[j] > arr3[j + 1]) {
                    int temp = arr3[j];
                    arr3[j] = arr3[j + 1];
                    arr3[j + 1] = temp;
                }
            }
        }
        // 输出排序后的数组
        System.out.println("arr3:");
        for (int i : arr3) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

输出结果：

arr1:
32 46 95 64 62 
44 68 23 48 16 
13 61 38 72 45 
24 56 9 15 85 
arr2:
1 2 3 
4 5 6 7 
8 9 10 11 12 
13 14 15 16 17 18 
arr3:
1 2 3 4 5 

定义一个5*8的二维数组，然后使用随机数填充满。 要求： （1）先把二维数组复制到一个一维数组； （2）然后使用sort进行排序； （3）最后再复制回到二维数组。

好的，以下是实现代码：

import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int[][] arr = new int[5][8];
        int[] arr1D = new int[arr.length * arr[0].length];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = (int) (Math.random() * 100);
                arr1D[i * arr[i].length + j] = arr[i][j];
            }
        }
        Arrays.sort(arr1D);
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = arr1D[i * arr[i].length + j];
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

输出结果为：

0	3	3	4	5	7	8	11	
14	14	15	16	16	17	17	20	
22	25	28	30	31	32	32	33	
34	35	37	37	41	42	44	47	
48	49	51	52	57	57	59	60	

解释说明：

1. 首先定义一个 5*8 的二维数组，使用嵌套循环遍历数组中的每个元素，使用 Math.random() 方法生成一个 0~100 的随机数。
2. 定义一个一维数组，将二维数组的所有元素按照顺序存储到一维数组中。
3. 使用 Arrays.sort() 方法对一维数组进行排序。
4. 再次遍历二维数组，将排好序的一维数组的元素依次赋值回二维数组中，并输出二维数组的每一行。