数组的定义及使用

本章目标
掌握数组的作用
掌握数组的声明及内存分配
通过数组的简单范例加深数组操作的理解
掌握多维数组的定义及使用

 

数组
数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组。
数组的优点：
——不使用数组定义100个整型变量：int i1;int i2;…int i100
——使用数组定义：int i[100]

 

一维数组
一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。
要使用Java的数组，必须经过两个步骤：（1）声明数组、（2）分配内存给该数组。这两个步骤的语法如下：
——声明形式一：
————声明一维数组：数据类型 数组名[] = null ;
————分配内存给数组：数组名 =  new 数据类型[长度] ;
——声明形式二：
————声明一维数组：数据类型[] 数组名= null ;

 

声明一维数组
数组的声明格式里，“数据类型”是声明数组元素的数据类型，常见的类型有整型、浮点型与字符型等。
“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议读者使用有意义的名称为数组命名。
数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中配置数组所需的内存，其中“长度”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。

 

声明及开辟数组空间
声明数组：
int score[] = null ;   —> null表示引用数据类型的默认值

 

为数组开辟空间：
score = new int[3];

 

堆栈内存的解释
数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内存空间数组是永远无法使用的，必须有指向的堆内存才可以使用，要想开辟新的堆内存则必须使用new关键字，之后只是将此堆内存的使用权交给了对应的栈内存空间，而且一个堆内存空间可以同时被多个栈内存空间指向，即：一个人可以有多个名字，人就相当于堆内存，名字就相当于栈内存

 

声明数组的同时分配内存空间
声明数组的同时分配内存：
——数据类型  数组名[] = new 数据类型[个数]
——int score[] = new int[10] ;
————声明一个元素个数为10的整型数组score，同时开辟一块内存空间供其使用
————在Java中，由于整数数据类型所占用的空间为4个bytes，而整型数组score可保存的元素有10个，所以上例中占用的内存共有4 * 10 = 40个字节

 

数组中元素的表示方法
想要访问数组里的元素，可以利用索引来完成。Java的数组索引编号由0开始，以一个的score[10]的整形数组为例，score[0]代表第1个元素，score[1]代表第2个元素，score[9]为数组中第10个元素（也就是最后一个元素）。

 

数组的声明及输出

public class ArrayDemo01 {
	public static void main(String[] args) {
		int score[] =null;//声明数组，但未开辟堆内存空间
		score = new int[3];//为数组开辟堆内存空间
		System.out.println("score[0] = "+score[0]);//分别输出每个元素
		System.out.println("score[1] = "+score[1]);//分别输出每个元素
		System.out.println("score[2] = "+score[2]);//分别输出每个元素
		for(int x=0; x<score.length; x++){//使用循环依次输出数组中的全部内容
			System.out.println("score["+ x +"] = "+score[x] );
		}
	}
/*结果：
 * score[0] = 0
 * score[1] = 0
 * score[2] = 0
 * score[0] = 0
 * score[1] = 0
 * score[2] = 0
 * */
}

 

访问注意
程序中可以发现，对于数组的访问采用“数组名称[下标]”的方式，之前一共开辟了三个空间大小的数组，所以下标的取值是0~2，假设程序中取出的内容超过了这个下标，如“score[3]”，则程序运行的时候会出现以下的错误提示：
java.lang.ArrayIndexOutOfBoundsException: 3

 

为数组中的元素赋值并进行输出

public class ArrayDemo02 {
	public static void main(String[] args) {
		int score[] =null;//声明数组，但未开辟堆内存空间
		score = new int[3];//为数组开辟堆内存空间，大小为3
		for(int x=0; x<3; x++){//为数组中的每个元素赋值
			score[x] = x*2+1;//为每一个元素赋值
		}
		for(int x=0; x<score.length; x++){//使用循环依次输出数组中的全部内容
			System.out.println("score["+ x +"] = "+score[x] );
		}
	}
/*结果：
 * score[0] = 1
 * score[1] = 3
 * score[2] = 5
 * */
}

 

代码及内存分析 —— I

 

代码及内存分析 —— II

 

代码及内存分析 —— III

 

取得数组长度
要特别注意的是，在Java中取得数组的长度（也就是数组元素的长度）可以利用“数组名称.length”完成，如下面的格式：
数组名称.length   —>  返回一个int型数据

public class ArrayDemo03 {
	public static void main(String[] args) {
		int score[] = new int[3];//声明并实例化数组
		System.out.println("数组长度为 ：" + score.length);//求出数组长度
	}
/*结果：
 * 数组长度为 ：3
 * */
}

 

数组的静态初始化
数组的内容分为动态初始化和静态初始化两种，之前所讲解的全部代码读者可以发现是采用先声明数组之后为数组中的每个内容赋值的方式完成的。那么也可以通过数组静态初始化在数组声明时就指定其具体内容。
如果想直接在声明时就给数组赋初值，可以利用大括号完成。只要在数组的声明格式后面再加上初值的赋值即可，如下面的格式：
数据类型 数组名[] = {初值0 , 初值1 , … , 初值n}

 

数组的静态初始化

public class ArrayDemo04 {
	public static void main(String[] args) {
		int score[] = {91,92,93,94,95,96};//使用静态初始化声明数组
		for(int x=0; x<score.length; x++){//循环输出
			System.out.println("score["+ x +"] = "+score[x] );
		}
	}
/*结果：
 * score[0] = 91
 * score[1] = 92
 * score[2] = 93
 * score[3] = 94
 * score[4] = 95
 * score[5] = 96
 * */
}

 

