05、数组

数组

存储相同数据类型的多个元素的容器
每个元素都有编号（专业名称：索引）
最小索引值：0
最大索引值：数组长度 – 1
定义格式：
数据类型[] 数组名 推荐
数据类型 数组名[]
初始化（为数组元素分配内存空间并且赋值）：
动态：
只给出长度，长度数值写在[]里，Java 会给出默认值
int[] arr = new int[2]; 2个值都是0
静态：
给出值，系统来决定长度，元素值写在{}里
int[] arr = {1,2};

数组常见的2个问题点（异常）

ArrayIndexOutOfBoundsException：数组索引越界异常
原因：访问了不存在的索引值
NullPointerException：空指针异常
原因：数组变量已经不再指向堆内存空间了，还用数组访问数组元素

一维数组定义

需要一个容器，但是不明确容器的具体数据
int[] arr = new int[3];

需要一个容器，存储已知的具体数据
//元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{89,34,270,17};
int[] arr = {89,34,270,17};

对数组操作最基本的动作就是存和取
核心思想：就是对角标的操作

遍历一维数组数组

for(int x=0; x<arr.length; x++){
	System.out.println(arr[x]+" ");
}

二维数组定义

创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素

int[][] arr = new int[3][2];
int[][] arr2= {{456,342,54},{457,63,45},{43,56}};

遍历二维数组

for(int x=0; x<arr.length; x++){
	for(int y=0; y<arr[x].length; y++){
		System.out.print(arr[x][y]+",");
	}
}

常见异常

ArrayIndexOutOfBoundsException
//当访问到数组中不存在的角标时，就会发生该异常

NullPointerException
//当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常

遍历

两种遍历方式
用 for 循环

int[] a = { 6, 8, 23, 97 ,8,9};
for (int i = 0; i < a.length; i++) {//index
	//a[i]=10;//修改了a中的所有数据
	System.out.println(a[i]);
}

用 foreach 循环（增强for循环）

for (int item : a) {//item
//item=10;//改的只是item这个变量，a这个数组中的元素没有影响
System.out.println(item);	
}

冒泡排序

public static void bubbleSort(int[] arr) {
	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]){
				int temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
	printArray(arr);
}

选择排序

public static void choiceSort(int[] arr) {
	for (int i = 0; i < arr.length-1; i++) {
		for (int j = i+1; j < arr.length; j++) {
			if(arr[i]>arr[j]){
				int temp=arr[i];
					arr[i]=arr[j];
				arr[j]=temp;
			}
		}
	}
	printArray(arr);
}

二分查找

public static int getIndex(int[] arr, int searchVaule) {
	// 1: 定义最大,最小索引值
	int max = arr.length - 1;
	int min = 0;

	// 2: 计算出中间索引值
	int mid = (max + min) / 2;

	// 拿中间索引值和要查找的元素比较:
	while (arr[mid] != searchVaule) {
		if (arr[mid] > searchVaule) {
			// 大于要查找的元素: 在中间索引的左边再继续二分查找
			max = mid - 1;
		} else if (arr[mid] < searchVaule) {
			// 小于要查找的元素: 在中间索引的右边再继续二分查找
			min = mid + 1;
		}
		if(min > max){
			return -1;
		}			
		mid = (max+min)/2;
	}
	return mid;
}