第一个七天内容知识记录

1. GUI：图像化界面

2. JDK = JRE + Java的开发工具（java.exe，java.exe，javadoc.exe）
   JRE = JVM + Java核心类库

3. long类型的数据后面要以L结尾
   float类型的数据后面要以f或F结尾

4. 数据大小：byte、char、short<int<long<float<double

5. 位运算：<<、>>、>>>、&、|
   (左移)x<x*2的y次方；(右移)x>>y–>x/2的y次方；(无符号右移)

6. label标签：
   在break和continue后面加上label标签，为break和continue指定要跳出的循环是哪个，那个循环前要加上label:

7. Java的数组在内存空间中开辟一块连续的空间，元素的引用是根据第一个的首地址进行索引，类似于C语言的列表

8. 二维数组arr[4][5]：arr.length获取的是4，即第一层的数组长度；arr[1].length获取的是5，即第一层指向的数组的长度

9. 内存结构：

   栈(stack)：主要存放局部变量 
   堆(heap)：主要存放对象实例，几乎所有的对象实例都在这里分配内存
   方法区(method area)：
   	常量池
   	静态域
   	类加载的信息
   	即时编译器编译后的代码
   

   具体图解

   int arr = new int[4];
   arr[0] = 1;
   arr = new int[3];
   

   首先第一行语句，先在栈中创建一个空间，存放变量名arr和数组的首地址值；
   在堆中创建的数组实体，中间的值开始默认值都为0或者null，在第二行代码执行完之后，数组的第一个位置就存放了数值1；第三行代码将栈中arr空间中的地址值，改为int[3]的首地址值了，那么原来创建的int[4]就被视为垃圾，在某个不确定的时间会被Java垃圾自动回收机制给销毁。

   二维数组和一维数组类似，即每个一维数组的位置都存放了另一个一维数组的首地址值

   在Java中，如果创建的变量是个引用类型的变量（String、对象等），那么变量名所存储的要么是null，要么是内容所在的地址值；

10. 二维数组的声明特殊情况：int[] y[];

11. ①数组元素的赋值（杨辉三角、回形数等）
    ②求数值型数组中元素的最大值、最小值、平均数、总和等
    ③数组的复制、反转、查找（线性查找、二分法查找）
    ④数组元素的排序算法

一、创建一个长度为6的int型数组，要求数组元素值都在1-30之间，且是随机赋值，同时要求元素的值各不相同
#这道题不是特别的难，就是把握随机数的产生就行了。

class ArrayExer{
	public static void main(String[] args)
		int arr = new int[6];
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * 29) + 1;
			for(int j = 0;j < i;j++){
				if(arr[i] == arr[j]){
					i--;
					break;
				}
			}
		}
	}

}

二、回形数格式方阵的实现
从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出：

1 2 
4 3 

输入数字3，则程序输出：

1 2 3 
8 9 4 
7 6 5 

输入数字4， 则程序输出：

1   2   3   4 
12  13  14  5 
11  16  15  6 
10   9  8    7

class RectangleTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];

		int s = len * len;
		/*
		 * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
		 */
		int k = 1;
		int i = 0, j = 0;
		for (int m = 1; m <= s; m++) {
			if (k == 1) {
				if (j < len && arr[i][j] == 0) {
					arr[i][j++] = m;
				} else {
					k = 2;
					i++;
					j--;
					m--;
				}
			} else if (k == 2) {
				if (i < len && arr[i][j] == 0) {
					arr[i++][j] = m;
				} else {
					k = 3;
					i--;
					j--;
					m--;
				}
			} else if (k == 3) {
				if (j >= 0 && arr[i][j] == 0) {
					arr[i][j--] = m;
				} else {
					k = 4;
					i--;
					j++;
					m--;
				}
			} else if (k == 4) {
				if (i >= 0 && arr[i][j] == 0) {
					arr[i--][j] = m;
				} else {
					k = 1;
					i++;
					j++;
					m--;
				}
			}
		}

		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

三、数组的复制

int[] arr1 = {1,2,3,4,5,6,7};
int[] arr2 = arr1;

这个代码其实是arr1和arr2同时指向了同一个堆中的数组实体；
Java中=是先判断两端的类型是否相同或者可以强制转换，然后将右边的地址值给左边的变量；

四、数组的反转

int[] arr = {1,2,3,4,5,6,7};
for(int i = 0;i <= arr.length/2;i++){
	int temp = 0;
	temp = arr[arr.length - i - 1];
	arr[arr.length - i - 1] = arr[i];
	arr[i] = temp;
}

五、二分查找

//前提是所要查找数组必须是已经排好序了
int[] arr = {-98,-23,-3,24,68,87,92,103,147};
int dest = 0;
int head = 0;
int end = arr.length - 1;
boolean flag = false;
while(head <= end){
	int mid = (head + end)/2;
	if(dest == arr[mid]){
		System.out.print("找到了，在位置" + mid);
		flag = true;
		break;
	}else if(dest < arr[mid]){
		end = mid - 1;
	}else if(dest > arr[mid]){
		head = mid + 1;
	}
}
if(!flag){
	System.out.print("没有找到");
}

六、排序算法优劣的衡量指标：
时间复杂度、空间复杂度、稳定性

十大内部排序算法：
选择排序：直接选择排序、堆排序
交换排序：冒泡排序、快排
插入排序：直接插入排序、折半插入排序、shell排序
归并排序
桶排序
基数排序

冒泡排序：时间复杂度O(n²)

int[] arr = {13,35,6,35,86,-14,64,-64};
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]){
			int temp;
			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] + " ");
}

快排：时间复杂度O(nlog2n)

https://blog.csdn.net/v123411739/article/details/80071521
归并排序：时间复杂度O(nlog2n)

堆排序：时间复杂度O(nlog2n)

对于常见的排序注意事项：
如果n比较小，直接使用插入排序或者选择排序；
如果数组原本就具有一定的序列，可以使用冒泡、直接插入或者快排
如果n很大，那么就要使用堆排、归并或者快排。

#注意的是快排在最坏的情况下效率是不如归并和堆排的

12. Arrays工具类：
    boolean equals(int[] a,int[] b)：判断两个数组是否相等
    String toString(int[] a)：输出数组信息
    void fill(int[] a,int val)：将指定值填充到数组中
    void sort(int[] a)：对数组进行排序
    int binarySearch(int[] a,int key)：对排序后的数组进行二分法检索指定的值

13. 数组中常见的异常
    ①数组角标越界：ArrayIndexOutOfBoundsException

    数组索引超出了范围
    

    ②空指针异常：NullPointerException

    第一种情况：定义了数组变量但是赋值为空
    

    int[] arr = {1,2,3,4,5};
    arr = null;	
    System.out.print(arr[2]);
    
    int[] arr1 = new int[];
    System.out.print(arr[2]);
    

    第二种情况：二维数组只定义了外层，内层尚未定义，直接索引内层
    

    int[][] arr = new int[4][];
    System.out.print(arr[2][3]);//arr的第一层每个中间的值都还是null，无法进一步索引内层数组
    

    第三种情况：调用方法的对象是null
    

    String[] arr = new String[]{"AA","BB","CC"};
    arr[0] = null;
    System.out.print(arr[0].toString());//调用toString方法的arr[0]对象是null