【第五天】数组
复习：
1. 顺序结构：程序是从上到下从左到右依次编译运行的
2. 判断结构：if、if-else、if-else if
3. 选择结构：switch-case---switch所能选择的类型只有byte/short/char/int，JDK1.7及其以后允许使用String。break的位置会影响结果
4. 循环结构：while、do-while、for --- 定义循环变量，控制判断条件，改变循环变量
5. break和continue：break表示终止一层循环或者选择结构，continue表示跳出一层循环继续下次循环---支持标号
数组
是一个可以用于存储同一类型的多个数据的容器---大小固定
把存入数组的每个数据进行编号，这个编号称之为下标，下标是从0开始计算的
定义格式
数据类型 [ ] 数组名 = new 数据类型[数组的大小或元素的个数];---由于在编译时期并不确定具体的元素，所以这种方式称之为数组的动态初始化
int[] arr = new int[5];---表示定义了一个能存储5个整型元素的数组
arr[3] = 10; --- 表示想arr这个数组下标为3的位置上放入一个元素10
arr[4] = 14;
System.out.println(arr[3]);
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, ... 元素n};---数组的大小就是n---在编译的时候就已经确定每一个具体的元素，这种方式称之为数组的静态初始化
int[] arr = new int[]{2,1,6,3,8,3,7};---此时数组的大小就是7
数据类型[] 数组名 = {元素1, 元素2, ... 元素n};---不允许先声明初始化
int[] arr = {2,5,4,6,7,1,9};
数组的应用
1. 获取数组中的元素---数组名[下标]
2. 获取数组的长度---数组名.length
3. 遍历数组
// 实际上是先遍历下标，然后根据下标再来获取指定下标的元素
for(int i = 0; i <= arr.length - 1; i++){
System.out.println(arr[i]);
}
// 增强for循环---不能改变原数组
for(int i : arr){
System.out.println(i);
}
// 将数组转换为字符串来显示
String str = Arrays.toString(arr);
4. 获取最值（最大值/最小值）
5. 数组排序
for(int i = 1; i <= arr.length - 1; i++ ){
for(int j = 1; j <= arr.length - i; j++){
if(arr[j - 1] > arr[j]){
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
for(int i = 1; i <= arr.length - 1; i++){
for(int j = i + 1; j <= arr.length; j++){
if(arr[i - 1] > arr[j - 1]){
int temp = arr[i - 1];
arr[i - 1] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
Arrays.sort(要排序的数组); ---只能升序排列---O(nlogn)
6. 数组的反转
// 需要创建一个新的数组
int[] arr2 = new int[arr.length];
for(int i = 0; i < arr.length; i++){
arr2[arr.length - i - 1] = arr[i]
}
// 首尾交换
for(int start = 0, end = arr.length - 1; start <= end ; start++, end--){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
7. 数组元素的查找
// 如果数组无序，使用for循环来遍历查找
for(int i = 0; i < arr.length; i++){
if(arr[i] == n){
System.out.println(i);
break;
}
}
// 如果数组有序，可以使用二分查找/折半查找
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while(arr[mid] != n)
{
if(n < arr[mid])
{
max = mid - 1;
} else {
min = mid + 1;
}
if(min > max){
mid = -1;
break;
}
mid = (min + max) / 2;
}
System.out.println(mid);
8. 数组的复制
System.arraycopy(要复制的数组,从这个数组的哪一个下标开始复制, 要存放的新数组, 指明从新数组的哪个下标开始放, 要复制的元素的个数);
Arrays.copyOf(要扩容的数组, 容量的大小);--地址会发生改变---本质上就是在做数组的复制
注意：如果[]紧跟数据类型，那么数据类型之后定义的变量一定是一个数组；如果[]紧跟数组名，那么仅限于当前变量是一个数组而不影响其他的变量
内存
java会将内存划分为5块：栈内存、堆内存、方法区、本地方法栈、PC寄存器（程序计数器）
栈内存
用于存储变量的。变量在定义后存入栈内存，而栈内存不会给变量自动赋值。变量在用完之后会立即从栈内存中释放。
堆内存
存储的是对象。对象在存入堆内存之后，堆内存会给对象中的每个位置上一个默认值。byte/short/int - 0 , long - 0L , float - 0.0F , double - 0.0 , char - ‘\u0000’ , boolean - false , 凡是引用类型，默认值一律为null。对象在使用完成之后会在不确定的某个时刻被回收。
如果访问的下标超过界限，会出现ArrayIndexOutOfBoundsException---数组下标越界异常
二维数组
存储数组的数组---将一维数组看做元素放到另一个数组中，那么这个数组就是一个二维数组
定义格式
数据类型[][] 数组名 = new 数据类型[存储几个一维数组][一维数组能存储几个元素];
int[][] arr = new int[3][5];---定义了一个二维数组，这个二维数组中能存储3个一位数组，每个一维数组又能存储5个整型变量
arr[0][2] = 5;
数据类型[][] 数组名 = new 数据类型[存储的一维数组的个数][];
int[][] arr = new int[5][];---定义了一个二维数组，这个二维数组能存储5个整型的一维数组
arr[0] = new int[3];
arr[1] = new int[8];
arr[2] = new int[1];
数据类型[][] 数组名 = {{元素11，元素12,...},{元素21，元素22...},...};
int[][] arr = {{1,6,3}, {4,2,5}, {4,8}, {8,9,6,3,6}};---定义了大小为4的二维数组，其中的每个一维数组的元素已经确定
遍历二维数组：
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
for(int[] arr2 : arr){
for(int i : arr2){
System.out.println(i);
}
}
练习：杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
arr[i][j] = arr[i - 1][j] + arr[i - 1][ j - 1];
输入一个数字，输出对应的行数
明日内容：
方法---定义、注意事项、重载、递归
