Day2—流程控制、数组
流程控制
if-else
if( 条件表达式1 ){
执行代码块1
}else if( 条件表达式2 ){
执行代码块2
}else{
执行代码块3
}
- 条件表达式必须是布尔表达式，或者是布尔变量；
- 执行代码块只有一条执行语句时，{ }可以省略；
- if-else是“多选一”结构，因此else是可选的；
- 根据条件是“互斥”还是“包含”关系，各部分的条件表达式和执行代码块的顺序存在要求；
如果条件是“互斥”的，那没有顺序要求；
如果条件是“包含”的，那子级在上、父级在下；
switch-case
switch( 表达式 ){
case 常量1:
执行语句1;
break;
case 常量2:
执行语句2;
break;
case 常量3:
执行语句3;
break;
default:
执行语句1;
break;
}
- switch语句中，表达式的值必须是以下几种类型之一：
byte，short，char，int，枚举，String - case后面的常量必须是确定的值，不能是变量名或者表达式；
- break用来执行完一个case分支后跳出switch语句块，如果没有break，程序会自动执行到switch的结尾；
- default是可选的，位置也是灵活的，当没有匹配的case时，执行default后面的语句；
- 不同的case可以执行同一个语句，因此可以将case进行合并，比如：
switch(month){
case 3:
case 4:
case 5:
System.out.println("Spring");
break;
case 6:
case 7:
case 8:
System.out.println("Summer");
break;
case 9:
case 10:
case 11:
System.out.println("Autumn");
break;
case 12:
case 1:
case 2:
System.out.println("Winter");
break;
}
for
for ( 初始化部分 ; 循环条件部分 ; 迭代部分 ){
循环体
}
- for循环条件部分为boolean表达式，当值为false时，退出循环；
- 初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔；
- 迭代部分也可以有多个变量更新，用逗号分隔；
- 无限循环：
for( , , ){
循环体
} // 表达式中并没有语句，会导致无限循环下去
while/do-while
初始化部分
while( 循环条件部分 ){
循环体部分
迭代部分
}
初始化部分
do{
循环体部分
迭代部分
}while( 循环条件部分 )
- 两者的区别在于do-while在循环之前至少会执行一次循环体；
- 通过控制while的循环条件，可以造成无限循环：
while( true ){
循环体
}
嵌套
一个输出9*9乘法表的例子：
int num;
for(int i = 1; i <= 9; i++){
for(int j = 1; j <= i; j++){
num = i * j;
System.out.print(j + "*" + i + "=" + num + '\t');
}
System.out.print('\n');
}
break/continue
- 使用{ }定义的一段代码被称作代码块
- break可以终止并跳出当前所处代码块的执行；
- continue则可以跳过当前所处代码块的循环，直接进行下一次循环；
- break、continue之后不能有其它的语句，因为程序永远不会执行在其之后的语句；
数组
数组概述
- 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
- 数组的长度一旦确定，就不能修改。
一维数组
声明方式
// 数组声明；
int a[];
int[] a1;
//int a[5]; // 非法，声明数组时不能指定其长度
double b[];
String s[];
String[] s1;
// 理论上，type var[] 和 type[] var这两种方式没有什么区别；
初始化
java中使用new关键字来创建数组；
动态初始化：
int arr[] = new int[3];
arr[0] = 0;
arr[1] = 1;
arr[2] = 2;
String[] names;
names = new String[3];
names[0] = "kana";
names[1] = "omew";
names[2] = "yuki";
静态初始化：
int arr1[] = new int[]{0,1,2};
int arr2[] = {1,2,3};
String[] charas = {"甲","乙","丙"};
数组的引用
- 定义、并用运算符new为数组分配空间之后，才可以引用数组中的每个元素；
- 采用数组下标来引用数组元素，可以是整数常量或者整型表达式，数组的下标从0开始；
- 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度；
- 数组一旦初始化，长度是不可变的；
for(int i = 0; i<names.length; i++ ){
System.out.println(names[i]);
}
数组元素默认初始化值
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
数组元素默认初始化值
内存解析图（例）
一维数组的内存解析
多维数组
数组中的数组：对于二维数组的理解，可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，并没有多维数组。
初始化
动态初始化：
// 动态初始化，格式1
int[][] arr = new int[3][2];
int arr1[][] = new int[3][2];
// 动态初始化，格式2
int[][] arr2 =new int[3][];
arr2[0] = new int[1];
arr2[1] = new int[2];
arr2[2] = new int[3];
// int[][] arr3 = new int[][3]; // 非法
静态初始化：
// 静态初始化
int[][] arr4 = new int[][]{{2,3},{4,5,6},{7,8,9}};
java中的数组不一定都是规则的矩阵形式
多维数组的使用
for(int i = 0; i < arr4.length; i++){
for(int j =0; j < arr4[i].length; j++)
System.out.print(arr4[i][j] + " ");
System.out.print('\n');
}
本质上还是对数组下标的引用，与一维数组不同的是多维数组的循环为嵌套；
数组声明方式总结
一维数组：int x[ ] 或者 int[ ] x；
二维数组：int y[ ][ ] 或者 int[ ][ ] y 或者 int[ ] y[ ]；
二维数组内存解析图（例）
二维数组内存解析图
数组涉及的常见算法
复制数组
int[] array1, array2;
array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
array2 = array1;
这样是不行的，表面上看数组array2的元素确实跟数组array1的元素一样，但这其实是复制了array1引用地址的结果，两个数组在内存中指向的是一个空间。这就导致了：如果你对数组array2的元素进行修改，同样也会影响到array1的元素。
直接复制的内存解析
正确的方法是，采用循环的方式对array2中的元素逐一进行复制操作：
//复制array1数组给array2
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
逐一复制的内存解析
二分查找
二分查找
这里需要注意的是：循环停止的条件
理论上说，无论head和end的值怎么改变，都不可能出现head > end 的情况，因为这跟数组的基本结构是矛盾的；同时在每一次二分查找后，都会执行 end = middle - 1 或者 head = middle + 1 ，来确保程序正常运行。
冒泡排序
int temp;
for(int j = 1; j < arr.length; j++ ){ // 外层循环是冒泡操作的次数
for(int i = 0; i < arr.length - j; i++){ // 内存循环是相邻两个元素做比较的次数
if(arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
冒泡排序的本质是比较相邻的两个元素，如果第一个比第二个大，就对其进行交换（升序）；
对每一组相邻的元素做相同的操作，从:
a[1] 和 a[2]
a[2] 和 a[3]
... ...
a[n-1] 和 a[n]
完成以上这个比较流程，最后的a[n]一定是最大的数，到此为止，执行了一次冒泡操作；
每执行一次冒泡操作后，除了最后一个元素，针对剩下的元素重复以上操作，直到没有任何一对数字需要比较为止。
Arrays工具类
Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法；
使用时，必须在声明import java.util.Arrays;
Arrays工具类
表格中的数据类型为执行了此工具类方法后返回的值类型：
// Arrays工具类
int[] arr1 = new int[]{1,3,5,7,9};
int[] arr2 = new int[]{1,3,5,7,9};
System.out.println(Arrays.equals(arr1,arr2)); // true
System.out.println(Arrays.toString(arr1)); // [1, 3, 5, 7, 9]
Arrays.fill(arr2, 0);
System.out.println(Arrays.toString(arr2)); // [0, 0, 0, 0, 0]
int[] arr3 = new int[]{-12,-90,5,2,88,60,-17,-44,46,80,32,11,7};
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3)); // [-90, -44, -17, -12, 2, 5, 7, 11, 32, 46, 60, 80, 88]
System.out.println(Arrays.binarySearch(arr3, 11)); // 7
System.out.println(Arrays.binarySearch(arr3, 10)); // -8 随机返回一个负数值
数组使用的常见异常
此异常编译时不会报错，只有执行编译后的程序才会出现提示信息：
常见异常
