Java笔记之数组（五）

一、数组的基本概念

1.什么是数组

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

2.数组的使用

1.方法一（动态初始化）

• 数组的定义
  语法格式：
  数据类型 数组名[] = new 数据类型[大小]；
  数据类型[] 数组名 = new 数据类型[大小]；
  以上两种定义方式等价;
  例：int test[] = new int[5]; //创建一个名字为test,长度为5,int类型的数组
• 数组的引用
  格式：
  数组名[下标]；
  例：test[2]; //使用数组第三个数
  注意：数组下标是从0开始的

2.方法二（动态初始化）

• 先声明数组，再创建数组
  语法格式：
  第一步：数据类型 数组名[]；或者 数据类型[] 数组名；
  第二部：数组名=new 数据类型[大小];
  例：int test[]；
  　　test = new int[5]；

3.方法三（静态初始化）

• 语法格式
  数组类型 数组名[] = {元素值1，元素值2 ···}；
  例：int test[] = {1,2,3,4,5}；

//声明数组
int test[] = new int[5];

Scanner myScanner =  new Scanner(System.in);
for (int i = 0 ;i<test.length ; i++ ) {
	System.out.println("请输入下标为"+i+"的元素");
	//对每个数组进行赋值
	test[i] = myScanner.nextInt();
}

//声明+赋值 与上面代码等价
int test1[] = {1,2,3,4,5};

//遍历数组
for (int i = 0 ;i<test.length ; i++ ) {
	System.out.println("第"+i+"元素的值为"+test[i]);
}

3.数组使用的注意事项

1. 数组是多个相同类型数据的组合，如果有不同类型，则会进行类型自动转换（符合类型转换的规则，否则会报错）。
2. 数组的下标是从 0 开始的。
3. 数组属引用类型，数组型数据是对象(object)。
4. 数组创建后，如果没有赋值，则会有默认值 如：int默认的默认值为0。
5. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
6. 数组下标必须在指定范围内使用，否则会报下标越界异常的错误。

//注意事项1
int a[] = {1,2,3,4,2.0};	//错误，double不能转int
double a1[] = {1.0,2.0,3.0,4.0,2};	//正确，int可以转int

//注意事项2
int b[] = {1,2,3,4,5};
System.out.println(b[0]);	//值为1

//注意事项3
//数组不是基本数据类型，它是一个对象

//注意事项4
int c[] = new int[5];
for (int i = 0 ;i<c.length ; i++ ) {
	System.out.println(c[i]);	//值为 0 0 0 0 0
}

//注意事项5 
//跟1表达的意思差不多

//注意事项6
int d[] = {1,2,3,4,5};		//下标0-4
System.out.println(d[5]);	//错误，下标为5，越界了

4.数组的基本操作

1.数组的赋值和复制

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

int a1[] = {1,2,3};
//把a1赋值给a2,传递的是一个地址，修改a2中的数据会，a1中的数据也会受到影响
int a2[] = a1;

a2[0] = 10;	//修改a2数组中第0个元素的值,对数组a1有影响

//遍历数组a1
for (int i = 0; i<a1.length ; i++) {
	System.out.println(a1[i]);	//10 2 3
}

System.out.println("------------");
//创建一个新的数组 b2,开辟新的数据空间
int b1[] = {1,2,3};
int b2[] = new int[3];

//把数组b1的值赋值给b2
for (int i = 0; i<b1.length ; i++) {
	b2[i] = b1[i];
}

b2[0] = 10;	//修改b2数组中第0个元素的值,对数组b1不会有影响

//遍历数组b1
for (int i = 0; i<b1.length ; i++) {
	System.out.println(b1[i]);	//1 2 3
}

2.数组的反转

把数组的内容进行反转 如：int arr1= {1，2，3} => int arr1 = {3，2，1}
说明：通过定义一个中间变量，进行替换

int arr1[] = {1,2,3};
int len = arr1.length;
int temp = 0;
for (int i = 0; i<len/2 ; i++) {
	temp = arr1[len-1-i];
	arr1[len-1-i] = arr1[i];
	arr1[i] = temp;
}

for (int i = 0; i<len ; i++) {
	System.out.println(arr1[i]);	//3 2 1
}

3.数组的扩容

要求：

1. 创建一个静态数组 如：int arr = {1,2,3};
2. 在arr后面增加一个元素 如：添加一个4，使arr = {1,2,3,4};
3. 判断是否继续添加元素，输入Y继续添加，否则退出添加。

import java.util.Scanner;

public class test{
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		int arr[] = {1,2,3};

