10.java数组

数组介绍

数组的概念：

具有相同数据类型的一系列数据的集合。

其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的容器。

数组的特点

1. 数组是一种引用数据类型。
2. 数组当中有多个数据，数据类型必须统一。
3. 数组一旦创建，长度不可更改。因此无法新增元素，也无法删除元素。
4. 数组的下标(索引)从0开始，数组最大下标=数组长度-1。

数组的初始化

在内存中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

1. 动态初始化（直接指定数组的长度）
2. 静态初始化（指定该数组的内容）

动态初始化的格式：
数据类型 [ ] 数组名称 = new 数据类型 [ 数组长度 ] ;
解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型。
左侧的中括号[ ]：代表定义的是一个数组
左侧的数组名称：给数组起的名字
右侧的new：代表创建数组的动作
右侧的数据类型：必须和左边的数据类型保持一致
右侧数组长度：也就是定义的数组到底可以保存多少个数据，是一个int数字。
静态 初始化的格式：
数据类型 [ ] 数组名称 = new 数据类型 [ ] { 元素1,元素2…};
静态初始化的省略格式：
数据类型[ ] 数组名称 = {元素1,元素2…};
注意事项：

1. 静态初始化虽然没有直接指定长度，但是仍然会自动推算到长度。
2. 静态初始化的标准格式可以拆分成两个步骤，

int [] arrayB;
arrayB = new int []{1,2,3};

3. 动态初始化可以拆分成两个步骤：

int [] arrayC;
arrayC = new int [5];

4. 静态初始化一旦使用省略格式，就不能拆分成两个步骤了。

使用建议：
如果不确定数组当中的具体内容，使用动态初始化；已经确定了具体的内容，用静态初始化。

数组的使用

获取数组的长度

我们可以使用数组的属性length获取数组的长度
格式：

数据类型 变量名 = 数组名.length ;

例如:

int len= array.length;

获取数组中的元素

格式：

数据类型 变量名 = 数组名[数组下标];

数组下标： 也叫索引值，就是一个int数字，代表数组当中元素的编号。索引值从0开始，一直到"数组长度-1"为止。
注意： 直接打印数组名称，得到的是数组对应的内存地址哈希值，而不是数组中元素的值。

例如：

//可以直接输出。
int[ ] array= {1,2,3};
System.out.println(array[2]);
//也可以先定义一个变量，用来接收array[2]的值，再进行输出。
int e = array[2];
System.out.println(array[2]);

但是 ，如果使用动态初始化的方式创建数组，在没有手动赋值之前，其中的每一个元素都将会拥有一个默认值，规则如下：

1. 如果是整数类型，那么默认值为0；
2. 如果是浮点类型，那么默认值为0.0；
3. 如果是布尔类型，那么默认值为false；
4. 如果是字符类型，那么默认值为’\u0000’；
5. 如果是引用类型，那么默认值为null。

例如：

		//动态初始化创建一个数组 
		int[ ] array= new int[ 10 ]; 
		//在没有手动进行赋值之前，结果为0
		System.out.println(array[2]);
		//将数据123赋值给数组array中的第三号元素 
		 array[ 2 ] = 123;
		 //赋值后的结果为123	
		 System.out.println(array[2]);	

注意事项：

1. 其实，数组就是把多个数据类型统一的变量连起来编个号储存。所以，变量的内容可以修改，那么数组中的每一个元素就好比是一个个单独的变量，它们的内容也是可以发生改变的。
2. 其实静态初始化也有默认值的过程，只不过系统马上自动将默认值替换为了大括号中我们创建的具体数值。

数组的循环遍历

数组的遍历需要使用for循环来把数组中的元素查询出来，再逐个输出每一个数组元素。
例如：

		//创建一个数组
		int[] arrayA = new int[]{5,3,7,2,100,20};
		//因为数组的下标从0开始，所以for循环的初始值也是从0开始。
		//因为数组的下标最大值比数组的长度少1，所以for循环的第二要素要小于数组的长度
		for(int i = 0;i<arrayA.length;i++) {
			System.out.println(arrayA[i]);
		}

