数组的练习

最新推荐文章于 2023-10-20 11:04:07 发布

耳东er

最新推荐文章于 2023-10-20 11:04:07 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： # Java数组文章标签： java

本文链接：https://blog.youkuaiyun.com/q734044429/article/details/116095721

Java数组专栏收录该内容

10 篇文章

订阅专栏

这篇博客详细介绍了如何使用Java进行数组操作，包括求解数组最小值、数组反转、排序、求最大值、合并数组以及二维数组的处理。内容涵盖了一维和二维数组的创建、填充随机数、排序以及合并等核心操作，是Java数组操作的实战指南。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先创建有一个长度是5的数组
然后给数组的每一位赋予随机整数
通过for循环，遍历数组，找出最小的一个值出来

0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

public class Array01 {
    public static void main(String[] args) {
        int[] num = new int[5];//创建一个int类型的数组，长度为5
        //为每一个数组元素赋予0~100的随机整数
        //方法一！
//        num[0]=(int)(Math.random()*100);
//        num[1]=(int)(Math.random()*100);
//        num[2]=(int)(Math.random()*100);
//        num[3]=(int)(Math.random()*100);
//        num[4]=(int)(Math.random()*100);

        //得出每个元素的值,并找出最小的值
        int n =1000;//求最小值时，先定义一个较大的值
        for (int i = 0; i < num.length; i++) {//下标为0~（5-1）
            num[i]=(int)(Math.random()*100);//方法二！
            System.out.print(num[i]+"\t");//每个元素的值
            if (num[i]<n){
                n=num[i];//替换得出最小值
            }
        }
        System.out.println();
        System.out.println(n);
    }
}

二、数组反转

首先创建一个长度是5的数组,并填充随机数
使用for循环或者while循环，对这个数组实现反转效果

0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

public class Array03 {
    public static void main(String[] args) {
        //创建一个长度为5的数组
        int[] arrays = new int[5];
        //每个元素赋值随机数
        for (int i = 0; i < arrays.length; i++) {
            arrays[i] = (int)(Math.random()*100);
            
            System.out.print(arrays[i]+"\t");//打印
        }
        
        System.out.println();//换行

        //先定义一个长度相等的空的数组
        int[] arrays1 = new int[arrays.length];
        //再反向赋值
        for (int i = 0; i < arrays.length; i++) {
            arrays1[i] = arrays[arrays.length-1-i];// -1 是因为下标是从0开始的
        }

        //再重新赋值给原来的数组
        arrays = arrays1;
        //增强for循环打印
        for (int array : arrays) {
            System.out.print(array+"\t");
        }
    }
}

三、排序

首先创建一个长度是5的数组,并填充随机数。
首先用选择法正排序，然后再对其使用冒泡法倒排序
注：所谓的正排序就是从小到大排序，倒排序就是从大到小排序

0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

···选择法排序···

public class Array06 {
    public static void main(String[] args) {
        //定义一个长度为5的数组
        int[] array1 = new int[5];
        //元素赋值：随机值
        for (int i = 0; i < array1.length; i++) {
            array1[i]=(int)(Math.random()*100);
        }
        //打印出原数组所有元素
        System.out.print("原数组排序：");
        for (int i : array1) {
            System.out.print(i+"\t");
        }
        System.out.println();

        // 选择法排序
        System.out.print("选择法排序：");
        for (int j = 0; j < array1.length-1; j++) {
            for (int i = j+1; i < array1.length; i++) {
                if (array1[j]>array1[i]){
                    int temp = 0;
                    temp = array1[j];
                    array1[j]=array1[i];
                    array1[i]=temp;
                }
            }
        }
        //增强for循环打印
        for (int i : array1) {
            System.out.print(i+"\t");
        }
    }
}

···冒泡排序···

public class Array07 {
    public static void main(String[] args) {
        // 定义一个长度为5的数组
        int[] array1 = new int[5];
        // 元素赋值：随机值
        for (int i = 0; i < array1.length; i++) {
            array1[i]=(int)(Math.random()*100);
        }
        // 打印出原数组所有元素
        System.out.print("原数组排序：");
        for (int i : array1) {
            System.out.print(i+"\t");
        }
        System.out.println();

        // 冒泡排序
        System.out.print("冒泡法排序：");
        for (int j = 0; j < array1.length-1; j++) {
            for (int i = 0; i < array1.length-1-j; i++) {
                if (array1[i]>array1[i+1]){
                    int temp = 0;
                    temp = array1[i];
                    array1[i] = array1[i+1];
                    array1[i+1] = temp;
                }
            }
        }
        //增强for循环打印
        for (int i : array1) {
            System.out.print(i+"\t");
        }
    }
}

四、求最大值

随机定义5个数，用增强型for循环找出最大的那个数

public class Array08 {
    public static void main(String[] args) {
        //创建长度为5的数组，随机定义5个数
        int[] array = new int[5];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int)(Math.random()*100);
//            System.out.print("array["+i+"]:"+array[i]+"---\t");
        }
        //求得最大值
        int num = array[0];//定义一个最大值
        for (int i : array) {
            System.out.print(i+"\t");
            if (num<i){
                num=i;
            }
        }
        System.out.println();
        System.out.println(num);
    }
}

五、合并数组

首先准备两个数组，他俩的长度是5-10之间的随机数，并使用随机数初始化这两个数组
然后准备第三个数组，第三个数组的长度是前两个的和
通过System.arraycopy 把前两个数组合并到第三个数组中

