if…else if和switch的互换

在很多时候使用switch比if…else if更加简单，但仅限于判断条件可以转换为固定值的时候，因为case后面必须是确定值，而不是能是范围。在前面的例子中，我们将优秀成绩设置为90分以及上，良好为70分及以上，这些标准都是可以被10整除的，因此可以方便地将一个范围转换为一个或者几个确定值。如果标准修改一下，优秀为90分以上（不含90），良好成绩为70以上（不含70）。这样，90分，80多分，70多分都是良好，而70分则不属于良好，这时再使用switch就会显得很麻烦（觉不够麻烦可以把分界线定在92、83之类的分数上）。相反，if…else if在处理这种“不规则”的范围更方便一些。在使用if…else…if语句时，要注意条件的顺序，最好按照各个标准的值从大到小或者从小到大排列，如果顺序混乱，会导致一些条件永远不会被使用到。此外，多个条件同时存在后，每个条件并不是独立存在的，而是自身及其前面条件的叠加。来看这个程序：

import java.util.Random;
public class IfDemo {public static void main(String[] args) {//通过随机数生成一个成绩，在0到100之间Random r=new Random();int score=r.nextInt(101);System.out.println("本次考试成绩是："+score);//90分以上为优秀，不含90if(score>90){System.out.println("恭喜你，成绩优秀！");}else if(score>70){//70分以上为良好，不含70//鉴于前面还有条件，所以这里的真实条件是大于70，小于等于90System.out.println("考得不错，良好！");}else if(score>=60){//60分及以上为及格//鉴于前面还有条件，所以这里的真实条件是大于等于60，小于等于70System.out.println("这次考试及格了");}else{//60分以下为不及格System.out.println("考试不及格，赶紧学习去！！！");}}
}

有兴趣的同学可以尝试将条件打乱顺序，看看执行结果如何。顺便说一下，switch语句中的case对顺序不敏感。

三种循环的转换

我们学了三种循环，这三种循环是可以互相替换的，替换的关键点就是正确找到循环条件、循环体以及循环条件中关键值的改变方式。再来看之前的例子：

public class Loop {public static void main(String[] args) {//定义变量x表示待相加的数字，第一个数字是1；sum表示和int x = 1;int sum = 0;System.out.println("----------------while循环----------------");//循环条件是x<=100，每次循环x增加1，循环的主体则是sum = sum + x;while (x <= 100) {sum = sum + x;x++;}System.out.println("经过while循环的计算，sum=" + sum);System.out.println("----------------do...while循环----------------");//将x和sum变量恢复初始值x=1;sum=0;//循环条件是x<=100，每次循环x增加1，循环的主体则是sum = sum + x;do {sum = sum + x;x++;} while (x <= 100);System.out.println("经过do...while循环的计算，sum=" + sum);System.out.println("----------------for循环----------------");//将x和sum变量恢复初始值的工作放到表达式1中完成//循环条件是x<=100，每次循环x增加1，循环的主体则是sum = sum + x;for(x=1,sum=0;x<=100;x++){sum=sum+x;}System.out.println("经过for循环的计算，sum=" + sum);}
}

找准了这三大核心部分，就可以很容易实现三种循环的互换。
do…while是先执行后判断，如果想在while循环和for循环中实现相同的效果，则可以在循环代码之前，写一遍循环体代码。
因此，三种循环并不存在明显的差异，大家可以根据自己的喜好和需要，选择合适的循环方法。

for循环中的三个表达式

我们都知道，for循环的小括号中有三个表达式，第一个表达式用于初始化数据；第二个表达式用于决定是否要执行循环体；第三个表达式在循环体执行完毕后执行，一般用于改变循环条件中关键变量的值。这三个表达式可以不写……在小括号中的。我们来看程序：

public class ForDemo {public static void main(String[] args) {//for循环中第一个表达式可以写到整个循环的前面int i=1;int sum=0;//小括号中的表达式可以不写，但分号不能不写for(;;){//第二个表达式可以放到循环中，在一定条件下使用break中止循环if(i>100){break;}sum+=i;//第三个表达式可以写在循环体的后面i++;}System.out.println("1+2+3...+100="+sum);}
}

输出九九乘法口诀

乘法口诀是我们每个人都背过的，现在我们编程来输出乘法口诀表。看程序：

public class Mul {public static void main(String[] args) {int i,j;//乘数和被乘数for(i=1;i<=9;i++) {for(j=1;j<=i;j++) {System.out.print(j+"X"+i+"="+i*j+"\t");}System.out.println();}}
}

在外层循环中，i表示乘数，内层循环的j表示被乘数。之所以内层循环条件是j<=i而不是j<=9，是为了避免出现乘数被乘数交换位置重复出现的情况。如果使用了j<=9，那么就会输出一个矩形的乘法口诀表。目前这个口诀表是上小下大的，大家再来思考一下，怎么输出一个上大下小的口诀表呢？

猜数字游戏

有没有玩过猜数字游戏？计算机先生成一个数字让你猜，你会有几次机会，每次猜完后，计算机会告诉你是猜对了、猜大了还是猜小了。直到你猜对或者把几次机会用完为止。
我们来看这个程序：

import java.util.Random;
import java.util.Scanner;
/** 猜数字游戏，计算机随机生成一个100以内的数字，有五次猜测机会 */
public class Guess {public static void main(String[] args) {int result;//存储计算机生成的数字int user;//用户猜的数字保存于变量user中boolean success=false;//表示用户是否猜对，默认为false，也就是猜错了Random r=new Random();result=r.nextInt(100)+1;//1到100之间的随机数，赋值给resultSystem.out.println("开始猜吧，1到100之间，你有五次机会");Scanner sc=new Scanner(System.in);byte count=1;while(count<=5) {System.out.println("请输入你猜的第"+count+"个数字：");user=sc.nextInt();if(user==result) {success=true;break;}else if(user>result) {System.out.println("你猜的数字太大了");}else {System.out.println("你猜的数字太小了");}count++;}if(success) {System.out.println("恭喜你，猜对了！！！");}else {System.out.println("很可惜，猜错了......");}System.out.println("正确答案是："+result);}
}

判断一定范围内有多少个质数

质数是指除了1和它自身之外不能被其他任何数整除的整数。质数在数据加密、机械制造等领域有很广泛的应用，因此此判断或寻找质数有很重要的现实意义。判断一个数是不是质数的程序是比较简单的，我们只需要确定除了1和它自身，没有其他约数就可以了。最简单粗暴的方法就是让这个数字除以2、3、4……直到这个数减1，只要这些数字不能被其整数，就说明它是个质数，否则不是质数。不过这个方法检测的数据量比较大，而且很多都是无用数据，造成了计算机性能的浪费。
我们仔细观察一下一个数的约数，会发现，它们是成对出现的，而且分布在该数平方根的两侧。所以我们只需要检测到该数的平方根即可。这样就可以实现对程序的优化。

import java.util.Scanner;
/* * 判断一个数是不是质数，并找出一定范围内的所有质数和个质数的个数*/
public class Prime {public static void main(String[] args) {//获取程序开始执行时的时间long startTime=System.currentTimeMillis();int x;// x存储一个整数，我们将判断它是不是质数int start = 10000;int end = 1000000;boolean flag = true;// flag用于标记x是不是质数，默认为是质数int count=0;//count用于统计质数的个数//如果起始值为偶数，则从它后面的数字开始检测if(start%2==0) {start++;}//判断x是不是质数，x值每次增加2，这样可以跳过偶数for (x = start; x <= end; x+=2) {for (int i = 3; i <=Math.sqrt(x); i++) {if (x % i == 0) {flag = false;break;}}if (flag) {System.out.println(x + "是一个质数");count++;} else {//System.out.println(x + "不是一个质数");flag=true;}}System.out.println("从"+start+"到"+end+"之间一共有"+count+"个质数");//获取程序结束时的时间，减去开始时间，就是程序执行的时间long endTime=System.currentTimeMillis();System.out.println("本次程序执行耗时"+(endTime-startTime)+"毫秒");}
}

水仙花数

水仙花数是指一个三位的整数，其各位上数字的立方和等于其自身的值。我们需要把这个三位数的个、十、百位上的数字提取出来，求它们的立方和，再判断是否和原数值相同即可。
这类问题的本质是将一个数字拆解，这在编程中是一种比较常见的技巧。
看程序：

public class Daffodil {public static void main(String[] args) {int a,b,c;//a,b,c用于存储一个整数的个十百位数字for(int i=100;i<1000;i++){//求个位数a=i%10;//求十位数b=(i%100)/10;//求百位数c=i/100;//判断该整数是不是水仙花数if(a*a*a+b*b*b+c*c*c==i){System.out.println("找到水仙花数："+i);}}}
}

这里留给大家两个思考题：

1. 水仙花数其实是自幂数中的一种。自幂数是指一个n位数，它的每位上的数字的n次幂之和等于它本身。大家可以编程寻找其他的自幂数。
2. 大家可以思考一下，还有没有其他的方法可以找到所有的水仙花数以及其它自幂数。

百钱买百鸡

计算机最大的优势就是不知疲倦，不会因为工作时间长而造成正确率的波动。在大多数情况下，那些耗时长、复杂的运算工作都是通过循环来实现的。利用计算机这个特点，我们有时可以把一些技巧性很强的方法放到一边，转而使用简单粗暴的方法，把所有的可能答案都尝试一遍，直到找到正确的位置。这就是穷举法。
传说三国时期的曹操死后怕人盗他的墓，所以建造了七十二个墓，以便迷惑世人。后人有说“尽掘七十二疑冢，必有一冢葬君尸”，使用的就是穷举法。
我们来看一个简单的例子：百钱买百鸡。某人有100块钱，去集市上买鸡，公鸡5元一只，母鸡3元一只，小鸡一元三只，现在计划买100只鸡，把这100块钱正好花完，应该怎么买？（原文出自张丘建的《算经》：鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁、母、雏各几何？）
如果我们假设需要买公鸡x只，母鸡y只，小鸡z只，则会产生两个方程：

• x+y+z=100
• 5x+3y+z/3=100

很显然，三个未知数，两个方程，并不足以组成一个方程组并，更别说求解了。事实上，这个问题有几组不同的解，想找出所有的解，还真有点麻烦。这时候我们就可以利用计算机，把所有的可能都尝试一遍了。看程序：

public class Chickens100 {public static void main(String[] args) {int x,y,z;//公鸡x只，母鸡y只，小鸡z只//使用三层循环来尝试所有可能的组合//考虑到价格和鸡的数量，通过假设所有的钱用来买同一种鸡，可以得出：//公鸡可以买0到20只，母鸡0到33只，小鸡0到99只//本来小鸡可以买得更多，但是题目要求买100只，而且小鸡数量必须是3的倍数，所以最多99只for (x=0;x<=20;x++){for(y=0;y<=33;y++){for(z=0;z<=99;z+=3){//判断当前组合是否满足百钱买百鸡的条件if((x+y+z==100)&&(5*x+3*y+z/3==100)){System.out.println("公鸡："+x+"只，"+"母鸡："+y+"只，"+"小鸡："+z+"只");}}}}}
}

运算结果：

公鸡：0只，母鸡：25只，小鸡：75只
公鸡：4只，母鸡：18只，小鸡：78只
公鸡：8只，母鸡：11只，小鸡：81只
公鸡：12只，母鸡：4只，小鸡：84只

穷举法充分利用了计算机的特点，虽然看似比较简单粗暴，缺乏技巧，但由于它尝试了所有的可能性，因此穷举法是必然有效的。在密码破解中，也会用到穷举法，把所有可能的密码都尝试一遍，必然能找到正确密码——当然时间往往会比较长。而另一种比较常用的“字典破解”法，则是一种简化版的穷举法。

递归

递归也是一种非常常用的思想。递归的本质就是方法自己调用自己。设计递归方法有两个要点：

1. 必须有结束条件
2. 核心算法必须是固定的、可以实现自我调用的形式

我们可以通过一个简单的例子了解递归：斐波那契数列。这个数列的前两项是0和1，此后每一项都是之前两项之和，所以这个数列就是0,1,1,2,3,5,8,13……
我们来看程序。Fibonacci.java：

public class Fibonacci {//getF1方法使用递归求第n位元素的值public int getF1(int n) {//如果是前两位，直接返回值if((n==0) || (n==1)) {return n;}//如果不是前两位，则返回待求解项之前两项之和return getF1(n-1)+getF1(n-2);}
}

创建FibonacciMain.java程序，调用Fibonacci类中的方法求解：

public class FibonacciMain {public static void main(String[] args) {Fibonacci f=new Fibonacci();int n=7;//求数列第n项System.out.println("数列第"+n+"项是："+f.getF1(n));}
}

穷举密码

上面我们提到了暴力破解，那我们就来写一个能够生成所有密码的程序吧。为了简化这个程序，我们假设要破解的密码是由小写字母和数字组成，要生成更复杂的密码的话，在这个程序基础上修改即可。

public class Passwords {public static void main(String[] args) {//密码长度int length = 5;//数组p存储密码字符在数组chars中的索引值int[] p = new int[length];//chars存储密码中包含的字符char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l','m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};//控制结束的标志boolean flag = false;//count用于统计密码的总数量long count = 0;while (true) {//判断是否需要进位，当一个元素的值大于chars长度-1后，就需要将数据存放到下一个元素中for (int j = 0; j < p.length - 1; j++) {int temp;//如果p中元素大于等于chars.length，则需要进位if (p[j] >= chars.length) {temp = p[j] / chars.length;p[j] = p[j] % chars.length;p[j + 1] = p[j + 1] + temp;}}//如果最后一位使用了不存在的字符，表示最后一位需要进位，停止循环//同使flag设置为true，提示外层循环也应该停止。if (p[p.length - 1] >= chars.length) {flag = true;break;} else {//输出数组p的值,p中存储的是字符数组chars中的元素编号，所以要转换为字符输出for (int m = 0; m < p.length; m++) {System.out.print(chars[p[m]]);}count++;}//输出一个组合就换一次行System.out.println();//如果flag为true，整个循环结束if (flag) {break;}//给第一个元素加1p[0]++;}System.out.println("一共有" + count + "个密码");}
}

基本思路：创建一个数组chars，保存有所有要用到的字符；创建数组p，用于保存密码中每一个字符在chars中的索引值。这样就把字符组合问题，转换成了在数组中保存一个数的问题——只不过这个数的每一位都占用一个数组元素。然后每次向数组p中加1，在低位（p[0]这边）加满时进位（chars中有n个字符，当低位的值达到n时，就可以进位了）。直到所有的元素都为最大值时，就穷举了所有的字符组合。

使用递归穷举密码

在上面的例子中，我们使用循环实现了对密码的穷举，这次我们使用递归的方法来实现对密码的穷举。下面我来看看程序：

public class Passwords02 {static char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k','l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v','w', 'x', 'y', 'z'};//计数器static int count = 0;//利用递归生成密码字典static void generate(int deep, String password) {if (deep == 1) {System.out.println(password);count++;} else {for (int i = 0; i < chars.length; i++) {generate(deep - 1, password + chars[i]);}}}public static void main(String[] args) {//要生成的密码长度int pwdLenght = 3;//空字符串String pwd = "";//开始生成密码for (int i = 0; i < chars.length; i++) {//参数pwd + chars[i]是为了将字符chars[i]转换为字符串//主方法中调用generate方法提供第一位密码，在递归过程中补上后面的密码generate(pwdLenght, pwd + chars[i]);}//输出生成的密码总数System.out.println("生成的密码总数为：" + count);}
}

循环和递归

在很多情况下，循环和递归是可以互换的，很多计算机科学家都给出一个结论：所有的递归都可以使用循环来替代。既然如此，为什么还要使用递归呢？
首先，我们来了解一下循环和递归两种思路，谁的速度更快。
在斐波那切数列的题目中的Fibonacci.java中添加方法：

// getF2方法使用循环求第n位元素的值public int getF2(int n) {int[] f = { 0, 1 };// a表示数列第一个值，b表示数列第二个值，c表示待求项的值int a = f[0];int b = f[1];int c = 0;// 如果是前两位，直接返回值if ((n == 0) || (n == 1)) {return f[n];}// 每次循环c为前两项之和，然后原来的第二位变为第一位，前两项之和变为第二位，继续循环for (int i = 2; i <= n; i++) {c = a + b;a = b;b = c;}return c;}

修改FibonacciMain.java：

public class FibonacciMain {public static void main(String[] args) {Fibonacci f=new Fibonacci();int n=30;//使用递归求数列第n项long start=System.currentTimeMillis();System.out.println("数列第"+n+"项是："+f.getF1(n));long end=System.currentTimeMillis();System.out.println("使用递归时，耗时："+(end-start)+"毫秒");//使用循环求数列第n项start=System.currentTimeMillis();System.out.println("数列第"+n+"项是："+f.getF2(n));end=System.currentTimeMillis();System.out.println("使用循环时，耗时："+(end-start)+"毫秒");}
}

运行之后就会发现，循环的速度明显比递归要快。这是因为，递归要一层一层调用自己，之后还要一层一层返回，过程比循环更加复杂，所以速度会慢一些。
如果有兴趣的话，同学们可以修改这个程序，单独使用递归或循环，查看一下内存占用情况。我们会发现，递归消耗内存高于循环。
除非编译器和JVM做了一些良好的优化，否则递归的效率是低于循环的。
但递归程序写起来更加简单、清晰，尤其是在一些不明确循环结束条件的情况下，如遍历一个目录中所有文件（包括子目录中的文件），包括后面我们将会看到的快速排序算法，递归程序都更容易写。
简言之，递归是以速度和内存等资源为代价换取降低编程难度。