一、数组的定义

在Java数组中可以使用下面的两种方式来定义,效果都是一样的

1、int[] x = new int[10];

2、int[] x;
x = new int[10];

上述语句相当于在内存中定义了10个int类型的变量,第一个变量名称为x[0],第二个变量名称为x[1].......以此类推,第十个变量名称为x[9],这些变量的初始值都是0。上面两种方式可根据自己的需求来选择使用哪种方法。

1、下面我们就通过实例来了解一下如何创建数组以及访问数组中的元素吧,代码如下:

package com.java.exercise.code;

public class WhatIsMethod5 {
	public static void main (String[] args){
		int[] arr = new int[4];   //创建数组对象
		System.out.println("arr[0]=" + arr[0]);   //访问第一个元素
		System.out.println("arr[1]=" + arr[1]);   //访问第二个元素
		System.out.println("arr[2]=" + arr[2]);   //访问第三个元素
		System.out.println("arr[3]=" + arr[3]);   //访问第四个元素
		System.out.println("数组的长度为:" + arr.length);   //打印数组长度
	}
}

运行结果如下

Java数组插图

2、元素的默认值

数据类型默认初始化值
byte、short、int、long0
float、double0.0
char一个空字符,即'\u0000'
booleanfalse
引用数据类型null,表示变量不引用任何对象

3、在很多时候我们使用数组时,是不会使用这些默认值的,下面我们看一下为数组元素赋值的实例吧,代码如下:

package com.java.exercise.code;

public class WhatIsMethod6 {
	public static void main(String[] args) {
		byte[] arr1 = new byte[2]; //定义一个可以存储2个元素的字节型的数组
		arr1[0] = 5;
		//依次打印数组中每个元素的值
		System.out.println("byte类型数组arr1[0]=" + arr1[0]);
		System.out.println("byte类型数组arr1[1]=" + arr1[1]);
		
		short[] arr2 = new short[2]; //定义一个可以存储2个元素的短整型的数组
		arr2[0] = 6;
		//依次打印数组中每个元素的值
		System.out.println("short类型数组arr2[0]=" + arr2[0]);
		System.out.println("short类型数组arr2[1]=" + arr2[1]);
		
		int[] arr3 = new int[2]; //定义一个可以存储2个元素的整型的数组
		arr3[0] = 7;
		//依次打印数组中每个元素的值
		System.out.println("int类型数组arr3[0]=" + arr3[0]);
		System.out.println("int类型数组arr3[1]=" + arr3[1]);
		
		long[] arr4 = new long[2]; //定义一个可以存储2个元素的长整型的数组
		arr4[0] = 8;
		//依次打印数组中每个元素的值
		System.out.println("long类型数组arr4[0]=" + arr4[0]);
		System.out.println("long类型数组arr4[1]=" + arr4[1]);
		
		float[] arr5 = new float[2]; //定义一个可以存储2个元素的单精度浮点型的数组
		arr5[0] = 9;
		//依次打印数组中每个元素的值
		System.out.println("float类型数组arr5[0]=" + arr5[0]);
		System.out.println("float类型数组arr5[1]=" + arr5[1]);
		
		double[] arr6 = new double[2]; //定义一个可以存储2个元素的双精度浮点型的数组
		arr6[0] = 10;
		//依次打印数组中每个元素的值
		System.out.println("double类型数组arr6[0]=" + arr6[0]);
		System.out.println("double类型数组arr6[1]=" + arr6[1]);
		
		char[] arr7 = new char[3]; //定义一个可以存储3个元素的数据型的数组
	        arr7[0] = 'c';
	        arr7[1] = '中';
		//依次打印数组中每个元素的值
		System.out.println("char类型数组arr7[0]=" + arr7[0]);
		System.out.println("char类型数组arr7[1]=" + arr7[1]);
		System.out.println("char类型数组arr7[2]=" + arr7[2]);
		
		boolean[] arr8 = new boolean[2]; //定义一个可以存储2个元素的布尔型的数组
		arr8[0] = true;
		//依次打印数组中每个元素的值
		System.out.println("boolean类型数组arr8[0]=" + arr8[0]);
		System.out.println("boolean类型数组arr8[1]=" + arr8[1]);
	}
}

