尚硅谷Java学习笔记-基础部分-2

前言
记录没有条理性，记一些自己没怎么用过，但是比较重要的内容。所以不是那么全面。
因为自己有一些java基础，为秋招准备的。大家看看就好，有错误的地方欢迎指正。

本节内容：数组

一、数组

1、一维数组

• 声明与初始化：

int num = 10;
int[] id = new int[]{1,2,3,4,5};
int[] id = new int[5];  //未直接赋值，动态初始化
int[] id = {1,2,3,4,5}; //会自动识别类型
String[] names = new String[5];

• 使用: num[0]="张三"，遍历使用for循环，长度: names.length。
• 默认值：int-0，double-0.0，char-0(非‘0’)，boolean-false，引用数据类型-null
• 内存解析，直接上图。
  
• 上图左右分别为栈空间和堆空间，stack和heap。栈中存放局部变量，在main中定义的都是局部变量，而堆中存放new出来的结构，比如对象，数组。
• 再看右上角代码，先是静态初始化了一个arr数组，还有一个String字符串数组arr1，然后赋值，覆盖。
• 右侧的堆空间里，arr数组的三个框分别放入了000，因为初始化为123，所以改为123。框的0x34ab这样的16进制数是代表数组的首地址，存放在栈空间中。这样从栈空间里通过地址就可以访问实体值了。
• arr1本来初始化为null，后来其中某些位置的值改掉了，首地址也存在栈空间。后来又被覆盖掉，所以栈空间中的arr1地址就被换掉了。
• 关于垃圾回收：在0x12ab失去了栈空间的引用后，在某个不确定的时间，java中的引用计数算法就会回收掉堆空间中的空间占用。而整个main函数结束后，因为是局部变量，arr，arr1都会失去引用，所以对应的空间也会全部被回收。

二、二维数组

• 声明与初始化

int[] arr = new int[]{1,2,3};
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; //不用非常严格几行几列，在堆中存放的时候就是一维数组的拓展，每个元素的拓展不一定一样长。
//打印输出arr1.length,arr1[0].length为3，3，没填入的也不为0.
int[][] arr2 = new int[3][2]; //默认为0，string默认为null
int[][] arr3 = new int[3][]; //列可以不先列出来
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}}; //自动判别类型，且前面的两个[][]分开

• 调用:arr[0][0]，行数arr.length,列数arr[0].length
• arr3没有设定列，可以设定arr3[1] = new int[4];。输出有行数3，列数报错，可能是只定义了arr3的1号列的内容，0，2号列没定义类型大小等（以最宽的列作为列数），所以没法确定。
• 遍历，双层for循环。发现没有值的位置，也不会自动填充为刚好方正的表格。

for(int i = 0;i < arr1.length;i++)
	for(int j = 0;j < arr1[i].length;j++) //注意是arr1[i],不是arr[0],因为arr是不完整的。arr0报错越界
		System.out.print(arr1[i][j] + "  ");

• 默认初始化
  规定：二维数组分为外层数组的元素，内层数组的元素
  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，内层元素的初始化值为：不能调用，否则报错。

• 内存解析
  
  注意到每个行对应的列不一样长。行数组中存的是地址或者null，列数组中存放的就是正常一维。

二、数组的常见算法

1、常见题目

• 杨辉三角，回形数。数组的最大值，最小值，总和，平均数

2、数组的赋值和复制

//赋值：将arr1的数组的地址值给到了arr2，两者共同指向堆空间中同一实体。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2;
arr2 = arr1; //赋值轻松加愉快，不像c中一个个元素赋值

//复制:另起炉灶，arr1，2之间无关系
int[] arr2 = new int[arr1.length];
for(int i=0;i< arr1.length;i++)
	arr2[i] = arr1[i];

3、查找

• 线性，排序后用二分法

4、排序

• 冒泡，快排，堆排序，归并排序，希尔排序等
• 冒泡排序，两两比较

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
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; 
		}
	}
}

• 快排，设立基准点，比之大的放后面，比之小放前面，前后两个双指针

public static void quickSort(int[] arr,int start,int end) {
		int i = start, j = end, temp = arr[start];
		while (i < j) {
			while (i < j && arr[j] > temp) j--;
			while (i < j && arr[i] < temp) i++;
			if(i<j)swap(arr, i, j); // 交换元素
		}
		swap(arr, start, j); //此时ij在一起了
		
		// 递归调用，排序左子集合和右子集合
		quickSort(arr, start, i - 1);
		quickSort(arr, i + 1, end); 
	}

private static void swap(int[] arr, int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

• 二分查找，事先要排好序

public static int binarySearch(int[] arr , int value){
	int left = 0,right = arr.length-1;
    while(left <= right){
        int mid = (left+right)/2;
		if(value == arr[mid]) return mid;
		if(value > arr[mid]) left=mid+1;
		if(value < arr[mid]) right=mid-1;
	}
	return -1;//没有找到返回
}

三、Arrays工具类

import java.util.Arrays;

public class arrayTest{
	public static void main(String[] args){
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		
		Arrays.equals(arr1,arr2); //equals函数,看是否一样，返回TF
		
		Arrays.toString(arr1); //返回数组信息
		System.out.println(Arrays.toString(arr1));//如果展示单个元素就直接输出arr1[0],如果展示整个数组就需要toString，不用像c中的遍历后一个个输出
		
		Arrays.fill(arr1,10);//用10填充整个数组，覆盖之前的
		System.out.println(Arrays.toString(arr1));  //10101010，注意arr1.toString格式不对，是Arrays.toString(arr1)
		
		Arrays.sort(arr1); //排序
		Arrays.binarySearch(arr1,10) //数组和待查找的数，返回找到数的下标，未找到返回-1
}

四、数组常见异常

下标越界：ArrayIndexOutOfBoundsException
空指针：NullPointerException

• 情况1

//空指针1
int[] arr = new int[]{1,2,3,4};//如前，堆空间中有1234元素，栈空间中的arr指向他们
arr = null; //现在又设置为null，即arr无物可指，所以空指针错误
System.out.println(arr[0]);

• 情况2：二维数组只定义了行，却要访问行列某个元素，指针无处可指

不积跬步，无以至千里；不积小流，无以成江海。