第四章 流程控制

第四章 流程控制语句

4.1 true和false

所有条件语句都利用条件表达式的真或假来决定执行路径。
Java中不允许将一个数字作为布尔值

4.2 if-else

if-else语句是流程语句中最基本的。其中else可选

//第一种
if(Boolean-expression)
	statement
//第二种
if(Boolean-expression)
	statement
else
	statement	

布尔表达式必须产生一个布尔结果

public class Demo{
	static int result = 0;
	static void test(int testval, int target){
		if(testval > target)
			result = +1;
		else if(testval < target)
			result = -1;
		else 
			result = 0;
		
	}
	public static void main(String args[]){
		test(10, 5);
		System.out.println(result);
		test(5, 10);
		System.out.println(result);
		test(5, 5);
		System.out.println(result);
		
	}
}

4.3 迭代

迭代语句：

1. while
2. do-while
3. for
   语句会重复进行，直到起控制作用的布尔表达式得到假的结果才会停止
   while：

while(Boolean-expression)
	statement

在循环刚开始的时候会计算一次布尔表达式；而在语句的下一迭代开始前再进行一次

public class Demo{
	public static void main(String args[]){
		while(condition())
			System.out.println("Inside while");
		System.out.println("Outerside while");
	}
	static boolean condition(){
		boolean result = Math.random() < 0.99;//生成的值小于0.99 true
		System.out.println(result);
		return result;
	}
}

4.3.1 do-while

do
	statement
while(Boolean-expression)	

do-while里面的语句至少会执行一次，即使第一次表达式是false

4.3.2 for

在使用第一次之前要进行初始化，随后进行条件测试，在每一次迭代结束后，进行步进

for(initialization; Boolean-expression; step)
	statement

三个地方都可以为空
执行流程：迭代之前测试布尔表达式，结果false，执行for后面的代码（只要true，就会一直执行for循环里面的语句）。每次循环结束之后，都会执行一次步进。

public class Demo{
	public static void main(String args[]){
		for(char c = 0; c < 128; c++)
			if(Character.isLowerCase(c))
			System.out.println((int)c +" "+c)u;
	}
}

练习一：打印1到100

public class Demo{
	public static void main(String args[]){
		for(int i = 1; i <= 100; i++)
			System.out.println(i);
	}
}

练习二 产生25个int类型的数据，对于每一个数，使用if-else将其分类大于，小于，或者紧随它产生的随机数

import java.util.Random;
public class Demo{
	public static void main(String args[]){
		Random rand = new Random();
		int pre = 0;
		int next ;
		for(int i = 0; i < 25; i++){
			next = pre;
			pre = rand.nextInt();
			System.out.println(pre);
			System.out.println(next);
			if(pre > next){
				System.out.println("第"+i+"大于");
			}else if(pre == next){
				System.out.println("第"+i+"等于");
			}else{
				System.out.println("第"+i+"小于");
			}
		}
	}
}

练习三：修改练习二，将代码用一个while无限循环包括起来，然后通过ctrl+c停止

import java.util.Random;
public class Demo{
	public static void main(String args[]){
		Random rand = new Random();
		int pre = 0;
		int next ;
		int i = 0;
		while(true){
			next = pre;
			pre = rand.nextInt();
			System.out.println(pre);
			System.out.println(next);
			if(pre > next){
				System.out.println("第"+i+"大于");
			}else if(pre == next){
				System.out.println("第"+i+"等于");
			}else{
				System.out.println("第"+i+"小于");
			}
			i++;
		}
	}
}

练习四：写一个程序，使用两个嵌套的for循环和取余操作符来探测和打印素数（只能被其自身和1整除，而不能被其他数整除）

public class Demo{
	//打印1-100之间的所有素数
	public static void main(String args[]){
		for(int i = 1; i <= 100; i++){
			boolean flag = true; //true 是素数，false 不是素数
			//素数是除了1和本身之外的数整除
			for(int j = 2; j < i; j++){
				if(i % j == 0){
					flag = false;
				}
			}
			if(flag){
				System.out.println(i);
			}
		}
	}
}

