1 质数问题
本案例要求使用交互的方式找出从 2 开始到某个数值范围内的所有质数，并输出结果。因为输出的质数可能较多，要求分行输出，每行最多输出 10 个质数。程序的交互过程如图-1所示：
图- 1
注：质数又称素数，指在大于1的自然数中，除了1和此整数自身外，不能被其它自然数整除的数。
参考答案
首先， 使用Scanner类接收控制台输入的一个大于 2 的整数 max，表示查找的范围。
其次，使用 for 循环从数值 2 开始进行判断，判断该数值是否为质数，然后判断数值 3、数值4 … ，逐一判断到 max 为止。
第三，判断某个数值是否为质数，需要在第二步的for循环内嵌套使用 for 循环。那么如何判断一个数是否为质数呢，如果一个数 n 不是质数，那么它一定是某两个整数的乘积。此时，如果其中一个整数大于 n 的平方根，那么必定能找到一个小于 n 的平方根的整数和它成对。例如，81的平方根是9，那么，我们只需要判断从2到9之间是否有整数可以整除 81 即可。因此，在判断数值 n 是否为质数时，需要让 n 除以 2 到 n 的平方根之间的每一个整数。在此范围内，如果 n 能被2 到 n (n大于2)的平方根之间的某个数整除，则说明n不是质数，否则n一定是质数。
最后，如果判断某个数值确实是质数，则需要记载质数的个数，并将该质数输出。为保证输出的美观，要求每行最多输出 10 个数值。因此，输出时，需要判断质数的总个数是否可以被 10 整除。如果不可以被 10 整除，则输出在同一行，数值之间用空格隔开，否则，输出到下一行。
实现此案例需要按照如下步骤进行。
步骤一：定义类及 main 方法
首先定义一个名为 PrimeNumber的类，并在类中定义Java 应用程序的入口方法main ，代码如下所示：
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
}
}
步骤二：读取控制台的输入
在main方法中，实例化Scanner类，并调用Scanner类的nextInt方法接收用户从控制台输入的表示查找范围的数值，使用完毕后将scanner对象关闭。代码如下所示：
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
#cold_bold Scanner scanner = new Scanner(System.in);
#cold_bold System.out.print("请输入查找质数的范围：2~");
#cold_bold int max = scanner.nextInt();
#cold_bold scanner.close();
}
}
步骤三：查找质数
使用双层for循环判断某个数是否为质数，其中，外层循环用于循环判断某范围内的每个数值; 内层循环用于判断某个数是否为质数。
在判断数值 n 是否为质数时，需要让 n 除以 2 到 n 的平方根之间的每一个整数。在此范围内，如果 n 能被2 到 n (n大于2)的平方根之间的某个数整除，则说明n不是质数，直接进入下一次质数的判断即可。代码如下所示：
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入查找质数的范围：2~");
int max = scanner.nextInt();
scanner.close();
#cold_bold int numOfPrime = 0;
#cold_bold for (int n = 2; n <= max; n++) {
#cold_bold // 判断n是否是质数
#cold_bold int m = (int) Math.sqrt(n);
#cold_bold int i = 2;
#cold_bold for (; i <= m; i++) {
#cold_bold if (n % i == 0)
#cold_bold break;
#cold_bold }
#cold_bold }
}
}
步骤四：输出结果
如果内层循环结束后，发现计数器 i 的值大于 n 的平方根的整数部分，则说明 n 没有被2 到 n (n大于2)的平方根之间的任何一个数整除，即n 为质数。此时，需要记载质数的总个数，并以每行 10 个数值的方式输出结果。代码如下所示：
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入查找质数的范围：2~");
int max = scanner.nextInt();
scanner.close();
int numOfPrime = 0;
for (int n = 2; n <= max; n++) {
// 判断n是否是质数
int m = (int) Math.sqrt(n);
int i = 2;
for (; i <= m; i++) {
if (n % i == 0)
break;
}
#cold_bold if (i > m) {
#cold_bold System.out.print(n + " ");
#cold_bold if (++numOfPrime % 10 == 0)
#cold_bold System.out.println();
#cold_bold }
}
#cold_bold System.out.println("\n共有" + numOfPrime + "个质数");
}
}
本案例的完整代码如下所示：
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入查找质数的范围：2~");
int max = scanner.nextInt();
scanner.close();
int numOfPrime = 0;
for (int n = 2; n <= max; n++) {
// 判断n是否是质数
int m = (int) Math.sqrt(n);
int i = 2;
for (; i <= m; i++) {
if (n % i == 0)
break;
}
if (i > m) {
System.out.print(n + " ");
if (++numOfPrime % 10 == 0)
System.out.println();
}
}
System.out.println("\n共有" + numOfPrime + "个质数");
}
}
2 int[]是一种数据类型吗？
参考答案
int[]是一种数据类型，是引用类型。与int类型，double类型类似，一样可以使用该类型定义变量。
3 使用两种方式，初始化数组arr的长度为4
参考答案
对数组进行初始化，方式一的代码为：
int[] arr={23,45,19,34};
上述数据初始化的方式为定义的同时对数据进行赋值。
方式二的代码为：
int[] arr=new int[4];
上述初始化方式为只指定数组的长度，由系统为每个数组元素指定初始值。
4 查询数组最小值，并将数组扩容形成新数组
创建程序，实现查询数组中最小值的功能，并将最小值放入数组的第一位。需求为：创建一个长度为 10 的数组，数组内放置 10 个 0 到 99 之间（包含0，包含99）的随机整数作为数组元素，要求查询出数组中的最小值，并打印显示在界面上。然后，将数组的长度扩容为 11，将查询到的数组最小值记载为数组的第一个元素，并打印扩容后的数组的内容。界面效果如图－2所示：
图- 2
参考答案
首先需要创建一个长度为 10 的整型数组，然后使用 for 循环来产生 10 个 0 到 99 之间的随机整数，并放入数组；
然后查询数组中的最小值，并打印显示结果。
第三，首先将原始组进行扩容，形成新数组。然后，可以使用 System 类的 arraycopy() 方法实现数组的拷贝，代码如下所示：
int[] arrNew = new int[arr.length + 1]; System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
如果数组 arr 的长度为 10，那么，上述代码将产生一个长度为 11 的新数组 arrNew，且此数组中的后 10 个元素和数组 arr 中的10个元素相同。
最后，将查询到的最小值放入新数组的第一个位置上，并打印新数组的内容即可。
实现此案例需要按照如下步骤进行。
步骤一：定义类及 main方法
首先定义一个名为 MinOfArray的类，并在类中添加Java应用程序的主方法main，代码如下所示：
public class MinOfArray{
public static void main(String[] args) {
}
}
步骤二：创建数组
在 main 方法中创建一个长度为 10 的数组，代码如下：
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
#cold_bold int[] arr = new int[10];
}
}
步骤三：数组的赋值
使用 for 语句构建一个 10 次的循环，在每次循环中，随机产生一个 0到99之间的整数，并存入数组。
此案例中，使用 Random 类的 nextInt方法产生随机数。代码如下所示：
#cold_boldimport java.util.Random;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
#cold_bold //随机生成 10 个0－99之间的数值，放入数组
#cold_bold Random ran = new Random();
#cold_bold for(int i=0;i<arr.length;i++){
#cold_bold arr[i] = ran.nextInt(100);
#cold_bold }
}
}
注意：此步骤中，需要导入java.util包下的Random类。
步骤四：打印数组内容
数组赋值后，为方便用户查看数组中的数据内容，需要将数组中的数据打印在界面上。因此，需要使用Arrays类的toString方法来得到数组的内容。代码如下所示：
import java.util.Random;
#cold_boldimport java.util.Arrays;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
//随机生成 10 个0－99之间的数值，放入数组
Random ran = new Random();
for(int i=0;i<arr.length;i++){
arr[i] = ran.nextInt(100);
}
#cold_bold //打印数组中的数据
#cold_bold System.out.println("数组中的数据为：" + Arrays.toString(arr));
}
}
注意：此步骤中，需要导入java.util包下的Arrays类。
步骤五：查询最小值
为找到数组中的最小值，依然需要使用循环来遍历数组。先定义一个变量 min 用于表示最小值，并赋初始值为数组中的第一个数值；然后依次把数组中的元素与变量 min 进行数值比较，如果数组中的某元素的数值小于 min，则将该元素的数值存入变量 min，并将最小值输出。代码如下所示：
import java.util.Random;
import java.util.Arrays;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
//随机生成 10 个0－99之间的数值，放入数组
Random ran = new Random();
for(int i=0;i<arr.length;i++){
arr[i] = ran.nextInt(100);
}
//打印数组中的数据
System.out.println("数组中的数据为：" + Arrays.toString(arr));
#cold_bold //查询最小值
#cold_bold int min = arr[0];
#cold_bold for(int i=1; i<arr.length; i++) {
#cold_bold if(min > arr[i]) {
#cold_bold min = arr[i];
#cold_bold }
#cold_bold }
#cold_bold System.out.println("最小值是：" + min);
}
}
步骤六：数组扩容
创建新数组，新数组的长度，在原数组长度的基础上增加1。且此数组中的后 10 个元素和原数组中的10个元素相同，代码如下所示：
import java.util.Random;
import java.util.Arrays;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
//随机生成 10 个0－99之间的数值，放入数组
Random ran = new Random();
for(int i=0;i<arr.length;i++){
arr[i] = ran.nextInt(100);
}
//打印数组中的数据
System.out.println("数组中的数据为：" + Arrays.toString(arr));
//查询最小值
int min = arr[0];
for(int i=1; i<arr.length; i++) {
if(min > arr[i]) {
min = arr[i];
}
}
System.out.println("最小值是：" + min);
#cold_bold //创建新数组
#cold_bold int[] arrNew = new int[arr.length + 1];
#cold_bold //将原数组的元素拷贝进入新数组
#cold_bold System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
}
}
步骤七：存储最小值并打印数组内容
将查询到的数组最小值放入新数组的第一个位置，并打印数组内容显示。代码如下所示：
import java.util.Random;
import java.util.Arrays;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
//随机生成 10 个0－99之间的数值，放入数组
Random ran = new Random();
for(int i=0;i<arr.length;i++){
arr[i] = ran.nextInt(100);
}
//打印数组中的数据
System.out.println("数组中的数据为：" + Arrays.toString(arr));
//查询最小值
int min = arr[0];
for(int i=1; i<arr.length; i++) {
if(min > arr[i]) {
min = arr[i];
}
}
System.out.println("最小值是：" + min);
//创建新数组
int[] arrNew = new int[arr.length + 1];
//将原数组的元素拷贝进入新数组
System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
#cold_bold //最小值放入新数组第一位，并打印新数组
#cold_bold arrNew[0] = min;
#cold_bold System.out.println("新数组中的数据为：" + Arrays.toString(arrNew));
}
}
本案例的完整代码如下所示：
import java.util.Random;
import java.util.Arrays;
public class MinOfArray {
public static void main(String[] args) {
//创建一个 10 个长度的数组
int[] arr = new int[10];
//随机生成 10 个0－99之间的数值，放入数组
Random ran = new Random();
for(int i=0;i<arr.length;i++){
arr[i] = ran.nextInt(100);
}
//打印数组中的数据
System.out.println("数组中的数据为：" + Arrays.toString(arr));
//查询最小值
int min = arr[0];
for(int i=1; i<arr.length; i++) {
if(min > arr[i]) {
min = arr[i];
}
}
System.out.println("最小值是：" + min);
//创建新数组
int[] arrNew = new int[arr.length + 1];
//将原数组的元素拷贝进入新数组
System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
//最小值放入新数组第一位，并打印新数组
arrNew[0] = min;
System.out.println("新数组中的数据为：" + Arrays.toString(arrNew));
}
}
5 总结冒泡排序算法的原理
参考答案
冒泡算法的原理如下：
在冒泡排序算法中，需要重复的走访要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换的元素，也就是说该数列已经排序完成。