常见循环实例.docx
《常见循环实例.docx》由会员分享，可在线阅读，更多相关《常见循环实例.docx（21页珍藏版）》请在冰点文库上搜索。
常见循环实例
1九九乘法表
1.1问题
在界面打印九九乘法表，效果如图－1所示：
图－1
1.2方案
此案例需要使用嵌套循环来实现。
分析图－1可以看出，九九乘法表一共需要输出九行数据，如图－2所示：
图－2
由图－2可以看出，需要使用一个for循环来控制输出的行数。
代码如下所示：
1.//i变量用于控制行数
2.for（inti=1;i<10;i++）{
3.}
分析图－2中的每行，可以看出，每行中的乘法表达式的个数正好和行数相同。
每个乘法表达式中，第一个乘数从1开始，乘到最大值（当前行数），而另一个乘数正好是行数，如图－3所示：
图－3
因此，在输出每行中的内容时，还需要使用一个for循环来控制每行中输出的表达式的个数。
如果当前行为第9行，则循环的代码如下所示：
1.//假设当前行为第9行
2.inti=9;
3.for（intj=1;j<=i;j++）{
4.System.out.print（j+"*"+i+"="+j*i+"\t"）;
5.}
因为行数并不固定，而是从第一行到第九行，因此，需要将两个循环嵌套起来，代码如下所示：
1.//i变量用于控制行数
2.for（inti=1;i<10;i++）{
3. //j变量用于控制每行中参与计算的最大数值：
与行数相等
4. for（intj=1;j<=i;j++）{
5.System.out.print（j+"*"+i+"="+j*i+"\t"）;
6.}
7. //每行输出完毕后，需要换行
8. System.out.println（）;
9.}
1.3步骤
实现此案例需要按照如下步骤进行。
步骤一：
定义类及main方法
首先定义一个名为MultiplicationTable的类，并在类中添加Java应用程序的主方法main，代码如下所示：
1.publicclassMultiplicationTable{
2. publicstaticvoidmain（String[]args）{
3. }
4.}
步骤二：
构建循环
在main方法中，构建两层嵌套的for循环：
外层循环用于控制行，内层循环用于控制某行上的乘法表达式。
需要注意的是，每行输出完毕后，需要换行。
代码如下所示：
1.publicclassMultiplicationTable{
2. publicstaticvoidmain（String[]args）{
3.//i变量用于控制行数
4.for（inti=1;i<10;i++）{
5.//j变量用于控制每行中参与计算的最大数值：
与行数相等
6.for（intj=1;j<=i;j++）{
7.
8.}
9.//每行输出完毕后，需要换行
10.System.out.println（）;
11.}
12. }
13.}
隐藏
步骤三：
输出乘法表
考虑到输出界面的美观性，使用“\t”进行排版对齐代码如下所示：
1.publicclassMultiplicationTable{
2. publicstaticvoidmain（String[]args）{
3.//i变量用于控制行数
4.for（inti=1;i<10;i++）{
5.//j变量用于控制每行中参与计算的最大数值：
与行数相等
6.for（intj=1;j<=i;j++）{
7.//设置输出的格式，控制排版对齐
8.System.out.print（j+"*"+i+"="+j*i+"\t"）;
9.}
10.//每行输出完毕后，需要换行
11.System.out.println（）;
12.}
13. }
14.}
隐藏
上述代码中的“\t”是水平制表符，其作用为从行首开始，每8字节算一个制表位，“\t”会在当前内容结束后第一个空的制表位处连接上下文。
1.4完整代码
本案例的完整代码如下所示：
1.publicclassMultiplicationTable{
2. publicstaticvoidmain（String[]args）{
3.//i变量用于控制行数
4.for（inti=1;i<10;i++）{
5.//j变量用于控制每行中参与计算的最大数值：
与行数相等
6.for（intj=1;j<=i;j++）{
7.//设置输出的格式，使用"\t"控制排版对齐
8. System.out.print（j+"*"+i+"="+j*i+"\t"）;
9.}
10.//每行输出完毕后，需要换行
11.System.out.println（）;
12.}
13. }
14.}
隐藏
2求数组元素的最大值
2.1问题
创建程序，实现查询数组中最大值的功能，需求为：
创建一个长度为10的数组，数组内放置10个0到99之间（包含0，包含99）的随机整数作为数组内容，要求查询出数组中的最大值，并打印显示在界面上，界面效果如图－4所示：
图－4
2.2方案
首先，此案例中，首先需要创建一个长度为10的整型数组，然后使用for循环来产生10个0到99之间的随机整数，并放入数组；然后查询数组中的最大值，并打印显示结果。
2.3步骤
实现此案例需要按照如下步骤进行。
步骤一：
定义类及main方法
首先定义一个名为MaxOfArray的类，并在类中添加Java应用程序的主方法main，代码如下所示：
1.publicclassMaxOfArray{
2. publicstaticvoidmain（String[]args）{
3. }
4.}
步骤二：
创建数组
在main方法中创建一个长度为10的数组，代码如下：
1.publicclassMaxOfArray{
2. publicstaticvoidmain（String[]args）{
3. //创建一个10个长度的数组
4. int[]arr=newint[10];
5. }
6.}
步骤三：
数组的赋值
使用for语句构建一个10次的循环，在每次循环中，随机产生一个0到99之间的整数，并存入数组。
此案例中，使用Random类的nextInt（）方法产生随机数。
代码如下所示：
1.importjava.util.Random;
2.
3.publicclassMaxOfArray{
4. publicstaticvoidmain（String[]args）{
5. //创建一个10个长度的数组
6. int[]arr=newint[10];
7.
8. //随机生成10个0－99之间的数值，放入数组
9. Randomran=newRandom（）;
10. for（inti=0;i11. arr[i]=ran.nextInt（100）;
12. }
13. }
14.}
注意：
此步骤中，需要导入java.util包下的Random类。
步骤四：
打印数组内容
数组赋值后，为方便用户查看数组中的数据内容，需要将数组中的数据打印在界面上。
因此，需要使用Arrays类的toString方法来得到数组的内容。
代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16. }
17.}
注意：
此步骤中，需要导入java.util包下的Arrays类。
步骤五：
查询最大值
为找到数组中的最大值，依然需要使用循环来遍历数组。
先定义一个变量max用于表示最大值，并赋初始值为数组中的第一个元素；然后依次把数组中的元素与变量max进行数值比较，如果数组中的某元素的数值大于max，则将该元素的数值存入变量max。
代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16.
17. //查询最大值
18. intmax=arr[0];
19. for（inti=1;i20. if（max21. max=arr[i];
22. }
23. }
24. System.out.println（"最大值是：
"+max）;
25. }
26.}
2.4完整代码
本案例的完整代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16.
17. //查询最大值
18. intmax=arr[0];
19. for（inti=1;i20. if（max21. max=arr[i];
22. }
23. }
24. System.out.println（"最大值是：
"+max）;
25. }
26.}
隐藏
3求数组元素的最大值放在最后一位
3.1问题
修改上一个案例中的程序，为程序添加功能：
将数组的长度扩容为11，然后将查询到的数组最大值作为数组的最后一个元素，并打印扩容后的数组的内容。
界面效果如图－5所示：
图－5
3.2方案
实现此案例，只需要在上一个案例的基础上添加功能即可。
可以使用Arrays类的copyOf（）方法实现数组的拷贝以及扩容，代码如下所示：
1.arr=Arrays.copyOf（arr,arr.length+1）;
如果原数组arr的长度为10，那么，上述代码将产生一个长度为11的新数组arr，且新数组中的前10个数值和原数组arr中的10个数值相同。
然后，将查询到的最大值放入新数组的最后一个位置上，并打印新数组的内容即可。
3.3步骤
实现此案例需要按照如下步骤进行。
步骤一：
创建新数组
在上个案例中的main方法中继续添加代码，创建新数组，代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16.
17. //查询最大值
18. intmax=arr[0];
19. for（inti=1;i20. if（max21. max=arr[i];
22. }
23. }
24. System.out.println（"最大值是：
"+max）;
25. //创建新数组
26. arr=Arrays.copyOf（arr,arr.length+1）;
27. }
28.}
步骤二：
存储最大值并打印数组内容
将查询到的数组最大值放入新数组的最后一个位置，并打印数组内容显示。
代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16.
17. //查询最大值
18. intmax=arr[0];
19. for（inti=1;i20. if（max21. max=arr[i];
22. }
23. }
24. System.out.println（"最大值是：
"+max）;
25.
26. //创建新数组
27. arr=Arrays.copyOf（arr,arr.length+1）;
28. //最大值放入最后一个位置，并打印新数组内容
29. arr[arr.length-1]=max;
30. System.out.println（"新数组中的数据为：
"+Arrays.toString（arr））;
31. }
32.}
3.4完整代码
本案例的完整代码如下所示：
1.importjava.util.Random;
2.importjava.util.Arrays;
3.
4.publicclassMaxOfArray{
5. publicstaticvoidmain（String[]args）{
6. //创建一个10个长度的数组
7. int[]arr=newint[10];
8.
9. //随机生成10个0－99之间的数值，放入数组
10. Randomran=newRandom（）;
11. for（inti=0;i12. arr[i]=ran.nextInt（100）;
13. }
14. //打印数组中的数据
15. System.out.println（"数组中的数据为：
"+Arrays.toString（arr））;
16.
17. //查询最大值
18. intmax=arr[0];
19. for（inti=1;i20. if（max21. max=arr[i];
22. }
23. }
24. System.out.println（"最大值是：
"+max）;
25.
26. //创建新数组
27. arr=Arrays.copyOf（arr,arr.length+1）;
28. //最大值放入最后一个位置，并打印新数组内容
29. arr[arr.length-1]=max;
30. System.out.println（"新数组中的数据为：
"+Arrays.toString（arr））;
31. }
32.}
隐藏
4冒泡排序算法实现
4.1问题
冒泡排序（BubbleSort），是一种较简单的排序算法。
在冒泡排序算法中，需要重复的走访要排序的数列，一次比较两个元素，如果它们的大小顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换的元素，也就是说该数列已经排序完成。
由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
本案例要求使用冒泡排序算法实现对数组的排序。
有一个长度为10的整型数组，使用冒泡排序算法将数组按照升序排列，并输出排序的过程以及结果。
程序交互情况如图-6所示：
图－6
4.2方案
为了理解冒泡排序算法，我们先假设有一个长度为7的数组，数组内容如图－7所示：
图－7
图－7中的数组元素为无序状态，为实现升序排列，可以先进行第一轮比较，过程大致如下：
1.先比较第一对相邻的元素（第一个位置的89和第二个位置的50）：
如果第一个比第二个大，就交换两个数值；
2.继续比较第二对相邻的元素（第二个位置和第三个位置）：
如果第二个位置上的数值大于第三个位置上的数值，则交换；
3.继续下去，重复上述的比较工作，直到结尾的最后一对；此时，一轮比较交换完成后，最后的元素则是数列中最大的数。
第一轮比较的过程如图－8所示：
图－8
由图－8可以看出，第一轮比较后，已经将数组中的最大值通过位置交换，移动到数组的最后位置上。
但是，其余的元素依然为无序状态，因此，依然进行第二轮比较：
针对除最后一个元素外的其他元素重复以上步骤，以找到剩余元素中的最大数，且放置到倒数第二的位置上。
第二轮比较的过程如图－9所示：
图－9
由图－9可以看出，第一个位置上的50比第二个位置上的84小，因此不发生交换；而其他位置将依次发生交换，从而将84交换到倒数第二的位置上。
然后，继续进行其他轮比较，持续进行，每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，则排序完
升级会员 