		do{	
			//把arr数组的元素依次赋值给newArr
			int newArr[] = new int[arr.length+1];
			for (int i=0; i<arr.length;i++ ) {
				newArr[i] = arr[i];
			}

			System.out.println("请输入要添加元素的值");
			int element =  myScanner.nextInt();
			newArr[newArr.length-1] = element;

			//把newArr指向的值1 2 3 4的地址赋值给arr，类似于链表元素的插入
			arr = newArr;

			System.out.println("添加元素后数组的值");
			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') {
				break;
			}
		}while(true);	

		System.out.println("元素添加完毕，已退出");
	}
}

二、数组的排序

排序：是将多个数据，依指定的顺序进行排列的过程。
冒泡排序：
通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素 的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

import java.util.Scanner;

public class test{
	public static void main(String[] args) {
		/*
			i一共循环4次
			j一共循环4+3+2+1次
			第一次循环比较前五个元素
			第二次循环比较前四个元素
			第三次循环比较前三个元素
			第四次循环比较前二个元素
		 */
		int arr[] = {5,3,8,9,2};
		int temp = 0;
		for (int i=0; i<arr.length-1;i++ ) {
			for (int j = 0;j<arr.length-i-1;j++ ) {
				if (arr[j]>arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}

		//排序后的数组
		for (int i=0; i<arr.length;i++ ) {
			System.out.print(arr[i]+"\t");
		}
	}
}

三、数组的查找

查找：查找数组中对于的元素
常用的查找有顺序查找和二分查找，这里演示一下顺序查找

//查找数组元素等于8的数组下标
int arr[] = {5,3,8,9,2};
int index = -1;
for (int i=0; i<arr.length-1;i++ ) {
	if (arr[i] == 8) {
		index = i;
		System.out.println("找到了！数组元素等于8下标为"+index);
		break;
	}
}

if (index == -1) {
	System.out.println("没找到！");
}

四、二维数组

1.基本介绍

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。

2.二维数组的使用

方法一（动态初始化）

• 定义格式：
  类型[][] 数组名=new 类型[大小][大小];
  如：int a[][]=new int[2][3];
  　　说明：表示二维数组中有2个一维数组，每个一维数组中有3个元素。

方法二（动态初始化）

• 定义格式
  先声明：类型 数组名[][];
  再定义(开辟空间)： 数组名 = new 类型[大小][大小];
  如：int a[][]；
  　　a = new int[2][3];
  如果没有赋值则有默认值，如int类型的默认值为0，上面一维数组中已经介绍过了，这里就不在举例了

方法三（动态初始化-列数不确定）

• 说明：如第一个一维数组中有一个元素，第二个一维数组有两个元素，第三个一维数组有三个元素
• 定义格式
  先声明：类型[][] 数组名=new 类型[大小][];
  再定义（给每个一维数组开辟空间）：数组名[大小] = new 类型[大小];

//创建类型为int的二维数组，期中三个一维数组，但没有开辟数据空间
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();
}

方法四（静态初始化）

• 定义格式：
  类型 数组名[][] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}};
  如：int[][] arr = {{1,2,3}, {4,5,6}, {2}};

//遍历二维数组
int[][] arr = {{1,2,3}, {4,5,6}, {2}};
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();
}

3.数组练习

1.杨辉三角

要求：打印前五行：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

//打印五行杨辉三角
int arr[][] = new int[5][];
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) {
			//第一行和第二行的元素都是1
			arr[i][j] = 1;
		}else{
			//arr[i][j] = 上一行的第j个元素和上一行的第j-1个元素的和
			arr[i][j] = arr[i-1][j]+arr[i-1][j-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();
}	

2.数组的添加与排序

要求：在一个升序数组{11,22,33,44,55}中插入一个数组元素25，使数组仍然是升序排列的，添加后的数组为：{11,22,25,33,44,55}。

/*
	1.找到插入的位置
	2.将数组赋值给一个新数组，在赋值的过程中插入新的数

 */

int arr[] = {11,22,33,44,55};
int newNum = 25;
int index = -1;
//找到插入的位置
for (int i=0 ; i<arr.length ; i++ ) {
	if (arr[i]>25) {
		index = i;
		break;
	}
}

//创建一个新数组，插入新增的数
int newArr[] = new int[arr.length+1];
for (int i=0,j=0; i<newArr.length ; i++ ) {
	if (i != index) {
		newArr[i] = arr[j];
		j++;
	}else{
		newArr[i] = newNum;
	}
}

//遍历数组验证
for (int i=0 ; i<newArr.length ; i++ ) {
	System.out.print(newArr[i]+" ");
}