Java中的数组——详解！

r囧r小猫 2024-03-23 14:17 77阅读 0赞

## Java中的数组——详解！ ##

### 一、数组的概念与基本要素 ###

#### 1.概念 ####

**数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。**

#### 2.基本要素 ####

**一个数组由4个基本元素构成：数组名称、数组元素、元素索引、数据类型。**

**数组的索引就相当于C语言中数组的下标，关于数组的长度可以用数组名.length求出。**

int[] array = {
        1,2,3};
    int sz = arr.length;

#### 3.数组的定义 ####

**关于数组的定义，其实有很多种定义方法，接下来，我会给你们介绍几种定义数组的方法。**

//第一种定义数组的方法：
    int[] array1 = {
        1,2,3};//直接赋值（静态初始化）
                          //int[]是数组的类型，array为数组名，随意取名字
    
    //第二种定义数组的方法：
    int[] array2 = new int[]{
        1,2,3,4};//数组的动态初始化
    
    
    //第三种定义数组的方法：
    int[] array3 = new int[10];//只是分配了内存，但是没有进行赋值，默认值都是0，
    
    //第四种定义数组的方法：
    int[] array4;
    array = new int[]{
        1,2,3};//一定要为数组符初值，不然编译器会报错，

**对于没有赋初值的数组，编译器会自动赋值，以下表格是不同类型的数组，初值大小：**

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">初始值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">byte</td> 
   <td align="center">0</td> 
  </tr> 
  <tr> 
   <td align="center">short</td> 
   <td align="center">0</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">0</td> 
  </tr> 
  <tr> 
   <td align="center">long</td> 
   <td align="center">0</td> 
  </tr> 
  <tr> 
   <td align="center">float</td> 
   <td align="center">0.0f</td> 
  </tr> 
  <tr> 
   <td align="center">double</td> 
   <td align="center">0.0</td> 
  </tr> 
  <tr> 
   <td align="center">char</td> 
   <td align="center">‘/u0000’</td> 
  </tr> 
  <tr> 
   <td align="center">boolean</td> 
   <td align="center">false</td> 
  </tr> 
 </tbody> 
</table>

#### 4.注意事项 ####

*  **静态初始化虽然没有指定数组的长度，编译器在编译时会根据\{\}中元素个数来确定数组的长度。**
 *  **静态初始化时, \{\}中数据类型必须与\[\]前数据类型一致。**
 *  **静态初始化可以简写，省去后面的new T\[\]。T可以为任意数据类型。**
 *  **如果数组中存储元素类型为引用类型，默认值为null。**

### 二、数组的使用 ###

#### 1.对数组中的元素进行访问 ####

**数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过**  
**索引访问其任意位置的元素。**

int[] array = {
        1,2,3,4,5,6,7,8};
    System.out.println(array[0]);//1
    System.out.println(array[1]);//2
    System.out.println(array[2]);//3
    System.out.println(array[3]);//4
    System.out.println(array[4]);//5
    
    //当然也可以对数组中的元素进行修改，、
    array[0]=111;
    System.out.println(array[0]);//111

#### 2.注意事项 ####

**（1）数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素。**

