1. 数组的概念
数组：一组无序的同类数据，在内存中连续存放形成的一种数据结构。
与数组对应的另一个基本数据结构是：链表
链表：一组无序的同类数据，在内存中分散存放形成的一种数据结构。
2. 一维数组的声明和使用
一维数组是一种“线性结构”
2.1 一维数组的声明和初始化
- 声明
int[] a;
或
int a[];
推荐使用第一种方式
- 初始化
数组的特点：定长的，初始化后不可更改长度，要求在初始化时必须指定长度（最大存储量）
示例1：声明了一个可以最多存储5个数字的数组，此时没有指定具体数字，int类型默认值为0，数组中相当于存储了5个“0”。
int[] a = new int[5];
示例2：声明了一个可以最多存储5个数字的数组，此时指定了具体的数字分别是1,2,5,12和7
int[] b = {1,2,5,12,7};
int[] c = new int[]{1,2,5,12,7};
2.2 一维数组的访问
需要通过下标去访问数组中的某个元素
下标：从0开始，下标最大值是（数组的长度-1） [0, 最大长度-1]
示例3：查看数组中的第2个元素
System.out.println(a[1]);
示例4：修改数组中的第4个元素的值为35
a[3] = 35;
如果使用了一个超过下标范围的数字作为数组下标使用，代码会发生问题。
比如长度是5的数组a，最大下标是4，访问a[5]就会发生下述异常
java.lang.ArrayIndexOutOfBoundsException：数组下标越界异常
2.3 遍历数组
访问数组中的所有元素
数组属性 a.length 表示数组的长度
int[] a = {23,12,11,15,28,42,31,55,8,17,12};
for(int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
示例5：给定数组 {23,12,11,15,28,42,31,55,8,17,12}，请计算平均值
int[] a = {23,12,11,15,28,42,31,55,8,17,12};
int sum = 0;
for(int i = 0; i < a.length; i++) {
sum += a[i];
}
int avg = sum / a.length;
System.out.println(avg);
示例6：找到数组中的最小值
int[] a = {23,12,11,15,28,42,31,55,8,17,12};
int min = a[0];
for(int i = 1; i < a.length; i++) {
if(a[i] < min) {
min = a[i];
}
}
System.out.println(min);
2.4 一维数组的内存分配
任何数组都属于引用数据类型
3. 多维数组的声明和使用(了解)
多维数组可以理解为：
二维数组是一种类似“表结构”
三维数组是一种类似“空间结构”
更高维的数组在现实世界中很少意义
实际上，多维数组是：数组类型的数组
以二维数组为例理解多维数组的概念
3.1 二维数组的声明和初始化
3.1.1 二维数组的声明
int[][] a;
或
int a[][];
或
int[] a[];
推荐使用第一种方式声明二维数组
3.1.2 二维数组的初始化
指定第一维的长度和第二维的长度
int[][] a = new int[3][4];
指定第一维的长度而不指定第二维的长度
int[][] a = new int[3][];
不允许在未指定第一维时，直接指定第二维
不允许两个维度的长度都不指定
下面这个是一个错误的示例
int[][] a = new int[][4]; //错误示例！！
int[][] a = new int[][]; //错误示例！！
可以直接数字的初始化，初始化了一个3x4的数组
第一维的长度为3，第二维的长度为4
int[][] a = {{1,2,3,4},{5,6,7,8},{1,4,2,8}};
| 1 | 2 | 3 | 4 |
| 5 | 6 | 7 | 8 |
| 1 | 4 | 2 | 8 |
初始化一个“锯齿数组”
int[][] a = {{1,2,3},{5,6,7,8,9},{1,4,2,8}};
int[][] d = new int[][]{{1,2,3},{5,6,7,8,9},{1,4,2,8}};
| 1 | 2 | 3 | ||
| 5 | 6 | 7 | 8 | 9 |
| 1 | 4 | 2 | 8 |
3.2 二维数组的遍历
二维数组a中
a.length得到第一维长度、
a[i].length对应的二维长度
int a[][] = {{1,2,3},{5,6,7,8,9},{1,4,2,8}};
for(int i = 0; i < a.length; i++) {//遍历第一维
for(int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]);
System.out.print("\t");
}
System.out.println();
}
3.3 二维数组的内存分配
4. 数组的排序（十分重要）
一维数组的内部排序
内部排序指的是不借助其他数组完成数组内部排序
4.1 冒泡排序法（笔试重点）
冒泡排序是一种稳定排序，两个相同数字的相对位置不会发生改变
所谓稳定"{12(a),11,15,6,2,9,12(b),7}"
稳定排序的结果一定是"{2,6,7,9,11,12(a),12(b),15}"
不稳定排序结果不一定是这样
数组中，相邻两个数进行比较，较大数放在后面，不断地进行这个过程。最大的数就会被放到结尾（升序）
冒泡排序法一个数的示例图
类似地继续地从头冒第二个数，第三个数...直到将所有的数字都放在合适的位置上
推导代码：
public class Test1 {
public static void display(int[] a) {
for(int t : a) {
System.out.print(t);
System.out.print("\t");
}
System.out.println();
}
public static void main(String[] args) {
int[] a = {15,7,22,14,8,16,10};
int temp = 0; //temp表示临时的意思 用于交换数字
System.out.println("第一个数===================================");
display(a);
for(int j = 0; j < a.length-1; j++) {
if(a[j] > a[j+1]) {
//交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
display(a);
}
System.out.println("第二个数===================================");
display(a);
for(int j = 0; j < a.length-2; j++) {
if(a[j] > a[j+1]) {
//交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
display(a);
}
System.out.println("第三个数===================================");
display(a);
for(int j = 0; j < a.length-3; j++) {
if(a[j] > a[j+1]) {
//交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
display(a);
}
}
}
更改为循环方式，最终代码：
int temp = 0;
for(int i = 1; i < a.length; i++) {
for(int j = 0; j < a.length-i; j++) {
if(a[j] > a[j+1]) {
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
4.2 选择排序法
选择排序是一种不稳定排序，两个相同数字的相对位置可能发生改变
从第一个位置起，将所有其他位置的数字与该位置进行比较，如果其他位置上的数字小于第一个位置，就进行交换。
int temp = 0; //temp表示临时的意思 用于交换数字
for(int i = 0; i < a.length; i++) {
for(int j = i+1; j < a.length; j++) {
if(a[j] < a[i]) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
