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

落日映苍穹つ 2023-09-24 14:28 13阅读 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：普通for循环---》正向遍历：
                    for(int i=0;i<=9;i++){
                            System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
                    }
                    
                    //方式2：增强for循环:
                    //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
                    int count = 0;
                    for(int num:scores){
                            count++;
                            //每次都将num在控制台输出
                            System.out.println("第"+count+"个学生的成绩为："+num);
                    }
                    
                    /*
                    增强for循环：
                    优点：代码简单
                    缺点：单纯的增强for循环不能涉及跟索引相关的操作
                    */
                    
                    //方式3：利用普通for循环： 逆向遍历：
                    for(int i=9;i>=0;i--){
                            System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
                    }
                    
            }
    }

#### 数组复制 ####

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

![cab2d44851b04a658bb34510796caf55.png][]

![82890b7b9c27458d8443dd71c5f8af65.png][]

原理:

![5173cd108ec3466dbe63a5bee687b566.png][]

代码如下:

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

运行结果:

![beb4fa98c5db47278de725898019897d.png][]

#### 数组最值问题 ####

eg:求数组中的最大值

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

数组中参数传递:

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

#### 数组查询问题 ####

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

#### 在指定位置增加元素 ####

import java.util.Scanner;
    public class TestArray07{
        public static void main(String[] args){
                    //功能：给定一个数组,在数组下标为2的位置上添加一个元素91
                    
                    //1.给定一个数组：
                    int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
                    //           0  1   2 3 4 5
                    //2.输出增加元素前的数组：
                    /*
                    System.out.print("增加元素前的数组：");
                    for(int i=0;i<arr.length;i++){
                            if(i!=arr.length-1){
                                    System.out.print(arr[i]+",");
                            }else{//i==arr.length-1 最后一个元素不用加,
                                    System.out.print(arr[i]);
                            }
                    }
                    */
                    
                    //从键盘接收数据：
                    Scanner sc = new Scanner(System.in);
                    System.out.println("请录入你要添加元素的指定下标：");
                    int index = sc.nextInt();
                    System.out.println("请录入你要添加的元素：");
                    int ele = sc.nextInt();
                    
                    //3.增加元素
                    //调用方法：
                    insertEle(arr,index,ele);
                    
                    
                    
                    //4.输出增加元素后的数组：
                    System.out.print("\n增加元素后的数组：");
                    for(int i=0;i<arr.length;i++){
                            if(i!=arr.length-1){
                                    System.out.print(arr[i]+",");
                            }else{//i==arr.length-1 最后一个元素不用加,
                                    System.out.print(arr[i]);
                            }
                    }
                    
            }	
            
            /*
            提取一个添加元素的方法：
            在数组的指定位置上添加一个指定的元素。
            在哪个数组的哪个位置添加哪个元素！
            不确定因素：形参：哪个数组，哪个位置，哪个元素
            返回值：无
            
            */
            public static void insertEle(int[] arr,int index,int ele){
                    for(int i=arr.length-1;i>=(index+1);i--){
                            arr[i] = arr[i-1];
                    }
                    arr[index] = ele;
            }
    }

#### 在指定位置删除元素 ####

import java.util.Arrays;
    public class TestArray09{
        public static void main(String[] args){
                    //功能：给定一个数组,删除元素3：
                    
                    //1.给定一个数组：
                    int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
                     
                    //2.输出删除前的数组：
                    System.out.println("删除元素前的数组："+Arrays.toString(arr));
                    
                    
                    //找到要删除的元素对应的索引即可：
                    int index = -1 ;
                    for(int i=0;i<arr.length;i++){
                            if(arr[i]==1200){
                                    index = i;
                                    break;
                            }
                    }
                    
                    //3.删除
                    
                    if(index!=-1){
                            for(int i=index;i<=arr.length-2;i++){
                                    arr[i] = arr[i+1];
                            }
                            arr[arr.length-1] = 0;
                    }else{//index==-1
                            System.out.println("根本没有你要删除的元素！");
                    }
                    
                    
                    //4.输出删除后的数组：
                    System.out.println("删除元素后的数组："+Arrays.toString(arr));
            }
    }

#### Arrays工具类 ####

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

## 二维数组 ##

#### 基本定义 ####

#### 数组初始化 ####

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

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

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

#### 数组遍历 ####

四种遍历方式

public class TestArray15{
            public static void main(String[] args){
                    //定义一个二维数组：
                    int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                    
                    int[] a1 = {1,2,3};
                    arr[0] = a1;
                    
                    arr[1] = new int[]{4,5,6,7};
                    
                    arr[2] = new int[]{9,10};
                    
                    //读取6这个元素：
                    //System.out.println(arr[1][2]);
                    
                    //对二维数组遍历：
                    //方式1：外层普通for循环+内层普通for循环：
                    for(int i=0;i<arr.length;i++){
                            for(int j=0;j<arr[i].length;j++){
                                    System.out.print(arr[i][j]+"\t");
                            }
                            System.out.println();
                    }
                    
                    //方式2：外层普通for循环+内层增强for循环：
                    for(int i=0;i<arr.length;i++){
                            for(int num:arr[i]){
                                    System.out.print(num+"\t");
                            }
                            System.out.println();
                    }
                    
                    //方式3：外层增强for循环+内层增强for循环：
                    for(int[] a:arr){
                            for(int num:a){
                                    System.out.print(num+"\t");
                            }
                            System.out.println();
                    }
                    
                    //方式4：外层增强for循环+内层普通for循环：
                    for(int[] a:arr){
                            for(int i=0;i<a.length;i++){
                                    System.out.print(a[i]+"\t");
                            }
                            System.out.println();
                    }
            }
    }

####     ####

[cab2d44851b04a658bb34510796caf55.png]: https://img-blog.csdnimg.cn/cab2d44851b04a658bb34510796caf55.png
[82890b7b9c27458d8443dd71c5f8af65.png]: https://img-blog.csdnimg.cn/82890b7b9c27458d8443dd71c5f8af65.png
[5173cd108ec3466dbe63a5bee687b566.png]: https://img-blog.csdnimg.cn/5173cd108ec3466dbe63a5bee687b566.png
[beb4fa98c5db47278de725898019897d.png]: https://img-blog.csdnimg.cn/beb4fa98c5db47278de725898019897d.png