Java基础语法——数组概念、数组内存图解（一个数组、二个数组）及二元数组的应用

- 日理万妓 2024-03-27 09:27 35阅读 0赞

**目录**

数组概述

数组定义格式

数组概念

数组的定义格式

数组的初始化

数组初始化概述

数组的初始化方式

Java中的内存分配

Java中一个数组的内存图解

Java中二个数组的内存图解

两个数组指向同一个地址的内存图解

数组操作中两个常见的小问题

二维数组

二维数组概述

二维数组定义格式

### 数组概述 ###

–需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后再进行操作，这样做会显得很麻烦。为了解决这种问题，Java提供了数组供我们使用。

–那么数组到底是什么呢?有什么特点呢?

*  数组是存储多个变量(元素)的东西(容器)
 *  这多个变量的数据类型要一致

### 数组定义格式 ###

#### 数组概念 ####

–数组是存储同一种数据类型多个元素的容器。

–数组既可以存储基本数据类型，也可以存储引用数据类型。

#### 数组的定义格式 ####

–格式1：数据类型\[\] 数组名;

–格式2：数据类型 数组名\[\];

–注意：这两种定义做完了，数组中是没有元素值的。**如何对数组的元素进行初始化呢?**

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

#### 数组初始化概述 ####

–Java中的数组必须先初始化,然后才能使用。

–所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

#### 数组的初始化方式 ####

–动态初始化：初始化时只指定数组长度，由系统为数组分配初始值,初始值都为0。

(1)格式：数据类型\[\] 数组名 = new 数据类型\[数组长度\];

(2)数组长度其实就是数组中元素的个数。

(3)举例：

•int\[\] arr = new int\[3\];

•解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

package com.demo01;
    
    public class ArrayDemo0 {
    
    	public static void main(String[] args) {
    		
    		// 这样程序比较麻烦
    		//int zhangsan = 10000;
    		//int lisi = 8000;
    		//.......
    		
    		// 整型数组工资
    		int[] gongzi = new int[80];
    		int gongzi1[] = new int[]{10000,8000,7500,11000};
    	}
    
    }

–静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

(1)格式：数据类型\[\] 数组名 = new 数据类型\[\]\{ 元素1,元素2,…\};

(2)举例：

•int\[\] arr = new int\[\]\{1,2,3\};

•解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。

•其实这种写法还有一个简化的写法

–int\[\] arr = \{1,2,3\};

