• Java的数组使用

    数组的定义：

    1. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    2.  
    3. /**
    4.  * 数组的作用：用来存储相同类型的数据
    5.  * 以int类型数据为案例：数组用来存储int类型数据
    6.  * 1》声明定义数组
    7.  * int【】 arr   定义一个int类型的数组，名字为arr
    8.  * int arr2【】
    9.  * 如果数组只声明，没有后续操作，那么这个数组相当于没有定义
    10.  * int 【】 arr3=null； 空  数组赋值为null和和什么都没有赋值 不一样的效果
    11.  *
    12.  * 2》创建
    13.  * arr=new int【4】；  给数组开辟了一个长度为4的空间
    14.  * int 【】arr=new int【4】；声明和创建和为一句话
    15.  * 3》赋值
    16.  * arr[0]=12;
    17.  * arr[1]=1255;
    18.  * arr[2]=1;
    19.  * arr[3]=232;
    20.  * ====================arr[4]=16452;-------------数组索引越界
    21.  *
    22.  * 4》使用
    23.  *System.out.println(arr[1]);
    24.  *数组的长度
    25.  * System.out.println(arr.length);
    26.  *
    27.  *
    28.  */
    29. public class TestArray02 {
    30.     public static void main(String[] args) {
    31.  
    32.  
    33.     }
    34. }

    数组的使用：

    1. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    2.  
    3. import java.util.Scanner;
    4.  
    5. /**
    6.  * 功能：键盘录入十个学生的成绩，求和，求平均数
    7.  *
    8.  */
    9. public class TestArray03 {
    10.     public static void main(String[] args) {
    11.         int[] scores=new int[10];
    12.         int sum=0;
    13.         Scanner sc=new Scanner(System.in);
    14.         for (int i = 0; i < 10; i++) {
    15.             System.out.println("请录入第"+(i+1)+"个学生的成绩");
    16.             int score=sc.nextInt();
    17.             scores[i]=score;
    18.             sum+=score;
    19.         }
    20.         System.out.println("十个学生的成句之和为"+sum);
    21.         System.out.println("十个学生成绩平均数为："+sum/10);
    22.  
    23.         //求取第6个学生的成绩
    24. //        System.out.println(scores[5]);
    25.  
    26.         //数组的遍历----》方式一
    27. //        for (int i = 0; i <= 9; i++) {
    28. //            System.out.println(scores[i]);
    29. //        }
    30.         //增强for循环 ----------》方式二
    31.         //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
    32. //        int count=0;
    33. //        for(int num:scores){
    34. //            //每次豆浆num在控制台输出
    35. //            System.out.println("第"+count+"个学生的成绩为："+num);
    36. //        }
    37. /**
    38.  * 增强for循环
    39.  * 优点：代码简单
    40.  * 缺点：单纯的增强for循环不能涉及跟索引相关的操作
    41.  */
    42. //方式三：利用普通的for循环：逆向遍历：
    43.         for (int i=9;i>=0;i++){
    44.             System.out.println(scores[i]);
    45.         }
    46.     }
    47. }

    求取数组中的最大值

    1. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    2.  
    3. /**
    4.  * 求最大值
    5.  */
    6. public class TestArray04 {
    7.     public static void main(String[] args) {
    8.         //1.定义一个数组
    9.         int[] arr = {12, 3, 7, 4, 8, 125, 9, 45, 666, 36};
    10.         //2.求出数组中的最大值：
    11.         int num = getMaxNum(arr);
    12.         System.out.println("当前数组中最大的数为：" + num);
    13.  
    14.     }
    15.     public static int getMaxNum(int[] arr) {
    16.         int maxNum = arr[0];
    17.         for (int i = 0; i < arr.length; i++) {
    18.             if (arr[i] > maxNum) {
    19.                 maxNum = arr[i];
    20.             }
    21.         }
    22.         return maxNum;
    23.     }
    24. }

    查询元素对应的索引

    1. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    2.  
    3. public class TestArray05 {
    4.     public static void main(String[] args) {
    5.         int[] arr={12,34,56,7,3,10};
    6.  
    7.         System.out.println(arr[2]);
    8.  
    9.         //查询56对应的索引
    10.         int index=getindex(arr,56);
    11.        if (index!=-1){
    12.            System.out.println("元素对应的索引："+index);
    13.        }else {
    14.            System.out.println("查无此书！");
    15.        }
    16.     }
    17.     public static int getindex(int []arr,int ele){
    18.         int index=-1;//初始值只要不是数组的索引就行
    19.         for (int i=0;i<arr.length;i++){
    20.             if(arr[i]==ele){
    21.                 index=i;//只要找到了元素，那么index就变成i
    22.                 break;
    23.             }
    24.         }
    25.         return index;
    26.     }
    27. }

    数组添加元素

    1. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class TestArray07 {
    6.     public static void main(String[] args) {
    7.         //给定一个数组，在数组下标为2的位置上添加一个元素91
    8.  
    9.         int[] arr = {12, 34, 56, 7, 3, 10};
    10.         //输出增加元素前的数组
    11.         System.out.print("增加元素前的数组：");
    12.         for (int i = 0; i < arr.length; i++) {
    13.             if (i != arr.length - 1) {
    14.                 System.out.print(arr[i] + ",");
    15.             } else {
    16.                 System.out.print(arr[i]);
    17.             }
    18.         }
    19. //从键盘接受数据
    20.         Scanner sc=new Scanner(System.in);
    21.         System.out.print("\n请录入你要添加元素的指定下标:");
    22.         int index=sc.nextInt();
    23.         System.out.print("请录入你要添加的元素:");
    24.         int ele=sc.nextInt();
    25.  
    26.         //增加元素
    27.         insertEle(arr,index,ele);
    28. /**
    29.  * arr[5]=arr[4];
    30.  *  arr[4]=arr[3];
    31.  *  arr[3]=arr[2];
    32.  */
    34.         //输出后增加元素后的数组
    35.         System.out.print("\n增加元素后的数组：");
    36.         for (int i = 0; i < arr.length; i++) {
    37.             if (i != arr.length - 1) {
    38.                 System.out.print(arr[i] + ",");
    39.             } else {
    40.                 System.out.print(arr[i]);
    41.             }
    42.         }
    43.     }
    44.  
    45.     /**
    46.      * 提起一个添加元素的方法：
    47.      * 在数组的指定位置上添加一个指定的元素
    48.      * 在哪个数组的哪个位置添加哪个元素
    49.      * 不确定因素：形参：哪个数组，哪个位置，哪个元素
    50.      * 返回值：无
    51.      */
    52. public static  void  insertEle(int []arr,int index ,int ele){
    53.  
    54.     for (int i = arr.length - 1; i >= (index+1); i--) {
    55.         arr[i] = arr[i - 1];
    56.     }
    57.     arr[index] = ele;
    58.  
    59.  
    60. }
    61.  
    62.  
    63.  
    64. }

    删除数组元素

    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 10:45
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray08
    6.  * @Description: TODO 给定一个数组，删除下标为2元素
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11.  
    12. import java.util.Arrays;
    13.  
    14. public class TestArray08 {
    15.     public static void main(String[] args) {
    16.         int[] arr = {12, 34, 56, 7, 3, 10};
    17. //输出删除前的数组：
    18.         System.out.println("删除前的数组" + Arrays.toString(arr));
    19.         //删除
    20. //        arr[2]=arr[3];
    21. //        arr[3]=arr[4];
    22. //        arr[4]=arr[5];
    23.         int index = 2;
    24.         for (int i = index; i <= arr.length - 2; i++) {
    25.             arr[i] = arr[i + 1];
    26.         }
    27.         arr[arr.length - 1] = 0;
    28.  
    29.         //输出删除后的数组
    30.         System.out.println("删除后的数组" + Arrays.toString(arr));
    31.  
    32.  
    33.     }
    34. }
    35.  
    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 11:02
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray09
    6.  * @Description: TODO
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11. import java.util.Arrays;
    12.  
    13. public class TestArray09 {
    14.     public static void main(String[] args) {
    15.         int[] arr = {12, 34, 56, 7, 3, 10,34,45,56,7,666};
    16. //输出删除前的数组：
    17.         System.out.println("删除前的数组" + Arrays.toString(arr));
    18.  
    19.         //找到要删除的元素对应的索引即可
    20.         int index = -1;
    21.         for (int i=0;i<arr.length;i++){
    22.             if (arr[i]==333){
    23.                 index=i;
    24.                 break;
    25.             }
    26.         }
    27.  
    28.         //删除
    29. //        arr[2]=arr[3];
    30. //        arr[3]=arr[4];
    31. //        arr[4]=arr[5];
    32. //        int index = 2;
    33.        if (index!=-1){
    34.            for (int i = index; i <= arr.length - 2; i++) {
    35.                arr[i] = arr[i + 1];
    36.            }
    37.            arr[arr.length - 1] = 0;
    38.        }else {
    39.            System.out.println("根本没有你要删除的元素！");
    40.        }
    41.  
    42.         //输出删除后的数组
    43.         System.out.println("删除后的数组" + Arrays.toString(arr));
    44.  
    45.  
    46.     }
    47. }
    48.

    可变参数

    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 14:09
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray12
    6.  * @Description: TODO1)可变参数：作用提供了一个方法，参数的个数是可变的，解决了部分方法重载问题
    7.  * int...num
    8.  * double...num
    9.  * boolean...num
    10.  *
    11.  * 2)可变参数在JDK1.5之后加入的新特性
    12.  *3)方法的内部对可变参数的处理跟数组是一样的
    13.  *4)可变参数和其它数据一起作为形参的时候，可变参数一定要放到最后
    14.  * 5）我们自己在写代码的时候，建议不要使用可变参数
    15.  * @Version 1.0
    16.  */
    17. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    18.  
    19. public class TestArray12 {
    20.     public static void main(String[] args) {
    21. //        method01(10);
    22. //        method01();
    23. //        method01(20,30,40);
    24.         method01(30,40,50,60,70);
    25. //        method01(new int[]{11,22,33,44});
    26.     }
    27.     public static  void  method01(int num2,int...num){
    28.         System.out.println("--------------1");
    29.         for (int i:num){
    30.             System.out.println(i+"\t");
    31.         }
    32.         System.out.println();
    33.         System.out.println(num2);
    34.     }
    35.  
    36. }
    37.

    数组的复制

    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 14:53
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray13
    6.  * @Description: TODO
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11. import java.util.Arrays;
    12.  
    13. public class TestArray13 {
    14.     public static void main(String[] args) {
    15.  
    16.         //给定一个数组：
    17.         int[] arr={1,3,7,2,4,8};
    18.         //toString:对数组进行遍历查看，返回的是一个字符串，这个字符串比较好看
    19.         System.out.println(Arrays.toString(arr));
    20.  
    21.         //binarySearch：二分法查找，找出指定数组中的指定元素对应的索引
    22.         //这个方法的使用的前提:一定要查看的是一个有序的数组：
    23.         //sort：排序----》升序
    24.         Arrays.sort(arr);
    25.         System.out.println(Arrays.toString(arr));
    26.         System.out.println(Arrays.binarySearch(arr,4));
    27.  
    28.  
    29.         int[] arr2={1,3,7,2,4,8};
    30.         //copyOf:完成数组的复制
    31.         int [] newArr=Arrays.copyOf(arr2,4);
    32.         System.out.println(Arrays.toString(newArr));
    33.  
    34.         //copyOfRange:区间复制：
    35.         int [] newArr2=Arrays.copyOfRange(arr2,1,4);//[1,4)---->1,2,3位置
    36.         System.out.println(Arrays.toString(newArr2));
    37.  
    38.         //equals：比较两个数组的值是否一样：
    39.         int[] arr3={1,3,7,2,4,8};
    40.         int[] arr4={1,3,7,2,4,8};
    41.         System.out.println(Arrays.equals(arr3,arr4));//true
    42.         System.out.println(arr3==arr4);// false  ==比较左右两侧的值是否相等  比较的是左右的地址值，返回结果一定是false
    43.  
    44.         //fill：数组的填充
    45.         int[] arr5={1,3,7,2,4,8};
    46.         Arrays.fill(arr5,11);
    47.         System.out.println(Arrays.toString(arr5));
    48.  
    49.  
    50.  
    51.  
    52.     }
    53. }
    54.  
    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 16:19
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray14
    6.  * @Description: TODO
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11. import java.lang.reflect.Array;
    12. import java.util.Arrays;
    13.  
    14. public class TestArray14 {
    15.     public static void main(String[] args) {
    16.         //给一个源数组
    17.         int [] srcArr={11,22,33,44,55,66,77,88};
    18.         //给一个目标数组：
    19.         int [] destArr=new int[10];
    20.  
    21.         //复制
    22.         System.arraycopy(srcArr,1,destArr,3,3);
    23.         //遍历查看目标数组：
    24.         System.out.println(Arrays.toString(destArr));
    25.     }
    26. }
    27.

    二维数组的遍历

    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 16:36
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray15
    6.  * @Description: TODO--二维数组的定义与遍历
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11. public class TestArray15 {
    12.     public static void main(String[] args) {
    13.         //定义一个二维数组
    14.         int[][] arr=new int[3][];//本质上定义了一个一维数组，长度为3
    15.         int[] a1={1,2,3};
    16.         arr[0]=a1;
    17.         arr[1]=new int[]{4,5,6,7};
    18.         arr[2]=new int[]{9,10};
    19.  
    20.         //读取6这个元素
    21. //        System.out.println(arr[1][2]);
    22.         //遍历二维数组
    23.         //方式1：外层普通for循环+内层普通for循环：
    24. //        for (int i = 0; i <= 2; i++) {
    25. //            for (int j=0;j<arr[i].length;j++){
    26. //                System.out.print(arr[i][j]+"\t");
    27. //            }
    28. //            System.out.println();
    29. //        }
    30.         //方式2：外层普通for循环+内层增强for循环
    31. //        for (int i=0;i<arr.length;i++){
    32. //            for (int num:arr[i]){
    33. //                System.out.print(num+"\t");
    34. //            }
    35. //            System.out.println();
    36. //        }
    37.  
    38.         //方式3：外层增强for循环+内层增强for循环
    39. //        for (int[]a:arr){
    40. //            for (int num:a){
    41. //                System.out.print(num+"\t");
    42. //            }
    43. //            System.out.println();
    44. //        }
    45.          //方式5：外层增强for循环+内层普通for循环
    46.         for (int[]a:arr){
    47.             for (int i=0;i<a.length;i++){
    48.                 System.out.print(a[i]+"\t");
    49.             }
    50.             System.out.println();
    51.         }
    52.     }
    53. }
    54.  
    1. /**
    2.  * @Author zhengwang
    3.  * @Date 2023/11/7 16:57
    4.  * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
    5.  * @ClassName: TestArray16
    6.  * @Description: TODO
    7.  * @Version 1.0
    8.  */
    9. package The_First_Stage.The_beginner_level_Java_SE.Arrawy;
    10.  
    11. public class TestArray16 {
    12.     public static void main(String[] args) {
    13.         int[][] arr=new int[3][2];
    14.         //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组
    15.  
    16.         arr[1]=new int[]{1,2,3,4};
    17.         //数组遍历
    18.         for (int[] a:arr){
    19.             for (int num:a){
    20.                 System.out.print(num+"\t");
    21.             }
    22.             System.out.println();
    23.         }
    24.     }
    25. }
    26.

  • 相关阅读:
    【东软实训Day2】用Java实现客户端与服务器交互
    数据治理平台项目总结和分析
    自顶向下计算机网络学习 传输层
    Python测试题12道（含答案）
    华为机试真题 C++ 实现【找终点】
    shiro原理解析
    StarGAN v2: Diverse Image Synthesis for Multiple Domains （多域多样性图像合成）
    Docker SpringBoot项目连接本地数据库
    C语言百钱买百鸡（ZZULIOJ1074:百钱买百鸡）
    数字孪生与GIS的完美融合
  • 原文地址：https://blog.csdn.net/weixin_45503872/article/details/134273436