**（2）下标从0开始，介于\[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。**

![在这里插入图片描述][62b6774cd22240e68b588afad40b6cbd.png_pic_center]

**所以在访问数组元素时一定不要越界！！！**

#### 3.对数组的遍历 ####

**对于什么是对数组的遍历，就是将数组的元素全都访问一遍，如将数组中的全部元素的打印一遍。**

第一种数组遍历方法：**直接打印数组中的每一个元素**

**Demo：**

int[] array = {
        1,2,3,4};
    System.out.println(array[0]);
    System.out.println(array[1]);
    System.out.println(array[2]);
    System.out.println(array[3]);

**本方法对于元素个数较少的数组来说可以应用，但对于有几十个元素的数组来说，太麻烦了，接下来为大家讲解第二种方法。**

第二种数组遍历的方法：**采用for循环打印**

**Demo：**

int[] array = {
        1,2,3,4};
    for(int i = 0;i < array.length;i++) {
        
        System.out.print(array[i]);
    }

第三种数组遍历的方法：**采用foreach的方式**

**Demo：**

int[] array = {
        1,2,3,4,5};
    for(int x : array) {
        
        System.out.print(x+" ");
    }

**foreach的语法格式：冒号右边写数组名，左边写由数组当中数据类型定义的变量。**

**但是foreach也有局限性，如果要求去访问数组中的某一个元素的时候，就不能进行访问，显然这时的for循环就占据了优势。**

第四种遍历数组的方法：**采用专门的工具**

**Demo：**

import java.util.Arrays;
    
    int[] array = {
        1,2,3,4,5};
    String ret = Arrays.toString(array);//将数组转换成字符串，然后返回.
    System.out.println(ret);

**注：要使用Arrays这个工具时要导入其专有的包！**

### 三、数组在内存的存在形式 ###

#### 1.数组是一种引用变量 ####

**基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；**  
**而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址，数组就是一种引用数据类型。**

int a = 10;
    int b = 20;
    int[] array =new int[]{
        1,2,3,4};

**在上述代码中，a、b、arr，都是方法内部的变量，因此其空间都在main方法对应的栈帧中分配。**  
**a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。**  
**array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。**

![在这里插入图片描述][0b56b8def24a47c6994437f324b52e59.png_pic_center]

**从图中可以看出，引用变量与基本数据类型的变量的不同，引用变量不会存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象，（但其实这“地址”是经过哈希得到的），此前不要求掌握该知识点。**

#### 2了解引用变量（数组） ####

**Demo：**

int[] array1 = {
        1,2,3,4};
    System.out.print(Arrays.toString(array1));//打印[1,2,3,4]
    
    int[] array2 = array1;
    array2[1] = 99;
    System.out.print(Arrays.toString(array1));//打印[1,99,3,4]
    System.out.print(Arrays.toString(array2));//打印[1,99,3,4]

**代码的解析：**

![在这里插入图片描述][9a5b89de5c714a428ad48777f8704815.png_pic_center]

**首先创建一个数组array1，并初始化赋值为1,2,3,4，然后打印数组array1，接着申请另一款空间，用来创建array2，且array2=array1，说明两个数组都指向同一块空间，修改array2中的第二个元素也就相当于修改了array1中对应的元素。**

#### 3.注意事项 ####

**（1）一个引用不能同时指向多个对象**  
**例：**  
![在这里插入图片描述][f00eff9373a440e994c6bf007f4a1239.png_pic_center]

**（2）一个对象可以被多个引用所指向**  
例：  
![在这里插入图片描述][52e1f5ff75984a70b8897ec974c2cc60.png_pic_center]

（3）

int[] array = 0;
    /*这种写法是错误的，因为0是一种基本数据类型，
     *而array是一种引用数据类型，如果将0改成null就不会错。
     *即代表这个引用不指向任何对象
    */

**注：null在Java中表示空引用，也就是一个不指向对象的引用，并不是0的意思。**

### 四、数组的应用场景 ###

#### 1.用来保存数据 ####

**Demo:**

int[] array = {
        1,2,3};
    for(int i = 0;i < array.length;i++ ) {
        
        System.out.print(array[i]);
    }

#### 2.数组作为方法的参数 ####

**Demo：**

public class TestDemo {
        
        public static void func1 (int[] array1) {
        
            array = new int[10];
        }
        public static void func2 (int[] array) {
        
            array[0] = 99;
        }
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4};
            func1(array);
            System.out.println(Arrays.toString(array));
            func2(array);
            System.out.println(Arrays.toString(array));
    
        }
    }

**代码解释：对func1方法进行解释就行，func2同理**

![在这里插入图片描述][482569d7afc941478ef0e2d36cbe9325.png_pic_center]

**形参的指向改变不会影响实参的指向改变！！！**