进阶：
数组相关知识极具代表性的一题
定义一个长度为10的整型数组，循环输入10个不重复整数。 然后再输入一个整数，在数组中查找此整数，找到输出下标，没找到给出提示。

		
		int[] array2 = new int[10];
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < array2.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个整数：");
			int num = sc.nextInt();
			array2[i] = num;
		}
		System.out.println("请输入要查找的数：");
		int num2 = sc.nextInt();
		for (int i = 0; i < array2.length; i++) {
			if (num2 == array2[i]) {
				System.out.println("该数的索引值为：" + i);
				System.exit(0);
			}
		}
		if(num2!＝array2[i])){
				System.out.println("没有找到这个数" );	
	     }
		

第一个for循环是接收十个整数并存入到数组中；第二个for循环是遍历数组并利用if语句比较每一个数组元素与要查找的值num2是否相等。在for循环的外面输出一句“System.out.println(“没找到这样的数”);”。if语句里加了一行“System.exit(0);”，这样如果找到相等的值时，输出该数的数组下标，然后执行“System.exit(0);”直接结束整个程序的执行。如果没找到相等的值，则for循环结束，执行“System.out.println(“没找到这样的数”);”。

也可以用第二种方法：

		int[] array2 = new int[10];
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < array2.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个整数：");
			int num = sc.nextInt();
			array2[i] = num;
		}
		System.out.println("请输入要查找的数：");
		int num2 = sc.nextInt();
		// 定义变量index存储下标，因为数组的下标是从0开始的，我们把变量的初值设为负数以便与数组的下标区分开来
		int index = -1;
		//遍历数组进行查找
		for (int i = 0; i < array2.length; i++) {
			if (num2 == array2[i]) {
				// 如果找到了，则把下标赋值给变量index
				index = i;
				// 既然找到了，循环也就没有必要再往后执行下去，使用break结束循环
				break;
			}
		}
		// 判断找到没有
		if (index >= 0) {
			System.out.println("找到了，下标为：" + index);
		} else {
			System.out.println("没有找到这样的数");
		}

二维数组（基本不用）

概念： 二维数组就是数组中再存放一个数组，使用两个下标确定一个元素。
语法：

