数组(一维数组和二维数组的初始化及遍历)

落日映苍穹つ 2023-09-24 14:28 183阅读 0赞

一维数组

数组声明

数组的作用：用来存储相同类型的数据
//以int类型数据为案例：数组用来存储int类型数据
1.声明(定义数组)
int[] arr; //定义一个int类型的数组，名字叫arr
int arr2[];
如果数组只声明，没有后续操作，那么这个数组相当于没定义
int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值 不一样的效果

2.创建
arr = new int[4];//给数组开辟了一个长度为4的空间
编译期声明和创建会被合为一句话: int[] arr = new int[4];

数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

1.静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};—>错误
2.int[] arr ;
arr = {12,23,45}; —->错误

2.动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;
3.默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[] arr = new int[3]; —-> 数组有默认的初始化值

数组遍历

方式1：普通for循环—-》正向遍历

方式2：增强for循环

方式3：利用普通for循环： 逆向遍历

代码如下:

  1. //将数组中的每个元素进行查看--》数组的遍历：
  2.                 //方式1：普通for循环---》正向遍历：
  3.                 for(int i=0;i<=9;i++){
  4.                         System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
  5.                 }
  7.                 //方式2：增强for循环:
  8.                 //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
  9.                 int count = 0;
  10.                 for(int num:scores){
  11.                         count++;
  12.                         //每次都将num在控制台输出
  13.                         System.out.println("第"+count+"个学生的成绩为："+num);
  14.                 }
  16.                 /*
  17.                 增强for循环：
  18.                 优点：代码简单
  19.                 缺点：单纯的增强for循环不能涉及跟索引相关的操作
  20.                 */
  22.                 //方式3：利用普通for循环： 逆向遍历：
  23.                 for(int i=9;i>=0;i--){
  24.                         System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
  25.                 }
  27.         }
  28. }

数组复制

当数组进行复制时,会将数组元素复制到新数组之中

cab2d44851b04a658bb34510796caf55.png

82890b7b9c27458d8443dd71c5f8af65.png

原理:

5173cd108ec3466dbe63a5bee687b566.png

代码如下:

  1. import java.util.Arrays;
  2. public class TestArray14{
  3.         public static void main(String[] args){
  4.                 //给一个源数组：
  5.                 int[] srcArr = {11,22,33,44,55,66,77,88};
  6.                 //给一个目标数组：
  7.                 int[] destArr = new int[10];
  9.                 //复制：
  10.                 System.arraycopy(srcArr,1,destArr,3,3);
  11.                 //遍历查看目标数组：
  12.                 System.out.println(Arrays.toString(destArr));
  13.         }
  15. }

运行结果:

beb4fa98c5db47278de725898019897d.png

数组最值问题

eg:求数组中的最大值

  1. public static int getMaxNum(int[] arr){
  2.                 //先找一个数上擂台，假定认为这个数最大：
  3.                 int maxNum = arr[0];
  4.                 for(int i=0;i<arr.length;i++){
  5.                         if(arr[i]>maxNum){
  6.                                 maxNum = arr[i];
  7.                         }
  8.                 }
  9.                 return maxNum;
  11.         }

数组中参数传递:

方法的实参传递给形参的时候一定要注意：一切都是值传递：
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值

数组查询问题

  1. public class TestArray06{
  2.     public static void main(String[] args){
  3.                 //查询指定元素的位置--》找出元素对应的索引 
  4.                 //给定一个数组：
  5.                 int[] arr = {12,34,56,7,3,56};
  6.                 //           0  1  2  3 4  5
  8.                 //功能：查询元素888对应的索引：
  9.                 //调用方法：
  10.                 int index = getIndex(arr,999);
  11.                 //后续对index的值进行判断：
  12.                 if(index!=-1){
  13.                         System.out.println("元素对应的索引："+index);
  14.                 }else{//index==-1
  15.                         System.out.println("查无次数！");
  16.                 }
  17.         }
  19.         /*
  20.         定义一个方法：查询数组中指定的元素对应的索引：
  21.         不确定因素：哪个数组，哪个指定元素  （形参）
  22.         返回值：索引
  24.         */
  25.         public static int getIndex(int[] arr,int ele){
  26.                 int index = -1; //这个初始值只要不是数组的索引即可
  27.                 for(int i=0;i<arr.length;i++){
  28.                         if(arr[i]==ele){
  29.                                 index = i;//只要找到了元素，那么index就变成为i
  30.                                 break;//只要找到这个元素，循环就停止
  31.                         }
  32.                 }
  33.                 return index;
  34.         }
  35. }

