四、流程控制与数组
4.1、顺序结构：程序从上到下，一行一行执行。
4.2、分支结构：
4.2.1、if条件语句：
使用 布尔表达式 或 布尔值 作为分支条件来进行分支控制。
注意1：使用 if else 语句基本规则：总是优先把包含范围小的条件放在前面处理。
1）、if(){...}， 2）、if(){...}else{...}， 3）、if(age>60){ System.out.println("老年人"); }else if(age>40){ System.out.println("中年人"); }else if(age>20){ System.out.println("青年人"); } 等同于： if(age>60){ System.out.println("老年人"); }else if(age>40 && !(age>60)){ //else的含义是"否则"，隐含条件是：对前面的条件取反 System.out.println("中年人"); }else if(age>20 &&!(age>60) && !(age>40 && !(age>60)){ //else的含义是"否则"，隐含条件是：对前面的条件取反 System.out.println("青年人"); }
4.2.2、switch分支语句：
switch语句由一个控制表达式和多个case标签组成。
注意1：控制表达式的数据类型只能是：byte、short、char、int 四种整数类型，枚举类型 和 String类型（从Java 7才允许)。
注意2：case后面的break不要省略，否则会继续执行后面的代码(不会再去判断后面的case、default条件)。
public class TestSwitch{ public static void main(){ char score = ‘C‘; switch(score){ case ‘A‘: System.out.println("优秀"); break; case ‘B‘: System.out.println("良好"); break; case ‘C‘: System.out.println("一般"); break; case ‘D‘: System.out.println("及格"); break; case ‘E‘: System.out.println("不及格"); break; default: System.out.println("输入有误"); } } }
4.3、循环结构
4.3.1、while、do while 循环
注意1：while循环，先判断循环条件，为真则执行循环体；
注意2： do while循环，先执行循环体，然后判断循环条件，为真则执行下一次循环，否则中止循环（至少执行一次）；
注意3：循环条件一定要保证有变成false的时候，否则死循环。
public class TestWhile{ public static viod main(String[] args){ //1、while循环，先判断循环条件，为真则执行 int count = 0; //初始化语句 while(count<10){ //循环条件，一定要保证有变成false的时候，否则死循环 //循环体 System.out.println(count); count++; //迭代语句 } System.out.println("while循环结束!"); //2、do while循环，先执行循环体，然后判断循环条件，为真则执行下一次循环，否则中止循环 int sum= 1; //初始化语句 do{ //循环体 System.out.println(sum); sum++; //迭代语句 } while(sum<10);//循环条件，一定要保证有变成false的时候，否则死循环 System.out.println("do while循环结束!"); } }
4.3.2、for、增强for、foreach循环
效率：foreach(方式5) > 增强for循环(方式4) > 普通for循环
public class TestFor{ //方式1：最普通for循环 public static void test1(List<String> list) { for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } //方式2：稍微高级一点 public static void test2(List<String> list) { for (int i = 0,lenth=list.size(); i < lenth; i++) { System.out.println(list.get(i)); } } //方式3：Iterator遍历 public static void test3(List<String> list) { Iterator<String> iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } //方式4：增强for循环,效率很棒 public static void test4(List<String> list){ for(String str:list){ System.out.println(str); } } //方式5：java8以后新增forEach循环,效率最好但不方便计数(lambda表达式) public static void test5(List<String> list){ //list.forEach(System.out::println);和下面的写法等价 list.forEach(str->{ System.out.println(str); }); } //方式6 public static void test6(List<String> list) { list.iterator().forEachRemaining(str->{ System.out.println(str); }); } }
4.4、控制循环结构
4.4.1、使用 break 结束循环
break 用于完全结束一个循环，跳出循环体；
break 还能结束其所在的外层循环（这时需要在break后面紧跟一个标签，该标签必须放在循环语句前面，用于标识一个外层循环）；
public class TestBreak{ public static void main(String[] args){ //1、一个简单的for循环，break结束一个循环 for(int m=0; m<5; m++){ System.out.println("m的值是："+ m); if(m==1){ break; //执行该语句时将结束for循环 } } /*
运行结果： m的值是：0 m的值是：1 */ //2、break配合标签使用，可以结束一个其外层的循环 //外层循环，outer作为一个标识符，后面是冒号(:) outer: for(int i=0; i<5; i++){ //内层循环 for(int j=0; j<3; j++){ System.out.println("i的值是："+ i+ "， j的值是："+ j); if(j==1){ break outer; //跳出outer标识的循环 } } } /*
与continue的区别：i>0后面的值不会执行
运行结果： i的值是：0， j的值是：0 i的值是：0， j的值是：1 */ } }
4.4.2、使用 continue 结束本次循环
continue 用于中止本次循环（略过本次循环剩下的语句），开始下一次循环；
continue 也能中止其所在的外层循环（这时需要在continue后面紧跟一个标签，该标签必须放在循环语句前面，用于标识一个外层循环）；
public class TestContinue{ public static void main(String[] args) { //外层循环，outer作为一个标识符，后面是冒号(:) outer: for(int i=0; i<3; i++) { //内层循环 for(int j=0; j<2; j++) { System.out.println("i的值为：" + i + "， j的值为：" + j); if(j==1) { //跳出outer标签所指定的循环 continue outer; } } } /*
与break的区别：i>0后面的值也执行了
运行结果如下： i的值为：0， j的值为：0 i的值为：0， j的值为：1 i的值为：1， j的值为：0 i的值为：1， j的值为：1 i的值为：2， j的值为：0 i的值为：2， j的值为：1 */ } }
4.4.3、使用 return 结束方法
4.5、数组
数组也是一种数据类型（引用类型）；
必须先定义、初始化数组(分配内存空间和赋初始值)，然后才能使用数组。
静态初始化：
int[] intArr = new int[]{ 2, 4, 6, 8, 10 } //初始化时，只指定数组元素的初始值，不指定数组长度
Object objArr = new String[]{ "Java", "Python" } //初始化时，元素类型可以是定义时的子类
动态初始化：只指定数组的长度，系统为每个数组元素赋初始值。
int[] intArr = new int[5];
Object objArr = new String[4];
JDK1.5提供了foreach循环(此处应该是增强的for循环)，遍历数组和集合时：无需获得数组长度，无需根据索引访问数组元素，无需循环条件，无须循环迭代语句。
public class TestForEach{ public static void main(String[] args){ String[] books = {"语文", "数学", "英语" }; //使用foreach循环来遍历数组元素：无需获得数组长度，无需根据索引访问数组元素，无需循环条件，无须循环迭代语句 for(String book : books){ System.out.println(book); } } }
4.6、深入数组
4.6.1、内存中的数组
数组 是一种引用数据类型，数组引用变量 存储在 栈(stack)内存 中，实际的数组元素存储在 堆(heap)内存 中。
数组 只能通过 引用变量 访问 堆内存中的数组元素；
栈内存：存放数组变量
堆内存：存放对象，以便反复利用。
4.6.2、基本类型数组的初始化
4.6.3、引用类型数组的初始化
4.6.4、操作数组的工具类
原文：https://www.cnblogs.com/mingyue1818/p/14435946.html