数据类型[ ] [ ] 数组名 = new数据类型[ 外部数组长度 ] [ 内部数组长度 ];

		int[][] arr = new int[2][3];
		//修改二维数组的数据
		arr[0][0]=11;
		arr[0][1]=22;
		arr[0][2]=33;
		arr[1][0]=44;
		arr[1][1]=55;
		arr[1][2]=66;
		//查看二维数组中的数据
		System.out.println(arr[0][1]);
		System.out.println(arr[1][0]);
		
		int[] array=arr[0];
		System.out.println(array[2]);
		//二维数组的遍历		
		for(int i=0;i<arr.length;i++) {
			//arr[i].length指二维数组中单个索引下的数组长度
			for (int j = 0; j < arr[i].length; j++) {
				System.out.println(arr[i][j]);

数组的相关算法

求和、平均值

案例： 循环接收10个学生的年龄存入数组,求所有年龄的和以及平均年龄。

		int[] array = new int[10];
		double sum = 0;
		Scanner sc = new Scanner(System.in);
		for(int i = 0;i<array.length;i++) {
			System.out.println("请输入第"+(i+1)+"个学生年龄：");
			int age = sc.nextInt();
			array[i] = age;
			sum+=array[i];
		}
		System.out.println("年龄的总和为："+sum);
		System.out.println("平均年龄为："+sum/array.length);

求最值

案例： 循环接收10个学生的年龄存入数组,求成绩的最大值和最小值。

		int[] arrayB = new int[10];
		Scanner sc = new Scanner(System.in);
		//逐个接收输入的学生成绩并将成绩赋值到数组中。
		for (int i = 0; i < arrayB.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个学生年龄：");
			int age = sc.nextInt();
			arrayB[i] = age;
		}
		int max = arrayB[0];
		int min = arrayB[0];
		//把max与数组中的每一个元素进行比较，再将值比max大的元素赋值给max
		for (int i = 0; i < arrayB.length; i++) {
			//把max与数组中的每一个元素进行比较，再将值比max大的元素赋值给max
			if (max <= arrayB[i]) {
				max = arrayB[i];
			}
			//把min与数组中的每一个元素进行比较，再将值比min小的元素赋值给min
			if (min >= arrayB[i]) {
				min = arrayB[i];
			}
		}
		System.out.println("成绩最高的学生分数为：" + max);
		System.out.println("成绩最低的学生分数为：" + min);

思考： 变量max和变量min到底应该定义在哪个位置？

我们可以看到程序中动态初始化创建的数组arrayB只声明了元素个数，还没有进行赋值，所以此时的arrayB里的内容实际上是{0,0,0,0,0,0,0,0,0,0}。而程序中的第一个for循环就是逐个接收手动输入的学生成绩并将成绩赋值到数组arrayB中的一个过程。如果把max和min定义在for循环的前面，将arrayB[ 0 ]赋值给它们，实际上他们的值都为0。这个时候但凡我们手动输入的学生成绩都大于0，那么min的将始终输出0。因此max和min必须定义在数组被赋值之后。

数组的反转

案例： 循环接收10个整数存入数组中，再将其反转输出。

		int[] arrayB = new int[10];
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < arrayB.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个数：");
			int num = sc.nextInt();
			arrayB[i] = num;
		}
		
		for(int i = 0;i<arrayB.length/2;i++) {
			int temp = arrayB[i];
			arrayB[i]=arrayB[arrayB.length-(1+i)];
			arrayB[arrayB.length-(1+i)] = temp;
		}
		for(int i =0;i<arrayB.length;i++) {
			System.out.println(arrayB[i]);
		}

数组的扩容

原理： 前面我们讲过数组一旦创建，长度就不能更改。而数组的扩容实则就是新建一个数组，将原数组里的每一个元素都赋值到新数组中，再把新数组赋值给原数组，这样就实现了数组的扩容。用代码解释原理如下：

//数组的扩容
		int[] arr = {1,2,3,4};
		//1.新建一个数组
		int[] arr2=new int[6];
		//2.把原数组中的每一个数据赋值到新数据arr2中
		for (int i = 0; i < arr.length; i++) {
			arr2[i]=arr[i];
		}
		//3.改名字。把arr2代表的数组赋值给arr 
		arr = arr2;//这里arr就变成了{1,2,3,4,0,0}
		//这时候我们再来看一下arr的长度和元素值
		System.out.println("数组arr的长度"+arr.length);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

		//数组名 = Arrays.copyOf(原数组,扩容之后的长度);
		arr = Arrays.copyOf(arr,6);
		System.out.println("数组arr的长度"+arr.length);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

当然在实际应用的时候我们不用像上面那么麻烦，我们可以直接调用Arrays.copyOf( )方法来实现功能：

格式：数组名 = Arrays.copyOf(原数组,扩容之后的长度);
例如：arr = Arrays.copyOf(arr,6);

案例：

		
		arr = Arrays.copyOf(arr,6);
		System.out.println("数组arr的长度"+arr.length);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

快速排序

		// 使用java提供的快速排序方式对数组进行排序 -- 升序排序
		Arrays.sort(array);
		for(int i =0;i<array.length;i++) {
			System.out.println(array[i]);
		}

for循环增强

		//增强for循环
		int [] arr= {3,7,1,4,6};
		for(int e:arr) {
			System.out.println(e);
		}