总结java学习（B站狂神说和动力节点老杜）——day5数组和八大算法

Java数组

数组概述

数组的定义

具有相同类型的一组数据的有序集合

---

数组的声明和创建

数组的声明

/dataType：int, double, float/

1. 首选方法

   dataType[] arrayRefVar;

2. 效果相同，但是不推荐

   dataType arrayRefVar[];

数组的创建

dataType[] arrayRefVar = new dataType[arraysize];

ex: int[] numbers = new int[10];

数组长度的获取

arrays.length;//返回值是一个int

内存图分析

1. 声明数组

   int[] array = null;

2. 创建数组

   array = new int[10];

三种初始化

静态初始化

int[] a = {1, 2, 3};

Man[] max = {new Man(1, 1),new Man(2, 2)};

动态初始化

int[] a = new int[2];

a[0] = 1;

a[1] = 2;

数组的默认初始化

数组是引用数据类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被系统赋予默认值

---

数组边界

ArrayIndexOutOfBoundsException

数组下标越界异常

小结

1. 数组是相同数据类型
2. 数组也是对象。数组元素相当于对象的成员变量
3. 数组长度是确定的，不可变的。

---

总结

数组的四个基本特点

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2. 其元素必须是相同的类型，不允许出现混合类型

3. 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

4. 数组变量属于引用数据类型，数组对象可以看成是对象，数组中的每个元素相当于该对象的成员变量。

   数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，

   对象本身是在堆当中的。

---

数组的使用

普通for循环

for-Each循环

for ( 变量类型  变量名 : 数组名 ) {
    
    需要执行的循环语句;
 
}

boolean found = false;
	for ( int k : data ) {
		if ( k==x ) {
			found = true;
			break;
		}
	}

数组作方法入参

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};  
    
        int[] result = reverse(array);
    
        for (int i : result) {
            System.out.println(i);
        }
 }
public static int[] reverse(int[] arrays){
    
	int[] result = new int[arrays.length];
    
	for (int i = 0; i < arrays.length; i++) {
		result[i] = arrays[arrays.length - 1 - i];
	}
	return result;
}

数组作为返回值

---

多维数组★★★★★

数组中的元素是数组

二维数组

int[][] array = {{1, 2},{3, 4},{5, 6}};

遍历二维数组的元素

1. 直接打印array[i]

   for (int i = 0; i < array.length; i++) {
   	System.out.println(array[i]);
   }
   /*[I@119d7047
   [I@776ec8df
   [I@4eec7777*/
   

   打印出来的是数组每行首个元素在堆中的地址

   以下代码效果相同

   for (int[] ints : array) {
   	System.out.println(ints);
   }
   

2. 正确打印

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

   以下代码效果相同

   for (int[] ints : array) {
   	for (int i : ints) {
   		System.out.println(i);
   	}
   }
   

---

Arrays类

打印数组元素

注意：Arrays.toSrting(数组名)；只能打印一维数组的元素，如果是二维数组，要打印，那么必须要降维

1. 一维数组

   int[] array2 = {1, 2, 3, 4};
   System.out.println(Arrays.toString(array2));
   /* [1, 2, 3, 4]*/
   

2. 二维数组

   int[][] array = {{1, 2}, {3, 4}, {5, 6}};
   for (int[] ints : array) {
   	System.out.println(Arrays.toString(ints));
   }
   /*[1, 2]
   [3, 4]
   [5, 6]*/
   

排序数组元素

注意：Arrays.sort(数组名)；只能排序一维数组的元素，如果是二维数组，要排序，那么必须要降维，并且排序只排序一维数组，调换二维数组顺序之后，没有作用

int[] array2 = {5, 9 ,654 ,8};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));
/*[5, 8, 9, 654]*/

填充数组元素

Arrays.fill(数组名，想要填满的数字);

int[] array3 = new int[8];
Arrays.fill(array3,9);
System.out.println(Arrays.toString(array3));
/*[9, 9, 9, 9, 9, 9, 9, 9]*/

---

八大排序算法★★★★★

冒泡排序

从头开始比较两个相邻数的大小，按照定好的顺序（从大到小或者从小到大的顺序）判断是否需要在数组中交换两个数

第一轮会找出一个最大（或最小）的值并且已经放放到了数组的第一位（或者最后一位），那么第二轮就不需要比较这个数了，比较次数减少1

第二轮也会找出一个最大（或最小）的值并且已经放放到了数组的第二位（或者最后第二位），那么第三轮就不需要比较这两个数了，比较次数减少2

…

int[] array = {5, 9 ,654 ,8, 984, 12 ,4, 6, 21};
int flag = array.length - 1;
for (int i = 0; i < array.length; i++) {
	for (int j = 0; j < flag - i; j++) {
		if (array[j] > array[j + 1]) {
			int temp = array[j];
			array[j] = array[j + 1];
			array[j + 1] = temp;
		}
	}
}
System.out.println(Arrays.toString(array));

选择排序

每此都从数组中剩余的数中选择一个最小（最大）的数，放在数组最前(最后)

int[] array = {5, 9 ,654 ,8, 984, 12 ,4, 6, 21};
for (int i = 0; i < array.length; i++) {
	int min = i;
	for (int j = i + 1; j < array.length; j++) {
		if (array[min] > array[j]){
			min = j;
		}
	}
	int temp;
	temp = array[i];
	array[i] = array[min];
	array[min] = temp;
}
System.out.println(Arrays.toString(array));

直接插入排序(二分法优化)

把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程

int[] array = {5, 9, 654, 8, 984, 12, 4, 6, 21};
int low, high, mid;//将mid设置为哨兵
for (int i = 1; i < array.length; i++) {
    low = 0;
    high = i - 1;
    mid = (low + high) / 2;
    if (array[i] >= array[high]) {
        continue;
    }
    while (high >= low) {
        if (array[i] > array[mid]) {
            low = mid + 1;
            mid = (low + high) / 2;
        } else if (array[i] < array[mid]) {
            high = mid - 1;
            mid = (low + high) / 2;
        }
    }
    if (array[i] >= array[mid]) {
        int temp = array[i];
        for (int j = i; j > mid + 1; j--) {
            array[j] = array[j - 1];
        }
        array[mid + 1] = temp;
    } else {
        int temp = array[i];
        for (int j = i; j > mid ; j--) {
            array[j] = array[j - 1];
        }
        array[mid] = temp;
    }
}
System.out.println(Arrays.toString(array));