运行结果如下

Java数组插图(1)

4、在定义数组时只指定数组的长度,由系统自动为元素赋初始值的方式称为动态初始化,在初始化数组时还有一种方式叫做静态初始化,就是在定义数组是还有一种方式称为静态初始化,就是咋在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式,具体格式如下:

1、类型[] 数组名 = new 类型[] {元素1,元素2,......};
2、类型[] 数组名 = {元素1,元素2,......};

下面我们看一下实例吧,代码如下

package com.java.exercise.code;

public class WhatIsMethod7 {
	public static void main(String[] args) {
		int[] arr = {7,9,2,11,6};  //静态初始化
		//依次访问数组中的元素
		System.out.println("arr[0]=" + arr[0]);
		System.out.println("arr[1]=" + arr[1]);
		System.out.println("arr[2]=" + arr[2]);
		System.out.println("arr[3]=" + arr[3]);
		System.out.println("arr[4]=" + arr[4]);
	}
}

运行结果如下

Java数组插图(2)

5、每个数组的索引都有一个范围,即0~length-1,在访问数组元素时,索引不能超出这个范围,否则程序会报错,如图:

Java数组插图(3)
Java数组插图(4)

6、在使用变量引用一个数组时,变量必须指向一个有效的数组对象,如果该变量的值为null,则意味着没有指向任何数组,此时通过该变量访问数组的元素会出现空指针异常,接下来通过实例来演示一下,如图;

Java数组插图(5)
Java数组插图(6)

二、数组的常见操作

1、数组遍历

我么你在操作数组的时候,有时候会需要访问数组中的每一个元素,这种操作称之为数组的遍历,接下来我们用for循环遍历数组,代码如下:

package com.java.exercise.code;

public class WhatIsMethod7 {
	public static void main(String[] args) {
		int[] arr = {8,2,11,9,6,1,3,};  //定义数组
		for(int i = 0; i < arr.length; i++){
                        //通过索引访问元素
			System.out.println(arr[i]);
		}
	}
}
Java数组插图(7)

2、数组最值

我们在编程的时候,需要得到数组中元素的最值(最大值或最小值),下面我们通过获取最大值作为实例,代码如下:

package com.java.exercise.code;

public class WhatIsMethod8 {
	public static void main(String[] args) {
		int[] arr = {7,11,5,9,8,4};  //定义数组
		int max = getMax(arr);   //调用获取元素最大值的方法
		System.out.println("arr数组中最大值为:" + max); //打印最大值
	}
	static int getMax(int[] arr){
		int max = arr[0];//定义变量max记住最大数,首先假设第一个元素为最大值
		//通过for循环遍历数组
		for(int i = 0; i < arr.length; i++){
			if(arr[i] > max){  //比较arr[i]的值是否大于max
				max = arr[i];  //条件成立就将arr[i]的值赋给max
			}
		}
		return max;
	}
}

运行结果如下

Java数组插图(8)

getMax()方法用于求数组中的最大值,该方法中定义了一个临时变量max,用于记住数组的最大值,首先假设数组中第一个元素arr[0]为最大值,然后使用for循环对数组进行遍历,在遍历的过程中,只要遇到比max的值还大的元素是,就将该元素赋值给max,这样一来变量max就能够在循环结束时记住数组中的最大值。需要注意的是,for循环中的变量i是从1开始的,这样写的原因是程序以及假设第一个元素为最大值,for循环只需要从第二个元素开始比较,从而提高程序的运行效率。

3、数组排序

在操作数组时,经常需要读数组中的元素进行排序。下面介绍一种较为常见的排序算法-----冒泡排序,在冒泡排序过程中,不断的比较数组中相邻的两个元素,较小者向上浮,整个过程和水中气泡上升的原理相似。

下面是冒泡排序的几个步骤,如下:

第一步,从第一个元素开始,将相邻的两个元素依次进行比较,知道最后两个元素完成比较。如果前一个元素比后一个元素大,则交换他们的位置,整个过程完成后,数组中最后一个元素自然就是最大值,这样也就完成了第一轮比较。

第二步,除了最后一个元素,将剩余的元素继续进行两两比较,过程与第一步相似,这样就可以将数组中第二大的数放在倒数第二个位置了。