练习五：重复第三章的练习10，不要使用Integer.toBinaryString()方法，而是使用三元操作符和按位操作符来显示二进制1和0

public class Demo{
	public static void main(String args[]){
		test(0x1234);
		
	}
	static void test(int a){
		//1|1 1 1|0 1 0|0 0
		int b = 0x8000;
		for(int i = 0; i < 16; i++){
			int out = (a | b) == a ? 1 : 0;//通过和a进行比较找到a的第一个是否是1还是0；相同就是1，不同就是0
			System.out.print(out);
			b >>>=1;
		}
	}
}

4.3.3逗号操作符

for循环中使用到逗号操作符，在初始化，和步进中，可以使用逗号分隔符，那些语句会独立执行
可以在for语句中定义多个变量，但是类型是相同的

public class Demo{
	public static void main(String args[]){
		for(int i =1, j = i + 10; i < 5; i++, j = i * 2){
			System.out.println(i+"    "+j);
		}
	}
}

4.4 foreach语句

更加简洁的for语法用于数组和容器。
使用foreach语法，表示不必创建int变量去对有访问项构成的序列进行计数。

import java.util.*;
public class Demo{
	public static void main(String args[]){
		Random rand = new Random();
		float f[] = new float[10];
		for(int i = 0; i < 10; i ++){
			f[i] = rand.nextFloat();
		}
		for(float x : f){
			System.out.println(x);
		}
	}
}
//填装数据的时候必须要知道放数据的位置，所以使用for循环

public class Demo{
	public static void main(String args[]){
		for(char c : "asdfasdf".toCharArray()){
			System.out.println(c);
		}
	}
}

for循环会在一个整数值里进行步进
foreach语句里面没有不仅，但是可以创建一个数组来实现增长。

public class Demo{
	public static void main(String args[]){
		int arr[]= {1, 2, 3, 4, 5, 6};
		for(int i : arr){
			System.out.println("这是第"+i+"次循环");
		}
	}
}

4.5 reurn

java有多个关键词表示无条件分支，表示这个分支无需任何测试即可发生。

• return
• break
• continue
• 标号语句

return：指定方法返回一个什么值。二导致当前的方法退出，并返回那个值。

public class Demo{
	public static void main(String args[]){
		System.out.println(test(10, 5));
		System.out.println(test(5, 10));
		System.out.println(test(5, 5));
	}	
	static int test(int testval, int testval2){
		if(testval > testval2){
			return +1;
		}else if(testval < testval2){
			return -1;
		}
			return 0;
	}
}

如果void方法没有一个return，那么会在方法的结尾处有一个隐式的return。
所以方法必须要有一个return来结束方法。
如果方法第一返回一个值，那么这个方法的每一个路径里面都必须返回值（条件语句）

练习六：修改test方法，让他接受两个额外的参数begin和end，，测试testval是否在begin和end之间。

public class Demo{
	public static void main(String args[]){
		test(1, 0, 3);
	}
	static void test(int testval, int begin, int end){
		if(testval >= begin && testval <= end){
			System.out.println("在范围内");
		}else{
			System.out.println("不在范围之内");
		}
	}
}

4.6 break和continue

在任何迭代语句的主体部分，都可以使用break和continue控制循环的流程。
break：强行退出循环，不执行剩余的部分
continue：停止执行当前的迭代，然后退回到循环的起始部分，开始下一次迭代。

public class Demo{
	public static void main(String args[]){
		for(int i = 0; i < 100; i++){
			if(i == 74) break; //i == 74,结束掉这个迭代
			if(i % 9 != 0) continue; //如果这个数不是9的倍数，则跳过这个循环,
			//后面的打印语句就不会执行，也就是说只有九的倍数才会打印
			System.out.println(i);
			
		}
		System.out.println();
		int arr[] = {1, 12, 23, 34, 54, 81, 43, 544, 34};
		for(int i : arr){
			if(i >=74) break;
			if(i % 9 !=0) continue;//不是倍数，跳过
			System.out.println(i);
		}
		System.out.println();
		int i = 0;
		while(true){
			i++;
			int j = i * 27;
			if(j == 1269) break;
			if(i % 10 != 0) continue;
			System.out.println(i);
		}
	}
}

