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

目录

数组概述

数组定义格式

数组概念

数组的定义格式

数组的初始化

数组初始化概述

数组的初始化方式

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]);
	}
}

Java中的内存分配

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

        –栈 存储局部变量

        –堆 存储new出来的东西

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

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

        –寄存器 (给CPU使用)

Java中一个数组的内存图解

——定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。我们定义一个名称为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]);
	}
}

 Java中二个数组的内存图解

 ——定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。定义两个数组，分别是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]);
	}
}

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

—— 定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素,首先我们定义一个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("-----------------------------");
	}
}

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

数组索引越界

        –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]);
		}
}

数组练习： 

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]);
		}
	}
}

练习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);
	}
}

二维数组 

二维数组概述

        –一年级有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]);
	}
}

 

练习：二维数组的遍历

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();
		}
	}
}