package com.demo02;
    /*
     * 静态初始化的格式
      (1)格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    
                    (2)举例：
    
                            •int[] arr = new int[]{1,2,3};
    
                            •解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
    
                    •其实这种写法还有一个简化的写法
    
                    –int[] arr = {1,2,3};
     */
    public class ArrayDemo {
    	public static void main(String[] args) {
    		//定义数组
    		//int[] arr = new int[]{1,2,3};
    		int[] arr = {1,2,3};
    		
    		//输出
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

### ![03230fb4a3f14cb3909616d8ca2955b6.png][] ###

### Java中的内存分配 ###

Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

–栈 存储局部变量

–堆 存储new出来的东西

–方法区 (面向对象进阶讲)

–本地方法区 (和系统相关)

–寄存器 (给CPU使用)

### Java中一个数组的内存图解 ###

![fa8b694fb4ad4d18b23f2397b5a283a8.jpeg][]

——定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。我们定义一个名称为arr的数组，长度为：3,假设输出地址为：001，我们可知局部变量在栈，new新建的对象在堆，arr的地址指向new创建对象的地址，动态分配的初始值为：0 0 0，arr\[0\]=0;arr\[1\]=0;arr\[2\]=0;我们给数组重新赋值：arr\[0\]=1;arr\[1\]=2;arr\[2\]=3;

**代码演示：**

package com.demo01;
    
    /*
     * 数组：存储同一种数据类型的多个元素的容器
     * 
     * 定义格式：
     * 		A:数据类型[]数组名;	(推荐的方式)
     * 		B:数据类型 数组名[];
     * 
     * 		举例:
     * 			int[] arr; 定义了一个int类型的数组名，数组名是arr
     * 			int arr[]; 定义了一个int类型的变量，变量名是arr数组
     * 
     * 数组初始化
     * A：所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
     * B：数组的初始化方式
     * 	a:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
     * 	b:静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
    
     * 动态初始化
     * 		int [] arr = new int [30];
     */
    public class ArrayDemo {
    	public static void main(String[] args) {
    		//  		int [] arr = new int [30];
    		int[] arr = new int[3];
    		/*
    		 * 左边
    		 * 		int:说明数组的元素类型是 int 类型
    		 * 		[]:这是一个数组
    		 * 		arr:数组的名称
    		 * 
    		 * 右边
    		 * 		new:Ϊ为数组申请内存分配，开辟空间
    		 * 		int:说明数组中的元素类型是int类型
    		 * 		[]：说明这是一个数组
    		 * 		3:数组长度
    		 */
    		
    		//输出数组名字
    		System.out.println("arr:"+arr); //arr:[I@626b2d4a  内存地址
    		//我们获取数组的地址是没有意义的，我要的是数组中的元素值，该怎么办呢？
    		//不用担心，Java已经帮我们想好了
    		//其实数组中每个元素都是有编号的，编号从0开始，最大的编号是数组长度-1
    		//ͨ通过数组名和编号的配合使用我们就可以获取指定编号的元素值ֵ
    		//这个编号的专业叫法：索引
    		//访问格式：数组名[索引]
    		System.out.println("*****************************");
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println("*****************************");
    		//给数组赋值
    		arr[0] = 1;
    		arr[1] = 2;
    		arr[2] = 3;
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

![f4339c4967e9418080510c871761a8dd.png][]

### Java中二个数组的内存图解 ###

![eb86dbc336564362a953823f1a519aab.jpeg][]

——定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。定义两个数组，分别是arr和arr2,长度为：2和3,假设arr输出地址为：001，arr2输出地址为：002，我们可知局部变量在栈，new新建的对象在堆，arr的地址指向new创建对象的地址，动态分配的初始值为：0 0 ，arr\[0\]=0;arr\[1\]=0;我们给数组重新赋值：arr\[0\]=0;arr\[1\]=1;arr2的地址指向new创建对象的地址，动态分配的初始值为：0 0 0，arr\[0\]=0;arr\[1\]=0;arr\[2\]=0;我们给数组重新赋值：arr\[0\]=0;arr\[1\]=1;arr\[2\]=2;

**代码演示：**

package com.demo01;
    /*
     * 定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
     */
    public class ArrayTest2 {
    	public static void main(String[] args) {
    		//定义两个数组
    		int[] arr = new int[2];
    		int[] arr2 = new int[3];
    		
    		//分别输出数组名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    		System.out.println("--------------------");
    		
    		//然后分别给数组中的元素赋值ظ�ֵ
    		arr[1] = 100;
    		
    		arr2[0] = 200;
    		arr2[2] = 300;
    		
    		//再次输出数组名及元素ٴ
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    	}
    }

![58a4d6e679574edfb58e1d80677ded80.png][]

### 两个数组指向同一个地址的内存图解 ###

![2c05b56a253e406a8d9e268b1de75ea0.jpeg][]

—— 定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素,首先我们定义一个arr数组，给arr数组赋值，arr\[0\]=100;arr\[1\]=200;arr\[2\]=300;然后把第一个数组的地址赋值给第二个数组，第二个数组的地址和第一个数组的地址是一样的，他们的值也是一样的，之后给第二个数组赋值，他们的地址都指向同一个地址，他们重新赋值后，他们值应该都是新的重新赋值的值。

**代码演示：**

package com.demo01;
    /*
     * 定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素
     */
    public class ArrayTest3 {
    	public static void main(String[] args) {
    		//定义一个数组
    		int[] arr = new int[3];
    		//赋值ֵ
    		arr[0] = 100;
    		arr[1] = 200;
    		arr[2] = 300;
    		//输出
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println("-----------------------------");
    		//然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组
    		int[] arr2 = arr;
    		//给第二个数组赋值ֵ
    		arr2[0] = 111;
    		arr2[1] = 222;
    		arr2[2] = 333;
    		
    		//再次输出两个数组的名称及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println("-----------------------------");
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    		System.out.println("-----------------------------");
    	}
    }

![0574774c0ae6480c8cb83ecb971f0564.png][]

### 数组操作中两个常见的小问题 ###

**数组索引越界**

–ArrayIndexOutOfBoundsException

–访问到了数组中的不存在的索引时发生。

**空指针异常**

NullPointerException

数组引用没有指向对象，却在操作对象中的元素时。

package com.demo03;
    
    /*
     数组索引越界
    
            –ArrayIndexOutOfBoundsException
    
            –访问到了数组中的不存在的索引时发生。
    
    空指针异常
    
            NullPointerException
    
            数组引用没有指向对象，却在操作对象中的元素时。
     */
    public class ArrayDemo {
    		public static void main(String[] args) {
    			//定义数组
    			int[] arr = {1,2,3};
    			
    			//访问数组元素
    			System.out.println(arr[3]);
    			
    			//引用类型：类，接口，数组
    			//常量：空常量null，是可以赋值给引用类型的
    			arr = null;
    			System.out.println(arr[1]);
    		}
    }

![de7bf02ddfad4241a2908bc5823f58dc.png][]

![1c9cf3e188544201979bdb44914bef62.png][]

**数组练习：**

1.  数组遍历(依次输出数组中的每一个元素)–获取数值长度：数值名.length
2.  数组获取最值(获取数组中的最大值最小值)

练习1：数组遍历(依次输出数组中的每一个元素)–获取数值长度：数值名.length

package com.demo04;
    /*
     * 数组遍历(依次输出数组中的每一个元素)–获取数值长度：数值名.length
     */
    public class ArrayTest {
    	public static void main(String[] args) {
    		//定义一个数组
    		int[] arr = {11,22,33,44,55};
    		
    		//输出
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println(arr[3]);
    		System.out.println(arr[4]);
    		System.out.println("--------");
    		
    		//ͨ通过for循环实现获取数据0-4
    		for(int x=0; x<5; x++) {
    			System.out.println(arr[x]);
    		}
    		System.out.println("--------");
    		
    		//Ϊ为了解决我们去数数组中元素的个数，数组提供了一个属性：length
    		//用于获取数组元素中的个数
    		//格式：数组名.length
    		System.out.println("数组共有"+arr.length+"个");
    		System.out.println("--------");
    		
    		for(int x=0; x<arr.length; x++) {
    			System.out.println(arr[x]);
    		}
    	}
    }

![76132e668eee4cb58d5aef09fa119aed.png][]

练习2： 数组获取最值(获取数组中的最大值最小值)

package com.demo04;
    /*
     * 数组获取最值(获取数组中的最大值最小值)
     */
    public class ArrayTest2 {
    	public static void main(String[] args) {
    		//定义数组
    		int[] arr = {12,45,98,73,60};
    		
    		//定义参照物
    		int max = arr[0];
    		
    		//遍历数组，获取除了0以外的元素，进行比较
    		for(int x=1; x<arr.length; x++) {
    			if(arr[x] > max) {
    				max = arr[x];
    			}
    		}
    		
    		//输出max即可
    		System.out.println("max:"+max);
    	}
    }

![c023a7a30b4e4d129a4ed65903b6250a.png][]

### 二维数组 ###

#### 二维数组概述 ####

–一年级有6个班，可以用数组来存储。一个班有30个学生，这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。

–由此可见：其实二维数组其实就是一个元素为一维数组的数组。

#### 二维数组定义格式 ####

•定义格式

–数据类型\[\]\[\] 数组名;

–数据类型 数组名\[\]\[\]; 不推荐

–数据类型\[\] 数组名\[\]; 不推荐

package com.demo05;
    
    public class ArrayArrayDemo0 {
    
    	public static void main(String[] args) {
    		int[][] a = new int[6][30];
    		int[]   a1[] = new int[6][30];
    		
    		System.out.print("1");
    		System.out.println();
    		System.out.print("2");
    	}
    
    }

•初始化方式

–数据类型\[\]\[\] 变量名 = new 数据类型\[m\]\[n\];

–数据类型\[\]\[\] 变量名 = new 数据类型\[\]\[\]\{ \{ 元素…\},\{ 元素…\},\{ 元素…\}\};

•简化版格式：数据类型\[\]\[\] 变量名 = \{ \{ 元素…\},\{ 元素…\},\{ 元素…\}\};

二维数组的操作

•二维数组遍历

–int\[\]\[\] arr = \{ \{1,2,3\},\{4,5,6\},\{7,8,9\}\};

package com.demo05;
    
    public class ArrayArrayDemo {
    	public static void main(String[] args) {
    		//数据类型[][]数组名={
       {元素…},{元素…},{元素…}};
    		int[][] arr = {
       {1,2,3},{4,5,6},{7,8,9}};
    		
    		System.out.println(arr); 
    		System.out.println(arr[0]); 
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		
    		//如何获取二元数组的元素呢？
    		System.out.println(arr[0][0]);
    		System.out.println(arr[1][1]);
    		System.out.println(arr[2][2]);
    		System.out.println(arr[2][1]);
    	}
    }

![f6914d5deac94c6b82e383280193dca3.png][]

练习：二维数组的遍历

package com.demo05;
    
    public class ArrayArrayTest {
    	public static void main(String[] args) {
    		//二维数组遍历
    		int[][] arr = {
       {1,2,3},{4,5,6},{7,8,9}};
    		
    
    		for(int i = 0;i<arr.length;i++) {
    			for(int j = 0;j<arr[i].length;j++) {
    				System.out.print(arr[i][j]+" ");
    			}
    			System.out.println();
    		}
    	}
    }

![bae3fa98deff413bbf9725a78a5407d8.png][]

[03230fb4a3f14cb3909616d8ca2955b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4d9e92cb340a4604a90c1e6720e9c58d.png
[fa8b694fb4ad4d18b23f2397b5a283a8.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d0eaa4727f3d409383e9d7ad75f33b69.png
[f4339c4967e9418080510c871761a8dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/368887f6e320498698225114c39aa488.png
[eb86dbc336564362a953823f1a519aab.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/aa187706a8e54023ad7db1ca9b6d1c8a.png
[58a4d6e679574edfb58e1d80677ded80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0e24b82fb90b409f8465567ebf328a8c.png
[2c05b56a253e406a8d9e268b1de75ea0.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e1f0aa4debcb4a5ebf1aae23fccd22a3.png
[0574774c0ae6480c8cb83ecb971f0564.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e5a77c669b98461daedd4dad3cd141bc.png
[de7bf02ddfad4241a2908bc5823f58dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9fcc5a608385492898c8ebd22311af28.png
[1c9cf3e188544201979bdb44914bef62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8bc4d3803dae4fdab9e652b0384a31c6.png
[76132e668eee4cb58d5aef09fa119aed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f59d52c8b5ca4adba1d7cd2c16b1a5e3.png
[c023a7a30b4e4d129a4ed65903b6250a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f0e1553ae48040f5a7eb42a16c5b36b9.png
[f6914d5deac94c6b82e383280193dca3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/cd4c741d49564cafa1d786977270961b.png
[bae3fa98deff413bbf9725a78a5407d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8cf8488db44d40ddb8365b93ed016c60.png