数组

数组

​ 举个例子，假如一个班有30个学生，每个学生都需要记录成绩。如果我们定义30个变量来保存成绩，就会很麻烦。当我们需要记录比较多同种类的数据的时候，使用变量去一个个记录工程量很大，这时候我们就可以通过数组去解决这个问题。

​ 数组是存储一组相同数据类型的数据（变量）的一个变量。

数组的概念

​ 数组包括5个基本要素：

​ 1、标识符。也可以叫做数组名，类似于变量中的变量名。

​ 2、数组元素。一个数组是由多个相同数据类型的数据组成的，里面每一个数据都是一个数组元素。

​ 3、数组长度。一个数组中一共有多少个数据，这个数组的数组长度就为多少。

​ 4、元素下标。数组中的每个元素都有按排序进行编号，这个编号是从0开始，到数组长度-1为止，这种编号叫做元素下标。

​ 5、元素类型。我们在声明数组的时候，数组是什么数据类型，那数组里的所有元素就必须是和数组相同的数据类型。

定义数组

​ 在程序中去定义一个数组，通常分为4个步骤：

1、声明数组。

​ 声明数组的语法有两种格式，分别为：

​ 数据类型[] 数组名;

或 数据类型 数组名[];

​ 两种格式都是可以使用的，但通常规范上提倡使用第一种，也就是 数据类型[] 数组名;

例如：

​ int[] scores;

​ int scores[];

​ Srting[] names;

2、分配空间。

​ 确定数组中一共有多少个数据,例如：

​ scores = new int[30];

​ avgAge= new int[6];

​ names= new String[30];

​ 分配完空间后，里面每个数据都会有个默认初始值。如果是整型的数组，里面所有元素初始值都为0;浮点型的数组，里面所有元素的初始值都为0.0；如果是字符串类型的数组，里面所有元素的初始值都为null。

​ 声明数组和分配空间可以合在一步完成，语法格式为：

​ 数据类型[] 数组名 = new 数据类型[个数];

例如：

​ int[] scores = new int[5];

数组在内存空间中的表现：

3、元素赋值。

​ （1）我们可以在声明数组的同时，给数组里的元素赋值。有两种格式，

例如： int[] scores ={89,79,76};

​ int[] scores = new int[]{89,79,76};

​ 这两种边声明边赋值的语法作用是相同的。在列出数据的同时，也已经确定了这个数组的长度，后续是无法再增加数组个数的，并且在第二种语法中，后面加了大括号和数值，大括号前面的中括号[]里就不能再写数组的长度了，否则就会报错。

​ （2）动态录入信息并赋值。这种方法用的比较多。可以通过循环的方式完成动态录入过程。

例如：

			Scanner input = new Scanner(System.in);
			for(int i=0;i<=30;i++){
				scores[i] = input.nextInt();
			}

4、处理数据。

​ 定义完数组后，就可以使用数组中的数据进行运算了。

例如： a[0] = a[0] * 10;

或者通过增强型for循环（foreach）来遍历数组，完成一些特定功能。

			for(int score : scores){
				sum += score;
			}

数组下标越界

​ 我们定义一个数组，他的元素下标是从0开始，到数组长度-1为止，在运用数组元素的时候，如果出现元素下标超出了数组元素下标范围的情况，程序就会报错，出现ArrayIndexOutOfBoundsException一长串的英文，表示的是数组的下标越界了。

​ 比如我们定义了一个长度为3的数组int[] scores = new int[3]

​ score[2] = 5;

​ score[3] = 8;

​ 这里score[3]就是一个数组下标越界的情况，这个数组中只有score[0]、score[1]、score[2]三个元素。

在数组中插入一个元素

​ 在已经定义好的一个数组中，我们要在其中插入一个新的数据，是通过将数组中插入点开始的每一个原有数据，分别向后或者说向右平移一个位置，然后再在插入点插入新的数据来完成的。这个平移的过程，是通过循环来实现的。

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int[] scores= {99,85,82,63,60,0};
		System.out.println("请输入要插入的成绩:");
		int score = scan.nextInt();
		int index = -1;
		for(int i=0;i<scores.length;i++) {
			if(score>scores[i]) {
				index =i;
				break;
			}
		}
		for(int i=scores.length-1;i>index;i--) {
			scores[i]=scores[i-1];
		}
		scores[index]=score;
		System.out.println("插入成绩后的成绩排序为:");
		for(int a : scores) {
			System.out.print(a+"\t");
		}
	}

​ 以上是在一个降序排列的数组中，插入一个数据，并使其在插入后依然为降序排列的例子。

冒泡排序

​ 如果有一个乱序的数组，我们要对其进行升序或降序排列，就要用到排序算法。排序算法有冒泡排序、选择排序，还有查找元素用的二分（折半）查找法。这里讲一下冒泡排序。

​

		int[] nums = {55,77,99,66,33,88,22};
		int temp =0;
		for(int i=0;i<nums.length-1;i++){
			for(int j=0;j<nums.length-i-1;j++){
				if(nums[j]>nums[j+1]){
					temp = nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
				}
			}
		}
		for(int a :nums){
			System.out.print(a+"\t");
		}