break在不知道中断条件何时满足的时候

练习7：在打印99的时候退出

public class Demo{
	public static void main(String args[]){
		for(int i = 1; i <= 100; i++){
			if(i == 99) break;
			System.out.println(i);
		}
	}
}

4.7 臭名昭著的goto语句

goto：若条件A成立，则跳到这里。否则跳到那里。
goto是在源码上面的跳转
java中实现跳转的类似操作：使用break和continue，其实不是一个跳转，而是终端迭代语句的一种方法
使用标签：label：
标签起作用的唯一地方刚好是在迭代语句之前。使用标签的理由是，在迭代中嵌套另一个迭代，和标签一起使用，终端循环，知道标签开始的地方

label1:
outer-iteration{
	inner-iteration{
		break;//结束当前循环,回到外部循环
		continue;//跳过内部循环，执行下一次内部循环
		continue label1;//中断内部循环，跳过外部循环，执行下一次外部循环
		break label1;//中断内部和外部
	}
}

public class Demo{
	public static void main(String args[]){
		//continue语句不会跳过for循环中的步进
		int i = 0;
		outer://外部循环标签
		for(;;){
			inner:
			for(; i < 10; i++){
				System.out.println(i);
				if(i == 2){
					System.out.println("continue");
					continue;
				}
				if(i == 3){
					System.out.println("break");
					i++;
					break;
				}
				if(i == 7){
					System.out.println("continue outer");
					i++;
					continue outer;
				}
				if(i == 8){
					System.out.println("break outer");
					break outer;
				}
				for(int k = 0; k < 5; k++){
					if(k == 3){
						System.out.println("continue inner");
						continue inner;
					}
				}
			}
		}
	}
}

continue不会中断i++
break会结束所有的部分，包括i++
如果没有break outer就不会结束掉外部的死循环
如果在中断循环的同时退出，使用return

public class Demo{
	public static void main(String args[]){
		int i = 0;
		outer:
		while(true){
			System.out.println("Outer while loop");
			while(true){
				i++;
				System.out.println(i);
				if(i == 1){
					System.out.println("continue");
					continue;
				}
				if(i == 3){
					System.out.println("continue outer");
					continue outer;
				}
				if(i == 5){
					System.out.println("break");
					break;
				}
				if(i == 7){
					System.out.println("break outer");
					break outer;
				}
			}
		}
	}
}

1. continue 会退回到最内层循环的开头，并继续执行
2. 带标签的continue会到达标签的位置，重新进入标签后面的循环内部
3. break会中断当前的循环
4. 带标签的break会结束标签所在位置的循环

4.8 switch

switch选择语句，根据表达式的值，switch语句可以从一系列代码中选择一段进行执行。

switch(integral-selector){
	case integral-value1: statement; break;
	case integral-value2: statemnet; break;
	case integerl-value3: statement; break;
	
	default: statemnet;
}

通过Integeral-selector是一个能够产生整数值的表达式，switch语句将这个表达式的结果和integral-value比较，如果相同则执行后面的代码，如果没有则执行default语句。
break，会跳转到switch语句的末尾。省略break，会继续执行后面的case语句，知道遇到一个break’。
整数因子：int、char、enum

import java.util.*;
public class Demo{
	public static void main(String args[]){
		Random rand = new Random(47);
		for(int i = 0; i < 100; i++){
			int c = rand.nextInt(26) + 'a';//产生一个a-z之间的数
			System.out.println((char)c + " " + c);
			switch(c){
				case 'a':
				case 'e':
				case 'i':
				case 'o':
				case 'u':
				System.out.println("元音字母");
				break;
				case 'y':
				case 'w':
				System.out.println("有时候是一个元音字母");
				break;
				default:
				System.out.println("辅音");
			}
		}
		
	}
}

