java：6 数组

数组array

[数组、排序、查找、多维数组]

1. 介绍

• 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
  即:数(数据)组(一组)就是一组数据。
  

2. 入门练习

它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。 请问这六只鸡的总体重是多少?平均体重是多少?

• 注意：可以用数组名.length 得到数组的长度/大小。

public class Test {
	public static void main(String[] args) {
		/*
		它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。 
		请问这六只鸡的总体重是多少?平均体重是多少?

		定义一个数组
		1. double[]表示一个double类型的数组。
		2. hens表示数组名。
		3. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素，依次表示数组第几个元素。

		遍历数组，得到所有元素的和，用for
		1. 通过hens[下标]来访问数组的元素，下标从0开始。
		2. 【第一个元素 = hens[0]】
		3. 通过for循环就可以循环访问数组的元素。
		4. 使用一个变量 totalWeight把所有元素累加起来。
		5.可以用数组名.length 得到数组的长度
		*/
		double[] hens = {3, 5, 1, 3.4, 2, 50};
		double totalWeight = 0;
		//可以用数组名.length 得到数组的长度
		for(int i = 0; i < hens.length; i++){
			totalWeight += hens[i];
		}
		System.out.println("总体重 = " + totalWeight + "平均体重 = " + totalWeight / hens.length);	
	}
} 

---

3. 数组的使用

3.1 使用方法一：动态初始化

1. 数组的定义

比如： int a[] = new int[5]; //创建了一个数组，名字a,存放5个int。
数组内存图：

2. 数组的引用

数组名[index]
比如：你要使用a数组的第3个数 a[2]。

3. 案例
   循环输入5个成绩，保存到double数组,并输出。

public class Test {
	public static void main(String[] args) {
		//步骤：
		//1. 创建一个double数组，大小为5
		double[] scores = new double[5];
		//2. 循环输入
		import java.util.Scanner;
		Scanner myScanner = new Scanner(System.in);
		for(int i = 0; i < scores.length; i++){
			System.out.println("请输入第" + (i + 1) + "个元素的值");
			scores[i] = myScanner.nextDouble();
		}
		//3. 输出，遍历上面的数组
		for(int i = 0 ;i < scores.length; i++){
			System.out.println("第" + (i + 1) + "个元素的值 = " + scores[i]);
		}
		
	}
} 

3.2 使用方法二：动态初始化

1. 先声明数组

比如：int a[]; 或者 int[] a;

2. 创建数组

比如： a=new int[10];

3. 案例演示【前面代码修改】

public class Test {
	public static void main(String[] args) {
		//先声明一个叫scores的数组。
		double[] scores 
		//再new分配内存空间来存放数据。
		scores = new double[5];	

	}
} 

3.3 使用方法三：静态初始化

• 初始化数组

int a[]={2,5,6.7,8,89,90,34,56}，如果知道数组有多少元素，具体值
相当于：int a[] = new int[9] :
a[0]=2:a[1]=5:a[2]=6; a[3]=7:a[4]=8;
a[5]=89;a[6]=90;a[7]=34;a[8]= 56;

• 快速入门案例【养鸡场】

double hens[] = {3, 5, 1, 3.4, 2, 50};
等价于
double hens[] = new double[6];
hens[0] = 3; hens[1] = 5; hens[2] = 1; hens[3] = 3.4; hens[4] =2; hens[5] = 50;

4. 数组的细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值。
   int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
4. 使用数组的步骤【1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组】
5. 数组的index从0开始。
6. 数组index必须在指定范围内使用，否则报:index越界异常，比如int [] arr=new int[5]; 则有效index为 0-4。
7. 数组属于引用类型，数组型数据是对象(object)。

5. 数组的应用

1. 创建一个char类型的26个元素的数组，分别放置’A’-‘Z’。使用for循环访问所有元素并打印出来。提示:char类型 数据运算 ‘A’+2 -> ‘C’
   【注意⚠️：这里的‘A’ + i是int类型的变量值，需要强制转换。因为：char类型可以保存int的常数值，但不能保存int的变量值，需要强转。】

public class Test {
	public static void main(String[] args) {
		//定义一个数组
		char chars[] = new char[26];
		//因为‘A’ + 1 = 'B'
		for(int i = 0; i < chars.length; i++){
			//chars是char[]类型。
			//chars[i]是char类型。
			//这里的‘A’ + i是int类型，需要强制转换。
			chars[i] = (char)('A' + i);
		}
		for(int i = 0; i < chars.length; i++){
			System.out.print(chars[i] + ' ');
		}
	}
} 