​ 以上为冒泡排序的过程。冒泡排序的原理就是把一个数组里的元素，两两之间进行对比，把两者之间大的数移到右边（升序），或把小的数移到右边（降序），一轮比较完后，最大或最小的数就到了数组的最后面，再把前面的数再进行一轮两两对比，直到排好序。这个过程通过两层for循环嵌套实现。外层循环的循环次数为N-1次，内层循环的循环次数为N-i-1次。

​ 除了两两元素相互比较外，还可以把第一个元素和后面所有元素依次比较，来把其中的最大值或最小值交换到第一个位置来，然后再拿第二个值和后面的数值依次循环比较。

		int[] nums = {55,77,99,66,33,88,22};
		int temp =0;
		for(int i=0;i<nums.length-1;i++){
			for(int j=i+1;j<nums.length;j++){
				if(nums[i]>nums[j]){
					temp = nums[j];
					nums[j]=nums[i];
					nums[i]=temp;
				}
			}
		}
		for(int a :nums){
			System.out.print(a+"\t");
		}

Arrays类

​ java中为我们提供了一些数组运算的方法。通过Arrays点出后面的方法，就能便捷的对数组进行运算了。

1、equals(array1,array2)

​ 这种方法的返回值类型为boolean类型。

​ 用于比较array1和array2两个数组是否相等。

​ 语法为： boolean a = Arrays.equals(array1,array2);

​ 其结果为布尔值。true为相等，false为不相等。

2、sort(array)

​ 这种方法的返回值类型为void，即没有返回值。

​ 用来对数组array中的元素进行升序排列。

​ 语法为：Arrays.sort(array);

​ 如果需要进行降序排列，只需要用for循环将数组元素倒过来输出即可。

3、toString(array)

​ 这种方法的返回值类型为String类型。

​ 用来将一个数组array转换成一个字符串。

​ 语法为：String a = Arrays.toString(array);

​ 例如：数组int[] nums ={10,30,40,50};

​ String a = Arrays.toString(nums);

​ 输出a的结果就为[10,30,40,50]

4、fill(array,val)

​ 这种方法的返回值类型为void，即没有返回值。

​ 用来把数组array中的所有元素都赋值成val。

​ 语法为：Arrays.fill(array,val);

​ 例如: 数组int[] nums ={10,30,40,50};

​ Arrays.fill(nums,40);

​ 数组nums中的元素就变为{40,40,40,40}

5、copyOf(array,length)

​ 这种方法的返回值类型与所赋值的数组的数据类型相同。

​ 用来把数组array复制成一个长度为length的新数组。

​ 语法为：<数据类型>[] array2 = Arrays.copyOf(array1,length);

​ 例如: int[] num2 = Arrays.copyOf(num1,5);

​ 新的数组num2的数组长度就为5.

6、binarySearch(array,val)

​ 这种方法的返回值类型为int类型。

​ 用来查询元素值val在数组array中的下标，但要求数组array中的元素已经经过排序。如果数组没排序或找不到这个元素，则返回随机负数。

​ 语法：int index = Arrays.binarySearch(array,val);

​ 例如：Arrays.sort(nums);

​ int index=Arrays.binarySearch(nums,50);

二维数组

​ Java中定义和操作多维数组的语法与一维数组类似，但实际应用中，三维以上的数组很少使用，主要是使用二维数组。在语法上Java支持多维数组，但从内存分配原理的角度讲，只有一维数组。因为二维及多维数组里的元素同样是数组，而层层下来元素其实就是一维数组。

​ 定义二维数组的格式有两种，和一维数组相似：

​ 1、<数据类型>[] 数组名；

​ 2、<数据类型> 数组名[];

​ 两种语法都可以使用，但通常规范上建议使用第1种语法。

​ 定义二维数组的过程同样也有声明数组、分配空间、元素赋值和处理数据这四部分，但声明二维数组时，必须要定义最大维度，即第一个[]里面的数组长度，后面的[]里的元素数组长度在定义二维数组的时候可不写。

​ 例如：

		int[][] scores = new int[5][50];
		int[][] scores = new int[5][];

​ 二维数组的数组长度为左边[]中的数字，右边[]中的数字为二维数组中的一维数组的数组长度。但是不能只写右边[]里的数字而不写左边[]里的数字，例如：

		int[][] scores = new int[][50];
		int[][] scores = new int[][];

​ 这两种写法是不被允许的，会报错。

​ 而定义并赋值的写法也与一维数组类似：

​ 写法1：

		int[][] scores=new int[][]{{90,85,92,78,54},{76,63,80},{87}};

​ 写法2：

		int[][] scores={{90,85,92,78,54},{76,63,80},{87}};

​ 两种写法都是可以的，而且可以看到，二维数组中的元素（一维数组）的数组长度并不是全都一样的，也可以不相同。

​ 以下为二维数组使用案例：

​

		int[][]scores =new int[3][5];
		Scanner scan = new Scanner(System.in);
		for(int i=0;i<scores.length;i++) {
			System.out.println("**********第"+(i+1)+"个班**********");
			for(int j=0;j<scores[i].length;j++) {
				System.out.print("请输入第"+(j+1)+"个同学的成绩:");
				scores[i][j]=scan.nextInt();
			}
		}
		System.out.println("*********成绩统计*********");
		for(int i=0;i<scores.length;i++) {
			int total =0;
			for(int j=0;j<scores[i].length;j++) {
				total+=scores[i][j];
			}
			System.out.println((i+1)+"班总成绩为："+total);
		}

输出结果如图所示：