练习8 ：写一个switch语句，为每一个case打印一个消息，然后把这个switch放进for测试case，

public class Demo{
	public static void main(String args[]){
		for(int i = 0; i < 10; i++){
			switch(i){
				case 0:
				case 1:
				case 2:
				case 3:
				case 4:
				case 5:
				System.out.println("sdf");
				break;
				case 6:
				case 7:
				case 8:
				case 9:
				System.out.println("sdfdgdfgf");
				break;
				default:
				System.out.println("hello");
			}
		}
	}
}

练习九：斐波那契数列1、1、2、3、5、8组成。每一个数字（从第三个数字）都是前两个数的和。创建一个方法，接受一个整数，并显示从第一个元素开始总共由该参数指定的个数所构成的所有数字。test5(). 1、1、2、3、5

public class Demo{
	public static void main(String args[]){
		test(5);
	}
	static void test(int i){
		int j =1;
		int k = 1;
		int twoSum;
		System.out.println(j);
		System.out.println(k);
		while(true){
			
			twoSum = j + k;
			j = k;
			k = twoSum;
			System.out.println(twoSum);
			if(twoSum == i){
				break;
			}
			
		}
	}
}

public class Demo{
	public static void main(String args[]){
		
		for(int i = 0 ;i < 5; i++){
			System.out.println(test(5));
		}
	}
	static int test(int i){
		// 1 1 2 3 5 
		
		if(i <= 2){return 1;}
		return test(i - 1) + test(i - 2);
		
	}
}

练习10：吸血鬼：位数为偶数，有一对数字相乘得到，这对数字包含乘积的一半数字。两个00是不被允许的

public class Demo{
	static int ge;
	static int shi;
	static int bai;
	static int qian;
	public static void main(String args[]){
		for(int i = 1000; i < 9999; i++){
			test(i);
			if(i == test1(ge, shi) * test1(bai, qian)){System.out.println(i+"是");}
			if(i == test1(ge, shi) * test1(qian, bai)){System.out.println(i+"是");}
			if(i == test1(ge, bai) * test1(shi, qian)){System.out.println(i+"是");}
			if(i == test1(ge, bai) * test1(qian, shi)){System.out.println(i+"是");}
			if(i == test1(ge, qian) * test1(shi, bai)){System.out.println(i+"是");}
			if(i == test1(ge, qian) * test1(bai, shi)){System.out.println(i+"是");}
			if(i == test1(shi, ge) * test1(bai, qian)){System.out.println(i+"是");}
			if(i == test1(shi, ge) * test1(qian, bai)){System.out.println(i+"是");}
			if(i == test1(shi, qian) * test1(bai, ge)){System.out.println(i+"是");}
			if(i == test1(shi, bai) * test1(qian, ge)){System.out.println(i+"是");}
			if(i == test1(bai, ge) * test1(shi, qian)){System.out.println(i+"是");}
			if(i == test1(bai, ge) * test1(qian, shi)){System.out.println(i+"是");}
			if(i == test1(bai, shi) * test1(qian, ge)){System.out.println(i+"是");}
			if(i == test1(bai, qian) * test1(shi, ge)){System.out.println(i+"是");}
			if(i == test1(qian, ge) * test1(shi, bai)){System.out.println(i+"是");}
			if(i == test1(qian, ge) * test1(bai, shi)){System.out.println(i+"是");}
			if(i == test1(qian, shi) * test1(bai, ge)){System.out.println(i+"是");}
			if(i == test1(qian, bai) * test1(shi, ge)){System.out.println(i+"是");}
		}
	}
	//这个方法是获取个、十、百、千
	static void test(int i){
			 ge = i % 10; 
			 shi = i / 10 % 10;
			 bai = i / 100 % 10 ;
			qian = i / 1000;
	}
	//将两个数组合成两位数
	static int test1(int x, int y){
		if(x != 0) {
			return (x * 10 + y);
		}
		return 0;
	}
}

//有重复的数据，判断重复