第3章数组

 for(int i = 0;i < arr4.length;i++ ) {
    for(int j = 0;j < arr4[i].length;j++) {
        System.out.print(arr4[i][j] + " ");
     }
       System.out.println();
 }

规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3]; 外层元素：arr[0],arr[1]等内层元素：arr[0][0],arr[1][2]等

⑤数组元素的默认初始化值

针对于初始化方式一：如int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：如int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

⑥数组的内存解析

四、数组中常见的异常

1.数组角标越界的异常

ArrayIndexOutOfBoundsExcetion

2.空指针异常

NullPointerException

五、算法

数据结构：

1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多

2.数据的存储结构：

①线性表：顺序表（比如：数组）、链表、栈、队列

②树形结构：二叉树

③图形结构：

算法：排序算法 \ 搜索算法

数组中涉及的常见算法：

1.数组元素的赋值（杨辉三角、回形树等）

2.求数值型数组中元素的最大值、最小值、平均数、总和等

3.数组的复制、反转、查找（线性查找、二分法查找）

4.数组元素的排序算法

/*
 * 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋予一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值。
 * 要求：所有随机数都是两位数。
 * 
 * [10,99] 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++) {
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++) {
			if(maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++) {
			if(minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		
		//求数组元素的总和
		int sum = 0;
		for(int i = 1;i < arr.length;i++) {
				sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

/*
 * 算法的考察：数组的复制、反转、查找（线性查找、二分法查找）
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		
		String[] arr = new String[] {"DD","WW","RR","GG","YY","HH"};
		
		//数组的复制（区别于数组变量的赋值：arr1 = arr）
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++) {
			arr1[i] = arr[i];
		}
		
		
		//数组的反转
		//方法一
		/*for(int i = 0;i < arr.length / 2;i++) {
			String temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}*/
		
		/*//方法二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--) {
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}*/
		
		//遍历
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println();
		//查找(或搜索)
		//线性查找
		String dest = "RR";
		boolean isFlag = true;
		for(int i = 0;i < arr.length;i++) {
			if(dest.equals(arr[i])) {
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if(isFlag) {
			System.out.println("很遗憾，没有找到！");
		}
		
		//二分法查找
		//前提：所要查找的数组必须有序
		int[] arr2 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 =  -34;
		int head = 0;//初始的首索引
		int end = arr.length - 1;//初始的末索引
		boolean isFlag1 = true;
		while(head <= end) {
			int middle = (head + end) / 2;
			if(dest1 == arr2[middle]) {
				System.out.println("找到了指定位置，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1) {
				end = middle - 1;
			}else {//arr2[middle < dest1
				head = middle + 1;
			}
		}
		if(isFlag1) {
			System.out.println("很遗憾，没有找到！");
		}
	}
}

十大内部排序算法

选择排序：直接选择排序、堆排序

交换排序：冒泡排序、快速排序

插入排序：直接插入排序、折半插入排序、Shell排序

归并排序

桶式排序

基数排序

/*
 * 数组的冒泡排序的实现
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		int[] arr =  new int[] {43,32,76,-98,0,64,33,-21,32,99};
		
		//冒泡排序
		for(int i = 0;i < arr.length - 1;i++) {//例：8个元素就是7轮
			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;
				}
			}
		}
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
	}
}

六、java.util.Arrays

/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 * 
 */
public class ArrayTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数是否相等。
		int[] arr1 = new int[] {1,2,3,4};
		int[] arr2 = new int[] {1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数信息。
		System.out.println(Arrays.toString(arr1));
		
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));
		
		//4.void sort(int[] a)：对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key):对排序后的数组进行二分法检索指定的值。
		int[] arr3 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 211);
		if(index >= 0) {
			System.out.println(index);
		}else {
			System.out.println("未找到");
		}
	}
}