05数组

## 概述

数组可以存放多个同一类型的数据，数组也属于数据类型，为引用类型。

数组 ------>  一组数据

## 使用方式

> 动态初始化1

数组的定义：数据类型  数组名[] = new  数据类型[大小]

例如：int a[] = new int[5]  -- 数组名为a，数据类型为整型，存放5个整型数据

数组的引用（使用/访问/获取数组元素）：数组名[下标/索引/index]

```java
/**
 * 循环输入五科成绩，将数据保存到数组中，并进行输出
 */
import java.util.Scanner;
public class Array01{
	public static void main(String[] args){
		// 定义数组
		double subject[] = new double[5];
		// 输入
		Scanner myScanner = new Scanner(System.in);
		// subject.length 数组的长度
		for(int i = 0;i < subject.length;i++){
			System.out.print("请输入学科成绩：");
			subject[i] = myScanner.nextDouble();
		}

// 输出，遍历数组
		System.out.println("===存放的值===");
		for(int i = 0;i < subject.length;i++){
			System.out.println("值为" + subject[i]);
		}
	}
}
```

![image-20230131095047069](https://oss.maolin101.com/202501070047876.png-101.webp)

> 动态初始化2

数组的定义：先声明数组，再创建数组

声明数组：数据类型  数组名[ ]  或者  数据类型[]  数组名

创建数组：数组名 = new  数据类型[大小]

例如：int a[]；a = new int[10];

```java
/**
 * 循环输入五科成绩，将数据保存到数组中，并进行输出
 */
import java.util.Scanner;
public class Array02{
	public static void main(String[] args){
		double subject[];  // 申明数组
		subject = new double[5];  //创建数组，分配内存空间

// 循环输入
		Scanner myScanner = new Scanner(System.in);
		for(int i = 0; i < subject.length; i++){
			System.out.print("请输入学科成绩：");
			subject[i] = myScanner.nextDouble();
		}

// 输出，遍历数组
		System.out.println("===存储的数据值===");
		for(int i = 0;i < subject.length;i++){
			System.out.println("存储值为：" + subject[i]);
		}

} 
}
```

![image-20230131100812698](https://oss.maolin101.com/202501070047878.png-101.webp)

> 静态初始化

初始化数组的定义：数据类型  数组名[]  =  {元素值,元素值,......}

例如：int a[] = {1,2,3,4,5,6,7,8,9}; //知道元素的个数与具体值

```java
/**
 * 存储五个值，以此进行输出
 */
public class Array03{
	public static void main(String[] args){
		int num[] ={1,2,3,4,5};
		for(int i = 0;i < num.length;i++){
			System.out.println(num[i]);
		} 
	}
}
```

![image-20230131101205748](https://oss.maolin101.com/202501070047879.png-101.webp)

> 数组使用注意事项

- 数组由多个相同类型数据的组合，实现对这类数据的统一管理；

- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但不能混用；

- 数组创建后，如果没有赋值，则有默认值：

![image-20230120164646064](https://oss.maolin101.com/202501070047880.png-101.webp)

- 使用数组步骤：1声明数组并开辟空间，2给数组各元素赋值，3使用数组；

- 数组的下标是从0开始的；

- 数组的下标必须在指定范围内使用，否则报：下标使用越界，例如：int arr[] = new int[4] //下标的范围是0-4；

- 数组属于引用类型，数组中的数据是对象；

## 数组赋值机制

基本数据类型赋值，值为具体的数据，不会互相影响，赋值方式为拷贝（拷贝的是具体的值）

数组在默认情况下是引用传递，赋值方式地址（拷贝的是数据地址）

```java
public class ArrayAssign01{
	public static void main(String[] args){
		// 数组在默认情况下是引用传递，赋的值是地址，赋值的方式为引用赋值
		// arr2的变化会影响arr1
		int arr1[] = {1,2,3};
		int arr2[] = arr1;
		System.out.println("===arr1的元素===");
		for(int i = 0; i < arr1.length;i++){
			System.out.println(arr1[i]);
		}
		// arr2赋值
		arr2[0] = 100;
		System.out.println("===arr1的元素===");
		for(int i = 0; i < arr1.length;i++){
			System.out.println(arr1[i]);
		}
	}
}
```

![image-20230131110917866](https://oss.maolin101.com/202501070047881.png-101.webp)

> 值拷贝与地址传递的区别

![image-20230131113915659](https://oss.maolin101.com/202501070047882.png-101.webp)

## 数组拷贝

> 编写代码实现数组的拷贝（内容复制）

将int[] arr1 = {10,20,30};拷贝到arr2数组中，要求数据空间是独立的。

```java
public class ArrayCopy01{
	public static void main(String[] args){
		int[] arr1 = {10,20,30};
		// 开辟一个新的数据空间
		int arr2[] = new int[arr1.length];
		// 将arr1中的元素拷贝到arr2对应的位置
		for(int i = 0; i < arr1.length; i++){
			arr2[i] = arr1[i];
		}

// 打印arr2中的元素
		for(int i = 0; i < arr2.length; i++){
			System.out.println(arr2[i]);
		}
	}
}
```

![image-20230131142131409](https://oss.maolin101.com/202501070047883.png-101.webp)

## 数组反转

> 将数组中的元素进行反转

arr{11,22,33,44,55,66}

```java
public class ArrayReversal{
	public static void main(String[] args){
		int[] arr = {11,22,33,44,55,66};
		int[] arr1 = new int[arr.length];
		for(int i = 0; i < arr.length; i++){
			int j = arr.length - i - 1;
			arr1[i] = arr[j];
		}
		for(int i = 0; i < arr1.length; i++){
			System.out.println(arr1[i]);
		}
	}
}
```

![image-20230131143736007](https://oss.maolin101.com/202501070047884.png-101.webp)

## 数组扩容

> 实现动态的给数组添加元素效果，实现对数组扩容

要求：

- 原始数组使用静态分配int[] arr = {1,2,3}

- 增加的元素，直接放在数组的最后arr = {1，2，3，4}

- 用户可以自己决定是否继续添加元素

代码

```java
/**
 * 思路分析
 * 	1.定义初始数组
 * 	2.定义一个新的数组，新数组长度比旧数组大一（length + 1）
 * 	3.遍历旧数组，将元素拷贝到新数组
 * 	4.将新元素赋值给新元素的最后一个元素（length - 1）
 * 	5.将旧数组指定新数组的地址  arr = arrNew
 */
import java.util.Scanner;
public class ArrayAdd01{
	public static void main(String[] args){
		// 原始数组
		int[] arr = {1,2,3};
		while(true){
			int[] arrNew = new int[arr.length + 1];
			for(int i = 0;i < arr.length;i++){
				arrNew[i] = arr[i];
			}

Scanner myScanner = new Scanner(System.in);
			System.out.print("请输入需要添加的元素：");

int addNum = myScanner.nextInt();
			arrNew[arrNew.length - 1] = addNum;
			// 指定新数组地址
			arr = arrNew;
			System.out.print("当前数组元素：");
			for(int i = 0;i < arr.length;i++){
				System.out.print(arr[i] + " ");
			}
			System.out.println("");
			System.out.print("是否继续添加元素(y/n)：");
			char input = myScanner.next().charAt(0);
			if(input == 'n'){
				break;
			}		
		}
		System.out.println("已退出添加");
	}
}
```

![image-20230131162201582](https://oss.maolin101.com/202501070047885.png-101.webp)

## 数组排序

> 概述

排序即是将多个数据，按指定的顺序进行排列的过程。

> 内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序（包括交换式排序法、选择式排序法、插入式排序法）。

> 外部排序

指数据量过大，无法全部加载到内存中，需要借助外部存储器进行排序（包括合并排序法和直接合并排序法）。

> 冒泡排序法 - Bubble Sorting

基本思想：通过对待排序序列从后向前（从下标较大的元素开始），以此比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

**示例：**五个无序的值：24、69、80、57、13，使用冒泡排序法将其排成一个**从小到大**的有序数列。

**思路：**

![image-20230131224128124](https://oss.maolin101.com/202501070047886.png-101.webp)

**代码：**

```java
public class BubbleSort{
	public static void main(String[] args){
		int[] arr = {24,69,80,57,13};
		int temp = 0; // 辅助交换参数

for(int i = 0; i < arr.length - 1;i++){
			for(int j = 0; j < arr.length - 1 - i;j++){
				if(arr[j] > arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			System.out.print("第" + (i + 1) + "次排序：");
			for(int j = 0;j < arr.length;j++){
				System.out.print(arr[j] + "\t");
			}
			System.out.println();
		}
	} 
} 
```

**运行截图：**

![image-20230201221345743](https://oss.maolin101.com/202501070047887.png-101.webp)

## 二维数组

> 使用方式1 动态初始化

语法：类型[][] \[]\[]  数组名=new 类型\[]\[]

例如：int a\[]\[]  = new  int\[2]\[3]

```java
public class TwoDimensionalArray01{
	public static void main(String[] args){
		int[][] arr = new int[2][3];
		arr[1][1] = 5;
		// 遍历数组
		for(int i = 0;i < arr.length;i++){
			
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}
```

![image-20230206164733897](https://oss.maolin101.com/202501070047888.png-101.webp)

**内存变化**

![image-20230206164826594](https://oss.maolin101.com/202501070047889.png-101.webp)

> 使用方式2：动态初始化

先声明：类型  数组名\[]\[]，例如：int arr\[][]

再定义[开辟新的空间]：数组名  =  new  类型\[大小][大小]，例如：arr = new int\[3][5]

```java
public class TwoDimensionalArray01{
	public static void main(String[] args){
		// 先声明，再定义
		int arr[][];
		arr = new int[3][4];
		arr[2][2] = 6;
		// 遍历数组
		for(int i = 0;i < arr.length;i++){
			
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}
```

![image-20230206165502432](https://oss.maolin101.com/202501070047890.png-101.webp)

> 使用方式3：动态初始化-列数不确定

![image-20230206165747804](https://oss.maolin101.com/202501070047891.png-101.webp)

代码部分

```java
public class TwoDimensionalArray02{
	public static void main(String[] args){
		/*
			1
			2 2
			3 3 3
		*/
		int[][] arr = new int[3][];
		for(int i = 0; i < arr.length;i++){
			// 为每个一维数组赋值
			arr[i] = new int[i+1];
			for(int j = 0; j < arr[i].length;j++){
				// 赋值
				arr[i][j] = i + 1;
			}
		}

// 遍历输出
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}
```

![image-20230206171659692](https://oss.maolin101.com/202501070047892.png-101.webp)

> 使用方式4：静态初始化

语法：类型  数组名\[][]  = {{值1,值2,值3,...},{值1,值2,值3,...}}

例如：int\[][]  arr = {{1,2,3},{4,5,6},{7,8,9}}

代码部分

```java
public class TwoDimensionalArray03{
	public static void main(String[] args){
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		int sum = 0;
		// 遍历数组
		System.out.println("数组列表为：");
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + "   ");
				sum += arr[i][j];
			}
			System.out.println();
		}
		System.out.println("二位数组总和为：" + sum);
	}
}
```

![image-20230206172905608](https://oss.maolin101.com/202501070047893.png-101.webp)

> 注意事项

1. 一维数组的声明方式：int  x\[]   或者 int[]  x；
2. 二维数组的声明方式：int\[][]  y   或者int  y\[][]  或者  int[]  y[]；
3. 二维数组实际上是由多个一维数组 组成，它的各个维数组 的长度可以相同，也可以不相同；

> 杨辉三角

使用二维数组打印一个10行的杨辉三角
			1 
			1 1
			1 2 1
			1 3 3 1
			1 4 6 4 1
			1 5 10 10 5 1
			......

代码

```java
public class YangHui{
	public static void main(String[] args){
		int[][] arr = new int[10][];
		for(int i = 0;i < arr.length;i++){
			arr[i] = new int[i + 1];
			for(int j = 0; j < arr[i].length;j++){
				if(j == 0 || j == arr[i].length - 1){
					arr[i][j] = 1;
				}
				else{
					arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
				}
				System.out.print(arr[i][j] + "  ");
			}
			System.out.println();
		}
	}
}
```

![image-20230207165445868](https://oss.maolin101.com/202501070047894.png-101.webp)