数组应用范例 —— 求出数组中的最大和最小值

public class ArrayDemo05 {
	public static void main(String[] args) {
		int score[] = {67,89,97,68,90,100,75,90};//静态初始化数组
		int max=0;//定义变量保存最大值
		int min=0;//定义变量保存最小值
		max = min= score[0];//把第 1 个元素的内容赋值给 max 和 min
		for(int x=0; x<score.length; x++){//循环求出最大和最小
			if(score[x] > max){//依次判断后续元素是否比 max 大
				max = score[x];//如果大，则修改 max 内容
			}
			if(score[x] < min){//依次判断后续元素是否比 min 小
				min=score[x];//如果小，则修改 min 内容
			}
		}
		System.out.println("最高成绩："+max);//输出最大值
		System.out.println("最低成绩："+min);//输出最小值
	}
/*结果：
 * 最高成绩：100
 * 最低成绩：67
 * */
}

  

 

对整型数组按照由小到大的顺序进行排列

public class ArrayDemo06 {
	public static void main(String[] args) {
		int score[] = {67,89,97,68,90,100,75,90};//声明数组
		for(int i=1; i<score.length; i++){//循环判断 
			for(int j=0; j<score.length; j++){
				if(score[i]<score[j]){//交换位置 
					int temp = score[i];
					score[i] = score[j];
					score[j] = temp;
				}
			}
		}
		System.out.print("由小到大的顺序进行排列：");//打印信息
		for(int i=0; i<score.length; i++){//数组输出
			System.out.print(score[i] +"、");
		}
	}
/*结果：
 * 由小到大的顺序进行排列：67、68、75、89、90、90、97、100、
 * */
}

 

二维数组
如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。

 

二维数组声明的方式和一维数组类似，内存的分配也一样是用new这个关键字。其声明与分配内存的格式如下所示：
——动态初始化：
————数据类型  数组名[][] ;
————数组名 = new 数据类型[行的个数][列的个数] ;
——动态初始化：
————数据类型 数组名[][] = new 数据类型[行的个数][列的个数] ；

 

二维数组的存储
声明整型数组score，同时为其开辟一块内存空间
——int score[][] = new int[4][3] ;
——整型数据score可保存的元素有4*3 = 12个，而在Java中，int数据类型所占用的空间为4个字节，因此该整型数组占用的内存共为4*12 = 48个字节

 

二维数组的定义及使用

public class ArrayDemo08 {
	public static void main(String[] args) {
		int score[][] = new int[4][3];//声明并实例化二维数组
		score[0][1] = 30;//为数组中的部分内容赋值
		score[1][0] = 31;//为数组中的部分内容赋值
		score[2][2] = 32;//为数组中的部分内容赋值
		score[3][1] = 33;//为数组中的部分内容赋值
		score[1][1] = 30;//为数组中的部分内容赋值
		for(int i=0; i<score.length; i++){//外层循环行
			for(int j=0; j<score[i].length; j++){//内层循环列
				System.out.print(score[i][j]+"、");
			}
			System.out.println("");//换行
		}
		
	}
/*结果：
 * 0、30、0、
 * 31、30、0、
 * 0、0、32、
 * 0、33、0、
 * */
}

 

二维数组静态初始化
格式：
——数据类型 数组名[][] = {  {第0行初值},{第1行初值}，…{第n行初值},};
声明二维数组：
——int score[][] = { { 67, 61 }, { 78, 89, 83 }, { 99, 100, 98, 66, 95 } };

 

使用静态初始化声明一个二维数组

public class ArrayDemo09 {
	public static void main(String[] args) {
		//静态初始化一个二维数组，每行的数组元素个数不一样
		int score[][] = {{67 , 61},{78, 89, 83}, {99,100,98,66,95},{10}};
		for(int i=0; i<score.length; i++){//外层循环行
			for(int j=0; j<score[i].length; j++){//内层循环列
				System.out.print(score[i][j]+"、");//输出每一个元素
			}
			System.out.println("");//换行
		}
		
	}
/*结果：
 * 67、61、
 * 78、89、83、
 * 99、100、98、66、95、
 * 10、
 * */
}

 

多维数组
经过前面一、二维数组的练习后不难发现，想要提高数组的维数，只要在声明数组的时候将索引与中括号再加一组即可，所以三维数组的声明为int score[][][]，而四维数组为int score[][][][] …，以此类推。

 

定义和使用三维数组

public class ArrayDemo10 {
	public static void main(String[] args) {
		//静态初始化一个三维数组，使用静态初始化的方式
		int score[][][] = {{{5,1},{6,7},{9,4},{8,3}}};
		for(int i=0; i<score.length; i++){//第 1 层循环
			for(int j=0; j<score[i].length; j++){//第 2 层循环
				for(int k=0; k<score[i][j].length; k++){//第 3 层循环
					//输出每一个元素
					System.out.println("score["+i+"]["+j+"]["+k+"]="+score[i][j][k]);
				}
			}
		}
		
	}
/*结果：
 * score[0][0][0]=5
 * score[0][0][1]=1
 * score[0][1][0]=6
 * score[0][1][1]=7
 * score[0][2][0]=9
 * score[0][2][1]=4
 * score[0][3][0]=8
 * score[0][3][1]=3
 * */
}