第三步,以此类推,持续对越来越少的元素重复上面的步骤,直到没有任何一对元素需要比较为止。

下面我们通过实例,来感受一下冒泡排序吧,代码如下:

package com.java.exercise.code;

public class WhatIsMethod9 {
	public static void main(String[] args) {
		int[] arr = {15,2,9,7,23,5,8};
		System.out.print("冒泡排序前:");
		printArray(arr);
		bubbleSort(arr);
		System.out.print("冒泡排序后:");
		printArray(arr);
	}
	//定义打印数组元素的方法
	public static void printArray(int[] arr){
		//循环遍历数组中的元素
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + " "); //打印元素和空间作为间隔
		}
		System.out.print("\n");
	}
	//定义对数组排序的方法
	public static void bubbleSort(int[] arr){
		//定义外层循环
		for(int i = 0; i < arr.length - 1; i++){
			//定义内层循环
			for(int j = 0; j < arr.length-i-1; j++){
				if(arr[j] > arr[j+1]){ // 比较相邻的两个元素
					//根据情况交换两个元素位置
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			System.out.print("第" + (i+1) + "论排序后:");
			printArray(arr); //每轮比较结束打印数组元素
		}
	}
}

运行结果如图

Java数组插图(9)

三、多维数组

在程序中可以通过一个数组来保存某个班级学生的考试成绩,试想一下,如果要统计一个学校各个班级学生的考试成绩,又该如何实现呢?这时我们可以用到多维数组了,多维数组可以简单地理解为在数组中嵌套数组,在程序中比较常见的就是二维数组了,下来我们通过实例来了解一下多维数组吧!

以下是三种方式:

第一种方式,格式如下:

int[][] arr = new int[3][4];

上面的代码相当于定义了一个3*4的二维数组,即二维数组的长度为3,每个二维数组中的元素又是一个长度为4的数组,通过下面的图片来表示这种情况,如图

Java数组插图(10)

第二种方式,格式如下:

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

第二种方式和第一种方式类似,只是数组中每个元素的长度不定,下图来表示这种情况,如图

Java数组插图(11)

第三种方式,格式如下:

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

上面的二维数组中定义了3个元素都是数组,分别{1,2}、{3,4,5}、{6,7,8,9},下面我们还是用图来表示这种情况吧,如图

Java数组插图(12)

我们通过一个具体实例来深入了解一下二维数组的使用吧,列如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额,代码如下:

package com.java.exercise.code;

public class WhatIsMethod10 {
	public static void main(String[] args) {
		int [][] arr = new int[3][];  //定义一个长度为3的二维数组
		//为数组的元素赋值
		arr[0] = new int[] {11,12}; 
		arr[1] = new int[] {21,22,23};
		arr[2] = new int[] {31,32,33,34};
		//定义变量记录总销售额
		int sum = 0;
		//遍历数组元素
		for(int i = 0; i < arr.length; i++){
			//定义变量记录小组销售总额
			int groupSum = 0;
			//遍历小组内每个人的销售额
			for(int j = 0; j < arr[i].length; j++){
				groupSum = groupSum + arr[i][j];
			}
			//累加小组销售额
			sum = sum + groupSum;
			System.out.println("第" + (i+1) + "小组销售额为:" + groupSum + "万元。");
		}
		System.out.println("总销售额为:" + sum + "万元。");
	}
}

运行结果如下

Java数组插图(13)

在以上代码中定义了一个长度为3的二维数组,并且在后面为每个元素赋值,在代码中还定义了两个变量sum和groupSum,其中,sum用来记录公司的总销售额,groupSum用来记录每个销售小组的销售额。当通过嵌套for循环统计销售额时,外层循环读三个销售小组进行遍历,内层循环对每个小组员工的销售额进行遍历。内层循环每循环一次就相当于将一个小组员工的销售额加到本小组的销售总额groupSum中,内层循环结束,相当于本小组销售总金额计算完毕,把groupSum的值与sum的值相加赋给sum。当外层循环结束时,三个销售小组的销售总额groupSum都累加到sum中,即统计出了整个公司的销售总额。

你也可能喜欢