在指定位置增加元素

  1. import java.util.Scanner;
  2. public class TestArray07{
  3.     public static void main(String[] args){
  4.                 //功能：给定一个数组,在数组下标为2的位置上添加一个元素91
  6.                 //1.给定一个数组：
  7.                 int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
  8.                 //           0  1   2 3 4 5
  9.                 //2.输出增加元素前的数组：
  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{//i==arr.length-1 最后一个元素不用加,
  16.                                 System.out.print(arr[i]);
  17.                         }
  18.                 }
  19.                 */
  21.                 //从键盘接收数据：
  22.                 Scanner sc = new Scanner(System.in);
  23.                 System.out.println("请录入你要添加元素的指定下标：");
  24.                 int index = sc.nextInt();
  25.                 System.out.println("请录入你要添加的元素：");
  26.                 int ele = sc.nextInt();
  28.                 //3.增加元素
  29.                 //调用方法：
  30.                 insertEle(arr,index,ele);
  34.                 //4.输出增加元素后的数组：
  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{//i==arr.length-1 最后一个元素不用加,
  40.                                 System.out.print(arr[i]);
  41.                         }
  42.                 }
  44.         }    
  46.         /*
  47.         提取一个添加元素的方法：
  48.         在数组的指定位置上添加一个指定的元素。
  49.         在哪个数组的哪个位置添加哪个元素！
  50.         不确定因素：形参：哪个数组，哪个位置，哪个元素
  51.         返回值：无
  53.         */
  54.         public static void insertEle(int[] arr,int index,int ele){
  55.                 for(int i=arr.length-1;i>=(index+1);i--){
  56.                         arr[i] = arr[i-1];
  57.                 }
  58.                 arr[index] = ele;
  59.         }
  60. }

在指定位置删除元素

  1. import java.util.Arrays;
  2. public class TestArray09{
  3.     public static void main(String[] args){
  4.                 //功能：给定一个数组,删除元素3：
  6.                 //1.给定一个数组：
  7.                 int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
  9.                 //2.输出删除前的数组：
  10.                 System.out.println("删除元素前的数组："+Arrays.toString(arr));
  13.                 //找到要删除的元素对应的索引即可：
  14.                 int index = -1 ;
  15.                 for(int i=0;i<arr.length;i++){
  16.                         if(arr[i]==1200){
  17.                                 index = i;
  18.                                 break;
  19.                         }
  20.                 }
  22.                 //3.删除
  24.                 if(index!=-1){
  25.                         for(int i=index;i<=arr.length-2;i++){
  26.                                 arr[i] = arr[i+1];
  27.                         }
  28.                         arr[arr.length-1] = 0;
  29.                 }else{//index==-1
  30.                         System.out.println("根本没有你要删除的元素！");
  31.                 }
  34.                 //4.输出删除后的数组：
  35.                 System.out.println("删除元素后的数组："+Arrays.toString(arr));
  36.         }
  37. }

Arrays工具类

  1. 为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。
  3. import java.util.Arrays;
  4. public class TestArray13{
  5.         public static void main(String[] args){
  6.                 //给定一个数组：
  7.                 int[] arr = {1,3,7,2,4,8};
  8.                 //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
  9.                 System.out.println(Arrays.toString(arr));
  11.                 //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
  12.                 //这个方法的使用前提：一定要查看的是一个有序的数组：
  13.                 //sort：排序 -->升序
  14.                 Arrays.sort(arr);
  15.                 System.out.println(Arrays.toString(arr));
  16.                 System.out.println(Arrays.binarySearch(arr,4));
  18.                 int[] arr2 = {1,3,7,2,4,8};
  19.                 //copyOf:完成数组的复制：
  20.                 int[] newArr = Arrays.copyOf(arr2,4);
  21.                 System.out.println(Arrays.toString(newArr));
  23.                 //copyOfRange:区间复制：
  24.                 int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
  25.                 System.out.println(Arrays.toString(newArr2));
  27.                 //equals:比较两个数组的值是否一样：
  28.                 int[] arr3 = {1,3,7,2,4,8};
  29.                 int[] arr4 = {1,3,7,2,4,8};
  30.                 System.out.println(Arrays.equals(arr3,arr4));//true
  31.                 System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
  33.                 //fill：数组的填充：
  34.                 int[] arr5 = {1,3,7,2,4,8};
  35.                 Arrays.fill(arr5,10);
  36.                 System.out.println(Arrays.toString(arr5));
  37.         }
  38. }

