常见Java系列题1

1.求最大公约数和最小公倍数。

import java.util.Scanner;

public class GCDandLCM {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("输入第一个整数：");
        int num1 = scanner.nextInt();

        System.out.print("输入第二个整数：");
        int num2 = scanner.nextInt();

        int gcd = calculateGCD(num1, num2);
        System.out.println("最大公约数为：" + gcd);

        int lcm = calculateLCM(num1, num2, gcd);
        System.out.println("最小公倍数为：" + lcm);
    }

    // 计算最大公约数
    public static int calculateGCD(int num1, int num2) {
        if (num2 == 0) {
            return num1;
        }

        return calculateGCD(num2, num1 % num2);
    }

    // 计算最小公倍数
    public static int calculateLCM(int num1, int num2, int gcd) {
        int product = num1 * num2;
        return product / gcd;
    }
}

这段代码中，我们使用了递归来计算最大公约数，而最小公倍数是通过先计算两个数的乘积，再除以最大公约数得到的。通过运行上面的代码，你可以输入两个整数，然后程序将会计算出它们的最大公约数和最小公倍数并输出。

下面是使用循环的方法来求解的Java代码示例：

import java.util.Scanner;

public class GCDandLCM {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("输入第一个整数：");
        int num1 = scanner.nextInt();

        System.out.print("输入第二个整数：");
        int num2 = scanner.nextInt();

        int gcd = calculateGCD(num1, num2);
        System.out.println("最大公约数为：" + gcd);

        int lcm = calculateLCM(num1, num2, gcd);
        System.out.println("最小公倍数为：" + lcm);
    }

    // 计算最大公约数
    public static int calculateGCD(int num1, int num2) {
        while (num2 != 0) {
            int temp = num2;
            num2 = num1 % num2;
            num1 = temp;
        }
        return num1;
    }

    // 计算最小公倍数
    public static int calculateLCM(int num1, int num2, int gcd) {
        int product = num1 * num2;
        return product / gcd;
    }
}

这段代码中，我们使用了循环来计算最大公约数。通过不断交换和更新两个数的值来实现辗转相除法，直到余数为0为止。最后的商就是最大公约数。其他部分的计算最小公倍数和输出结果的过程与之前的方法相同。

2.求素数。

import java.util.Scanner;

public class PrimeNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("输入一个正整数：");
        int number = scanner.nextInt();

        if (isPrime(number)) {
            System.out.println(number + "是素数");
        } else {
            System.out.println(number + "不是素数");
        }
    }

    // 判断一个数是否为素数
    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }

        // 循环从2开始，逐个判断是否能整除该数
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false; // 如果能整除，说明不是素数
            }
        }

        return true; // 循环结束，未能整除，说明是素数
    }
}

这段代码中，我们通过循环从2开始逐个判断给定的数是否能被整除。如果存在被整除的情况，即该数不是素数；如果循环结束后都未能整除，说明该数是素数。

还有一种更高效的方法来判断素数，称为埃拉托斯特尼筛法（Sieve of Eratosthenes）。这种方法可以找到一个给定范围内的所有素数。下面是使用埃拉托斯特尼筛法来求素数的Java代码示例：

import java.util.Arrays;
import java.util.Scanner;

public class PrimeNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("输入一个正整数：");
        int number = scanner.nextInt();

        boolean[] isPrime = new boolean[number + 1];
        Arrays.fill(isPrime, true);
        
        calculatePrimes(isPrime);
        
        if (number < 2) {
            System.out.println(number + "不是素数");
        } else if (isPrime[number]) {
            System.out.println(number + "是素数");
        } else {
            System.out.println(number + "不是素数");
        }
    }

    // 使用埃拉托斯特尼筛法计算素数
    public static void calculatePrimes(boolean[] isPrime) {
        int n = isPrime.length;
        isPrime[0] = false;
        isPrime[1] = false;

        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j < n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
    }
}

在这个示例中，我们使用了一个布尔数组 isPrime 来表示 0 到给定范围内的每个数是否为素数。初始时，将所有数都标记为素数。然后，从2开始循环，将每个素数的倍数的位置标记为非素数，直到循环结束。最后，判断给定的数是否为素数，根据 isPrime 数组中的值，输出结果。

3.水仙花数。

水仙花数，也被称为阿姆斯特朗数，是指一个 n 位数 (n≥3)，它的每个位上的数字的 n 次幂之和等于它本身。下面是用 Java 编写的求水仙花数的代码示例：

public class ArmstrongNumber {
    public static void main(String[] args) {
        int start = 100;
        int end = 999;

        System.out.println("水仙花数：");
        findArmstrongNumbers(start, end);
    }

    // 寻找指定范围内的水仙花数
    public static void findArmstrongNumbers(int start, int end) {
        for (int number = start; number <= end; number++) {
            if (isArmstrongNumber(number)) {
                System.out.print(number + " ");
            }
        }
    }

    // 判断一个数是否为水仙花数
    public static boolean isArmstrongNumber(int number) {
        int originalNumber = number;
        int numDigits = String.valueOf(number).length();
        int sum = 0;

        while (number != 0) {
            int digit = number % 10;
            sum += Math.pow(digit, numDigits);
            number /= 10;
        }

        return sum == originalNumber;
    }
}

在上面的代码中，我们使用了两个方法来寻找水仙花数。findArmstrongNumbers 方法用于遍历指定范围内的所有数，并调用 isArmstrongNumber 方法来检查每个数是否为水仙花数。

isArmstrongNumber 方法首先保存原始的数字以便后续比较，然后计算该数字的位数 numDigits。接下来，我们循环取出每个位上的数字，并将其的 n 次幂加到 sum 变量中。最后，我们将 sum 与原始数字进行比较，如果相等则返回 true，表示该数字是水仙花数。

当然，还有一种更简单的方法来判断是否为水仙花数。我们可以直接遍历每个三位数，并将其个位、十位和百位的数字进行立方求和，然后判断是否等于原始数。下面是使用这种简单方法求水仙花数的 Java 代码示例：

public class ArmstrongNumber {
    public static void main(String[] args) {
        System.out.println("水仙花数：");
        findArmstrongNumbers();
    }

    // 寻找三位数的水仙花数
    public static void findArmstrongNumbers() {
        for (int number = 100; number <= 999; number++) {
            int digit1 = number / 100;          // 百位数字
            int digit2 = (number / 10) % 10;    // 十位数字
            int digit3 = number % 10;           // 个位数字

            int sum = (int) (Math.pow(digit1, 3) + Math.pow(digit2, 3) + Math.pow(digit3, 3));

            if (sum == number) {
                System.out.print(number + " ");
            }
        }
    }
}

在这个示例中，我们遍历了所有的三位数（从 100 到 999），并分别获取每个数的百位、十位和个位数字。然后，我们将这三个数字的立方和计算出来，将其与原始数进行比较。如果它们相等，则该数字是水仙花数。