java学习笔记之数组-2021/03/07

特殊流程控制语句

一、return、break、continue的区别

1. return ：并非专门用于结束循环，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束；
2. break：只能用于switch语句和循环语句中
3. continue：只能用于循环语句；
   二者功能类似，但continue是终止本次循环，break是终止本层循环。
   4.break、continue之后不能有其他语句，因为程序永远不会执行其后的语句
4. 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内；

数组

一、一维数组声明

1、 一维数组声明方式

type var[] 或 type[] var

//例如：
int a[ ];
int[ ] a;

2、一维数组初始化

1. 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行；

int[] arr = new int[3];//声明一个能放3个int类型数据的数组
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

2. 静态初始化：在定义数组的同时就位数组元素分配空间并赋值。

int a[] = new int[]{3,9,8};
int[] a = {3,9,8};

3、数组元素的引用

1. 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
2. 数组元素的引用方式：数组名【数组元素下标】

• 数组元素下标可以是整型常量或整型表达式。如：a[3],b[i],c[6*i];
• 数组元素下标从0开始

3. 每个数组都有一个属性length指明它的长度，例如：a.length指明数组a的长度（元素个数）；

• 数组一旦初始化，其长度不可变

String[] strs = new String[]{"a","b","c"};
System.out.println("strs的数组长度是："+strs.length);

4、数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

int a[] = new int[5];//整型数组默认元素初始化为0；对象型默认初始化为null

二、多维数组

1、二维数组初始化

一维数组中每一个元素都是一个数组，这样的数组就是二维数组

1. 动态初始化1：

int[][] arr = new int[3][2];
//定义了名称为arr的二维数组
//二维数组中有3个一维数组
//每一个一维数组中有2个元素
//一维数组的名称分别为arr[0],arr[1],arr[2]
//给第一个一维数组1脚标赋值为78写法是：
arr[0][1] = 78

2. 动态初始化2：只定义第一维的长度，第二维不定义。

int[][] arr = new int[3][];
//二维数组中有3个一维数组
//每个一维数组都是默认初始化值null
//可以对这3个一维数组分别进行初始化
arr[0] = new int[0];
arr[1] = new int[1];
arr[2] = new int[2];
//int[][] arr = new int[][3]; 非法

3. 静态初始化：

int[][] ii = new int[][]{
	{1,2};
	{4,2};
}

• 注意特殊写法情况：

int[] x,y[];//x是一维数组，y是二维数组

• java中多维数组不必都是规则矩阵形式

三、数组中涉及的常见算法

1、求数组元素的最大值、最小值、总和、平均数

int[] arr = new int[]{4,2,7,1,3,5};

//最大值
int max = arr[0];
for(int i = 0;i < arr.length;i++){
	if(max < arr[i]){
		max = arr[i];
	}
}
System.out.println("max:" + max);

//最小值
int min = arr[0];
for(int i = 0;i < arr.length;i++){
	if(min > arr[i]){
		min = arr[i];
	}
}
System.out.println("min:" + min);

//总和，平均数 
int res = 0;
for(int i = 0; i < arr.length; i++){
	res += arr[i];
}
System.out.println("总和:" + res);
System.out.println("平均数:" + (res / arr.length));//输出的是整数，一定能刚好除尽吗

2、数组的复制、反转

//复制
int[] copy = new int[arr.length];//声明一个与arr长度一致的数组
for(int i = 0; i < arr.length; i++){
	copy[i] = arr[i];
}

//反转
//int[] arr  = new int[]{4,2,7,1,3,5}
//声明一个数组temp，数组temp长度与arr长度一致，倒着循环arr，正着赋值给temp
//temp就是arr的倒序的数组，然后再把temp赋值给arr
int[] temp = new int[arr.length];
int k = 0;
for(int i = arr.length - 1; i >= 0; i--){
	temp[k] = arr[i];
	k++;
}
arr = temp;
for(int i = 0;i < arr.length; i++){
	System.out.println(arr[i]);
}

3、数组元素的排序

冒泡排序

• 排序思想：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。

• 序列：4，7，3，1

• 排序：

  • 第一轮：
    • 4，7，3，1
    • 4，3，7，1
    • 4，3，1，7
    • 第一轮得到一个最大的数字，放在倒数第一位
  • 第二轮：
    • 3，4，1，7
    • 3，1，4，7
    • 第二轮得到除最后一个数字之外的最大数字，放在倒数第二位
  • 第三轮：
    • 1，3，4，7
    • 第三轮得到除最后两个数字之外最大的数字，放在倒数第三位

//正序（从小到大排序）
int[] arr = new int[]{4,7,3,1};
int temp = 0;
for(int i = 0; i < arr.length - 1; i++){//外层循环是循环轮次，循环的次数是数字长度-1
	for(int j = 0; j < arr.length - 1 - i; j++){//每一轮次的数字对比排序，每轮比较的次数是数字长度-1-i
		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-1; i++){
	System.out.println(arr[i]):
}

//倒序（从大到小排）
int[] arr = new int[]{4,7,3,1};
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;
		}
	}
}
for(int i = 0; i < arr.length-1; i++){
	System.out.println(arr[i]):
}

四、数组操作常见问题

1、数组下标越界异常（ArrayIndexOutOfBoundsException）

//访问到了数组中不存在的脚标时发生
int[] arr = new int[2];
System.out.println(arr[2]);

2、空指针异常（NullPointerException）

//arr引用没有指向实体，却在操作实体中的元素时
int[] arr = null;
System.out.println(arr[0]);