#### 3.数组作为方法的返回值 ####

**Demo：**

public class TestDemo {
        
        public static int[] func() {
        
            int[] array = {
        1,2,3,4};
            return array;
        }
        public static void main(String[] args) {
        
            int[] ret = func();
            System.out.println(Arrays.toString(ret));
        }
    }

### 五、数组的练习 ###

**小伙伴们，也可以直接去写一下，再过来看示例代码，增强自己的代码能力。**

#### 1.数组转成字符串 ####

**Demo：**

//第一种是利用编译器自带的工具
    int[] array = {
        1,2,3};
    String ret = Arrays.toString(array);
    System.out,print(ret);
    
    
    //第二种利用自己写的方法去解决
    public class TestDemo {
        
        public static String mytoString(int[] arr) {
        
            if(arr == null){
        
                return "null";
            }
            String ret = "[";
            for(int i=0;i<arr.length;i++) {
        
                ret+=arr[i];
                if(i!=arr.length-1) {
        
                    ret+=",";
                }
            }
            ret+="]";
            return ret;
        }
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5,6};
            String ret = mytoString(array);
            System.out.println(ret);
        }
        
        
    //打印结果为 [1,2,3,4,5,6]

#### 2.数组的拷贝 ####

**本练习还是采用两种方式，一种是编译器自带的，另一种是自己所写的方法。**

**下面是错误代码！！！**

/*
            int[] array1 = {1,2,3};
            int[] array2 = array1;
    */
    //这不是对数组的拷贝，因为没有产生新的空间

**Demo：**

//第一种：自己写的方法
    public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array1 = {
        1,2,3,4};
            int[] array2 = new int[array1.length];
    
            for(int i=0;i<array1.length;i++) {
        
                array2[i]=array1[i];
            }
    
            System.out.println(Arrays.toString(array1));
            System.out.println("复制之后的数组为：");
            System.out.println(Arrays.toString(array2));
    
        }
    }
    
    //最后输出为：
      [1,2,3,4]
      复制之后的数组为：
      [1,2,3,4] 
        
        
    //第二种编译器自带的方法
        import java.util.Arrays;
        
        int[] array1 = {
        1,2,3,4};
        int[] array2 = Arrays.copyOf(array1,array1.length);
    
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    
    //最后输出为：
        [1,2,3,4] 
        [1,2,3,4]

**显然自己写的方法没有编译器自带的工具简洁，但是不能说有了这些工具就可以不用写代码了，自己的能力还是要加强，这些工具只是帮我们减轻了负担，但是原理还是要自己弄懂。**

#### 3.求数组的平均值 ####

**由于这道题比较简单，本博主直接就给答案咯。**

**Demo：**

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        23,45,2,74,86,24};
            int sum = 0 ;
            double ave = 0.0f;
            for(int i=0; i<array.length;i++) {
        
                 sum=sum + array[i];
            }
             ave = sum/array.length;
            System.out.println(ave);
    
        }
    }
    
    //最后结果：
      42.0

#### 4.数组排序（冒泡排序） ####

**算法思路：**

*  **将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素**  
    **就在数组的末尾**
 *  **依次从上上述过程，直到数组中所有的元素都排列好**

**Demo：**

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        23,4,53,1,765,52,356,9,7,2,324};
            System.out.println("排序之前的数组：");
            System.out.println(Arrays.toString(array));
            for(int j = 1;j<array.length;j++) {
        
                for(int i = 0;i<array.length-j;i++) {
        
                    if(array[i]>array[i+1]) {
        
                        int tmp = array[i];    //交换数据
                        array[i] = array[i+1];
                        array[i+1] = tmp;
                    }
                }
            }
            System.out.println("排序之后的数组：");
            System.out.println(Arrays.toString(array));
        }
    }
    
    
    //排序之前的数组：
    [23, 4, 53, 1, 765, 52, 356, 9, 7, 2, 324]
    //排序之后的数组：
    [1, 2, 4, 7, 9, 23, 52, 53, 324, 356, 765]