区间随机数方法查看文章------Java学习------Java生成区间随机数
0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

public class Array12 {
    public static void main(String[] args) {
        //创建两个数组，长度为[5,10]随机数，元素为[0,100)随机数
        int[] a = new int[(int)(Math.random()*(10-5+1))+5];
        int[] b = new int[(int)(Math.random()*(10-5+1))+5];
        //给a,b数组元素赋值
        //a赋值
        for (int i = 0; i < a.length; i++) {
            a[i] = (int)(Math.random()*100);
        }
        for (int i : a) {
            System.out.print(i+"\t");
        }
        System.out.println();
        //b赋值
        for (int i = 0; i < b.length; i++) {
            b[i] = (int)(Math.random()*100);
        }
        for (int i : b) {
            System.out.print(i+"\t");
        }
        System.out.println();

        //创建一个数组c,长度为a+b的长度，再把a、b数组合并到c
        //创建一个数组c
        int[] c = new int[(a.length+b.length)];
        //先把a合并到c
        System.arraycopy(a,0,c,0,a.length);
        //再把b合并到c
        System.arraycopy(b,0,c,a.length,b.length);
        //合并后打印
        for (int i : c) {
            System.out.print(i+"\t");
        }
    }
}

六、二维数组

定义一个5X5的二维数组。然后使用随机数填充该二维数组。
找出这个二维数组里，最大的那个值，并打印出其二维坐标

0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

方法一

public class Array13 {
    public static void main(String[] args) {
        //定义一个5*5的二维数组
        int[][] arrays = new int[5][5];
        //给所有元素赋值
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                arrays[i][j] = (int)(Math.random()*100);
            }
        }
        //打印二维数组
        System.out.println("数组的二维坐标:");
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        //找出最大值和其坐标
        int max = 0; //定义一个最大值
        int x = 0; //定义横竖坐标位置
        int y = 0; //定义横竖坐标位置
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                if (max < arrays[i][j]){
                    max = arrays[i][j];
                    x=i;
                    y=j;
                }
            }
        }
        System.out.println("最大数组元素值:"+max+",坐标为:arrays["+x+"]["+y+"]");
    }
}

方法二

public class Array131 {
    public static void main(String[] args) {
        //创建一个5*5二维数组
        int[][] ints = new int[5][5];
        //给元素赋值，并找到最大值和其坐标
        //定义最大值
        int max = 0;
        //定义坐标
        int x = 0 ;
        int y = 0 ;
        //给元素赋值，并找到最大值和其坐标
        System.out.println("打印二维数组");
        for (int i = 0; i < ints.length; i++) {
            for (int j = 0; j < ints[i].length; j++) {
                ints[i][j] = (int) (Math.random()*100);//赋值随机数
                System.out.print(ints[i][j]+"\t");
                if (max < ints[i][j]){//找出最大值和坐标
                    max = ints[i][j];
                    x = i;
                    y = j;
                }
            }
            System.out.println();
        }
        System.out.println("最大数组元素值:"+max+",坐标为:ints["+x+"]["+y+"]");
    }
}

七、二维数组排序

首先定义一个5X8的二维数组，然后使用随机数填充满。
借助Arrays的方法对二维数组进行排序。
参考思路：

先把二维数组使用System.arraycopy进行数组复制到一个一维数组
然后使用sort进行排序
最后再复制回到二维数组。

0~100的随机整数的获取办法有多种，下面是参考办法之一：
(int)(Math.random()*100)
Math.random() 会得到一个0~1之间的随机浮点数，然后乘以100，并强转为整数即可。

public class Array14 {
    public static void main(String[] args) {
        //定义一个5*8的二维数组
        int[][] array = new int[5][8];
        //给元素赋值,并打印出二维数组
        System.out.println("源二维数组");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = (int)(Math.random()*100);
//                System.out.print(array[i][j]+"\t"); //打印
            }
            System.out.print(Arrays.toString(array[i]));//打印
            System.out.println();
        }

        System.out.println("======================================");
        //给二维数组的每个一维数组单独进行排序
        System.out.println("每个一维数组单独进行排序后的二维数组");
        for (int i = 0; i < array.length; i++) {
            Arrays.sort(array[i]);//每个一维数组排序
            System.out.println(Arrays.toString(array[i]));//打印
        }

//        for (int[] i : array) {//增强for循环打印
//            for (int i1 : i) {
//                System.out.print(i1+"\t");
//            }
//            System.out.println();
//        }

        System.out.println("======================================");
        //把二维数组的所有元素进行排序

        int[] array1 = new int[5*8];//定义一个一维数组，长度为array.length*array[].length
        //把array二维数组的全部元素复制到array1一维数组
        for (int i = 0; i < array.length; i++) { 
            System.arraycopy(array[i],0,array1,i*array[i].length,array[i].length);
        }

        System.out.println("复制后的array1数组元素");
        System.out.println(Arrays.toString(array1));//打印array1数组元素

        Arrays.sort(array1);// 把array1排序

        System.out.println("排序后的array1数组元素");
        System.out.println(Arrays.toString(array1));//打印排序后的array1数组元素

        System.out.println("所有元素进行排序后的array二维数组");
        for (int i = 0; i < array.length; i++) {
            System.arraycopy(array1,i*array[i].length,array[i],0,array[i].length);
            System.out.println(Arrays.toString(array[i]));
        }
    }
}