二维数组

基本定义

  1. public class TestArray15{
  2.         public static void main(String[] args){
  3.                 //定义一个二维数组：
  4.                 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
  6.                 int[] a1 = {1,2,3};
  7.                 arr[0] = a1;
  9.                 arr[1] = new int[]{4,5,6,7};
  11.                 arr[2] = new int[]{9,10};
  12.         }
  13. }

数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

  1. eg:
  2. int[][] arr = {
  3.    {1,2},{4,5,6},{4,5,6,7,8,9,9}};
  4. int[][] arr =new int[][] {
  5.    {1,2},{4,5,6},{4,5,6,7,8,9,9}};
  6. 动态初始化
  7. 数组定义与为数组元素分配空间并赋值的操作分开进行。
  8. eg:
  9. int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
  10. arr[0] = new int[]{1,2};
  11. arr[1] = new int[]{3,4,5,6};
  12. arr[2] = new int[]{34,45,56};
  14. eg:
  15. int[][] arr = new int[3][2]; 
  16. public class TestArray16{
  17.         public static void main(String[] args){
  18.                 int[][] arr = new int[3][2];
  19.                 //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：
  21.                 arr[1] = new int[]{1,2,3,4};
  23.                 //数组遍历：
  24.                 for(int[] a:arr){
  25.                         for(int num:a){
  26.                                         System.out.print(num+"\t");
  27.                         }
  28.                         System.out.println();
  29.                 }
  31.         }
  32. }

静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组遍历

四种遍历方式

  1. public class TestArray15{
  2.         public static void main(String[] args){
  3.                 //定义一个二维数组：
  4.                 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
  6.                 int[] a1 = {1,2,3};
  7.                 arr[0] = a1;
  9.                 arr[1] = new int[]{4,5,6,7};
  11.                 arr[2] = new int[]{9,10};
  13.                 //读取6这个元素：
  14.                 //System.out.println(arr[1][2]);
  16.                 //对二维数组遍历：
  17.                 //方式1：外层普通for循环+内层普通for循环：
  18.                 for(int i=0;i<arr.length;i++){
  19.                         for(int j=0;j<arr[i].length;j++){
  20.                                 System.out.print(arr[i][j]+"\t");
  21.                         }
  22.                         System.out.println();
  23.                 }
  25.                 //方式2：外层普通for循环+内层增强for循环：
  26.                 for(int i=0;i<arr.length;i++){
  27.                         for(int num:arr[i]){
  28.                                 System.out.print(num+"\t");
  29.                         }
  30.                         System.out.println();
  31.                 }
  33.                 //方式3：外层增强for循环+内层增强for循环：
  34.                 for(int[] a:arr){
  35.                         for(int num:a){
  36.                                 System.out.print(num+"\t");
  37.                         }
  38.                         System.out.println();
  39.                 }
  41.                 //方式4：外层增强for循环+内层普通for循环：
  42.                 for(int[] a:arr){
  43.                         for(int i=0;i<a.length;i++){
  44.                                 System.out.print(a[i]+"\t");
  45.                         }
  46.                         System.out.println();
  47.                 }
  48.         }
  49. }

#

发表评论

表情：
评论列表 （有 0 条评论，183人围观）

还没有评论，来说两句吧...

相关阅读

    相关 二维数组的初始化与遍历

           这里主要写一些二维数组的简单总结，我对二维数组的理解是：“数组里面套数组”；对比一下一维数组，一维数组中的元素是基本类型的数值或者是引用，那么二维数组的元素即为一

    Dear 丶Dear 丶/ 0 赞/ 321 阅读

    相关 二维数组的遍历

    java二维数组和C语言二数组的理解是相同的，即都可以看成是矩阵。 下面程序是对二维数组的遍历过程： 【方法一】：录入和输出基本相同，第一层for循环控制行数的变化；第二层

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 518 阅读