#### 5.数组逆序 ####

题目理解：**就是给定一个数组，将其倒序输出。**

思路：  
**先定义两个下标分别指向数组的第一个元素和最后一个元素，将数组中的第一个元素和最后一个元素交换位置，然后指向第一个元素的下标进行加加，指向最后一个元素的下标进行减减。**

**Demo：**

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5,6};
            int left = 0;
            int right = array.length-1;
            System.out.println("排序之前的数组：");
            System.out.println(Arrays.toString(array));
    
            while(left<=right) {
        
                int tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
                left++;
                right--;
            }
            System.out.println("排序之后的数组：");
            System.out.println(Arrays.toString(array));
        }
    }
    
    //运行结果：
    排序之前的数组：
    [1, 2, 3, 4, 5, 6]
    排序之后的数组：
    [6, 5, 4, 3, 2, 1]

### 六、二维数组 ###

#### 1.二维数组的定义 ####

**关于二维数组的定义有很多种方法，这里咱们介绍最常用的三种。**

**Demo：**

//第一种定义二维数组的方法:（行数和列数都知道的情况）
    //  数组类型[][] 数组名 = new 数组类型[行数][列数];
    
     int[][] arr = new int[2][3];//定义一个3行4列的数组

![在这里插入图片描述][c61baa78a01d4a0e9aaaeec3d3b6fbd8.png_pic_center]

//第二种定义数组的方法：（只知道行数，不知道列数）
    //  数组类型[][] 数组名 = new 数组类型[行数][];
    
    int[][] arr = new int[2][];

![在这里插入图片描述][3fc5a4cd3cf54e6f80acbd2eca392c43.png_pic_center]

//第三种定义二维数组的方法：（知道具体的数据）
    //  数据类型[][] 数组名 = {
        {第0行初始值}，{第1行初始值}，···，{第n行初始值}};
    
    int[][] arr = {
        {
        1,2},{
        3,4,5},{
        6,7,8,9}};

![在这里插入图片描述][9f1ea1c6e7fb4bfc8051c439318bfc7d.png_pic_center]

**以上就是关于二维数组最常见的定义方法！！！**

#### 2.二维数组的打印 ####

**二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.**

**Demo：**

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[][] array = {
        {
        1,2},{
        3,4,5},{
        6,7,8,9}};
            for(int i=0;i< array.length;i++) {
        
                for(int j=0;j<array[i].length;j++) {
        
                    System.out.print(array[i][j]+" ");
                }
                System.out.println(" ");
            }
        }
    }
    
    //运行结果：
    1 2  
    3 4 5  
    6 7 8 9

**由于二维数组的应用和一维数组并没有太大的区别，所以，在这里不做介绍，学会如何定义二维数组就好。**

[62b6774cd22240e68b588afad40b6cbd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/f50d0b00f51942f398fe6ad1c0ca1446.png
[0b56b8def24a47c6994437f324b52e59.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/28d232273cb5460c9636aca8cdf3f48b.png
[9a5b89de5c714a428ad48777f8704815.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/65fd273703434cd4a90ec2348716c2d1.png
[f00eff9373a440e994c6bf007f4a1239.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/bca6ad409ca744bbb0951a2a26a0748d.png
[52e1f5ff75984a70b8897ec974c2cc60.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ee899aee52e341e296a6a94c819c4b33.png
[482569d7afc941478ef0e2d36cbe9325.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/99df192e9eca47cd9b7e143c9d8b0ef3.png
[c61baa78a01d4a0e9aaaeec3d3b6fbd8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/5380299b6e3f49e68e12c1c28879eeff.png
[3fc5a4cd3cf54e6f80acbd2eca392c43.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ce7dc4c0057445c8a37734d10e3a424e.png
[9f1ea1c6e7fb4bfc8051c439318bfc7d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0b2a4e8785b449f99352cd07a0e2144f.png