4.数 组

​

4.数组

4.1 数组介绍

1.介绍：数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

4.2一维数组

4.2.1一维数组使用

使用方式2：:

1.先声明数组

数据类型 数组名[]; 也可以 数据类型[] 数组名;

int a[]; 或者 int[] a;

2.创建数组

语法: 数组名=new 数据类型[大小];

a=new int[10];

4.2.2使用注意事项

1. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
2. 数组创建后，如果没有赋值，有默认值int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
3. 使用数组的步骤 1. 声明数组并开辟空间 2 .给数组各个元素赋值 3 .使用数组
4. 数组的下标是从 0 开始的。
5. 数组下标必须在指定范围内使用，否则报：下标越界异常。

4.2.3数组的赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

​ int n1 = 2; int n2 = n1;

2. 数组在默认情况下是引用传递，赋的值是地址。

​ int[] arr1 = {1,2,3};

​ int[] arr2 = arr1;

数组拷贝：

//将 int[] arr1 = {10,20,30};  拷贝到 arr2 数组,
//要求数据空间是独立的.
int[] arr1 = {10,20,30};
//创建一个新的数组 arr2,开辟新的数据空间
int[] arr2 = new int[arr1.length];
//遍历 arr1 ，把每个元素拷贝到 arr2 对应的元素位置
for(int i = 0; i < arr1.length; i++) { 
	arr2[i] = arr1[i];
}

数组反转：

要求：把数组的元素内容反转。

//思路：从两头开始互相交换
// 一共要交换 arr.length / 2次
//每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
int[] arr = {11, 22, 33, 44, 55, 66};
int temp = 0;
for( int i = 0; i < arr.length / 2; i++) {
	temp = arr[len - 1 - i];//保存
    arr[len - 1 - i] = arr[i];
	arr[i] = temp;
}
System.out.println("===翻转后数组===");
for(int i = 0; i < arr.length; i++) {
	System.out.print(arr[i] + "\t");
}

数组添加/扩容：

要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java

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

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

3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

/*思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标 0-2
2.	定义一个新的数组 int[] arrNew = new int[arr.length+1];
3.	遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
4.	将 4 赋给 arrNew[arrNew.length - 1] ;
5.	让 arr  指向 arrNew ;	arr = arrNew;  那么 原来 arr 数组就被销毁
6.	创建一个 Scanner 可以接受用户输入
7.	因为用户什么时候退出，不确定，可使用 do-while + break 来控制
*/
Scanner myScanner = new Scanner(System.in);
//初始化数组 
int[] arr = {1,2,3};
do {
	int[] arrNew = new int[arr.length + 1];
	//遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
	for(int i = 0; i < arr.length; i++) { 
        arrNew[i] = arr[i];
	}
	System.out.println("请输入你要添加的元素");
    int addNum = myScanner.nextInt();
	//把 addNum 赋给 arrNew 最后一个元素
	arrNew[arrNew.length - 1] = addNum;
	//让 arr  指向 arrNew, 
    arr = arrNew;
	//输出 arr 看看效果
	System.out.println("====arr 扩容后元素情况===="); 
    for(int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + "\t");
	}
	//问用户是否继续
	System.out.println("是否继续添加 y/n");
    char key = myScanner.next().charAt(0); 
    if( key == 'n') { //如果输入 n ,就结束
		break;
	}
}while(true);

4.2.4排序

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

排序的分类：

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

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

冒泡排序法

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

int[] arr = {24, 69, 80, 57, 13};
int temp = 0; //用于辅助交换的变量
for( int i = 0; i < arr.length - 1; i++) {//外层循环是 4 次
	for( int j = 0; j < arr.length - 1 - i; j++) {//4 次比较-3 次-2 次-1 次
        //如果前面的数>后面的数，就交换
        if(arr[j] > arr[j + 1]) {
        temp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = temp;
        }
    }
}

4.2.5查找

java 中，我们常用的查找有两种:

顺序查找

二分查找

4.3二维数组

4.3.1介绍

4. 什么是二维数组：

5. 从定义形式上看 int[][]

6. 可以这样理解，原来的一维数组的每个元素是一维数组, 就构成二维数组

int[][] arr = { {0, 0, 0, 0, 0, 0},

	{0, 0, 1, 0, 0, 0},

	{0,2,  0, 3, 0, 0},

	{0, 0, 0, 0, 0, 0} };

4.3.2使用

使用方式1：动态初始化

语法: 
类型[][] 数组名=new 类型[大小][大小];

使用方式 2: 动态初始化

语法：
类型 数组名[][];
数组名 = new 类型[大小][大小]; 

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

/*动态创建下面二维数组，并输出
i = 0:	1
i = 1:	2	2
i = 2:	3	3	3
*/
//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间
int[][] arr = new int[3][];
for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
    //给每个一维数组开空间 new
    //如果没有给一维数组 new ,那么 arr[i]就是 null
    arr[i] = new int[i + 1];
	//遍历一维数组，并给一维数组的每个元素赋值
    for(int j = 0;	j < arr[i].length; j++) {
		arr[i][j] = i + 1;//赋值
	}
}
//遍历 arr 输出
for(int i = 0; i < arr.length; i++) {
	//输出 arr 的每个一维数组
	for(int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
	}
	System.out.println();//换行
}

使用方式 4: 静态初始化

类型 数组名[][]	= {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}};
如:int[][] arr = {{1,1,1}, {8,8,9}, {100}};

4.3.3应用

使用二维数组打印一个 10 行杨辉三角

int[][] yangHui = new int[12][];
for(int i = 0; i < yangHui.length; i++) {//遍历 yangHui 的每个元素
	//给每个一维数组(行) 开空间
	yangHui[i] = new int[i+1];
	//给每个一维数组(行) 赋值
	for(int j = 0; j < yangHui[i].length; j++){
		//每一行的第一个元素和最后一个元素都是 1 
        if(j == 0 || j == yangHui[i].length - 1) {
			yangHui[i][j] = 1;
		} else {//中间的元素
			yangHui[i][j]	=	yangHui[i-1][j] + yangHui[i-1][j-1];
		}
    }
    

t[i+1];
//给每个一维数组(行) 赋值
for(int j = 0; j < yangHui[i].length; j++){
//每一行的第一个元素和最后一个元素都是 1
if(j == 0 || j == yangHui[i].length - 1) {
yangHui[i][j] = 1;
} else {//中间的元素
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}