2. 请求出一个数组int[]的最大值{4,-1,9,10,23}，并得到对应的下标。

public class Test {
	public static void main(String[] args) {
		//1.定义一个数组
		int[] arr = {4,-1,9,10,23};
		//2.假设arr[0]是max。如果max < 当前值，max = 当前值。
		int max = arr[0];
		int maxIndex = 0;
		for(int i = 1; i < arr.length; i++){
			//条件筛选
			if(max < arr[i]){
				max = arr[i];
				maxIndex = i;
			}
		}
		System.out.println("max = " + max + "maxIndex = " + maxIndex);
	}
} 

3. 请求出一个数组的和以及平均值。(养鸡场)

public class Test {
	public static void main(String[] args) {
		//double[] hens = {3, 5, 1, 3.4, 2, 50};
		double[] hens = {3, 5, 1, 3.4, 2, 50};
		doubel totalWeight = 0;
		for(int i = 0; i < hens.length; i++){
			totalWeight += hens[i];
		}
		System.out.println("数组和 = " + totalWeight + "数组平均值 = " + totalWeight / hens.length)

	}
} 

6. 数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
   比如：int n1 = 2; int n2 = n1; （n2的变化不影响n1。）
2. 数组在默认情况下是引用传递，赋的值是地址。
   【分析数组赋值的内存图(重点, 难点. )】
   【可以理解为给数组取了另一个名字，对应表达的是同一个人（地址）】

public class Test {
	public static void main(String[] args) {
		//什么是引用传递（地址拷贝）
		int[] arr1 = {1,2,3};
		int[] arr2 = arr1; //把arr1的地址赋给arr2.
		//arr2的变化会影响arr1。
		arr2[0] = 10; 

		//看一下arr1的值。
		for(int i = ; i < arr1.length; i++){
			System.out.print(arr1[i]);//输出{10,2,3}
			System.out.print(arr2[i]);//输出{10,2,3}
		}
	}
} 

• 粉色框–>地址（门牌号）
• 在内存里只有分配了空间，就一定对应一个地址。

7. 数组拷贝

• 将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组。要求数据空间是独立的。
  编写代码 实现数组拷贝(内容复制)

public class Test {
	public static void main(String[] args) {
		//将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组
		//要求数据空间是独立的。
		
		int[] arr1 = {10,20,30};
		//先创建一个arr2，开辟新的数据空间，保证大小和arr1一样。
		int[] arr2 = new int[arr1.length];
		//for循环拷贝arr1的每个元素拷贝给arr2
		//这样arr2的变化，就不会影响arr1。
		for(int i = 0; i < arr1.length; i++){
			arr2[i] = arr1[i];
		}
	}
} 

8. 数组反转（2种）

要求:把数组的元素内容反转。
arr {11,22,33,44,55,66} {66, 55,44,33,22,11}

• 方式 1:通过找规律反转 【重点在于思路分析】

public class Test {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {11,22,33,44,55,66};
		//1. 把arr[0]和arr[5]交换{66,22,33,44,55,11}
		//2. 把arr[1]和arr[4]交换{66,55,33,44,22,11}
		//3. 把arr[2]和arr[3]交换{66,55,44,33,22,11}
		//4. 一共交换arr.length/2。
		//5. 每次交换对应的index是arr[i]和arr[arr.length - 1 - i]
		for(int i = 0; i < arr.length / 2; i++){
			int temp = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = arr[i];
			arr[i] = temp;
		}
	}
} 

• 方式 2:使用逆序赋值方式

public class Test {
	public static void main(String[] args) {

		int[] arr = {11,22,33,44,55,66};

		//1. 创建一个新的数组arr2，大小和arr1一样。
		int[] arr2 = new int[arr.length];
		
		//2. 逆序遍历arr1，将每个元素拷贝到arr2当中（顺序拷贝）。
		//建议增加一个循环变量，更简单。
		for(int i = arr.length - 1, j = 0; i >= 0; i--, j++){
			arr2[j] = arr[i];
		}

		//3. for循环结束后， arr2就是arr的逆序数组。
		//arr指向arr2的数据空间。
		//arr原来的数据空间没有变量应用，会被当作垃圾销毁。
		arr = arr2;
	}
}