如何在 Java 中检查一个数是否为 2 的幂

简介

在这个实验中，你将学习如何在 Java 中高效地判断一个给定的数字是否为 2 的幂。我们将探索一种巧妙的按位运算方法，这种方法通常比传统方法性能更高。

本实验将引导你实现并测试这种按位运算技术，将其与基于循环的方法进行比较，并处理诸如非正数等边界情况，以确保得到一个健壮的解决方案。

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/booleans("Booleans") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/BasicSyntaxGroup -.-> java/while_loop("While Loop") subgraph Lab Skills java/data_types -.-> lab-559959{{"如何在 Java 中检查一个数是否为 2 的幂"}} java/operators -.-> lab-559959{{"如何在 Java 中检查一个数是否为 2 的幂"}} java/booleans -.-> lab-559959{{"如何在 Java 中检查一个数是否为 2 的幂"}} java/if_else -.-> lab-559959{{"如何在 Java 中检查一个数是否为 2 的幂"}} java/while_loop -.-> lab-559959{{"如何在 Java 中检查一个数是否为 2 的幂"}} end

使用按位运算判断 2 的幂

在这一步中，我们将探索一种巧妙的方法，使用 Java 中的按位运算来判断一个数是否为 2 的幂。这种方法通常比传统的基于循环的方法更高效。

首先，让我们了解一下什么是 2 的幂。2 的幂是任何可以表示为 2 的整数次幂的数（例如，2^0 = 1，2^1 = 2，2^2 = 4，2^3 = 8，依此类推）。在二进制表示中，2 的幂有一个独特的模式：它们由一个 1 后面跟着零个或多个 0 组成（例如，1 是 1，2 是 10，4 是 100，8 是 1000）。

现在，考虑 2 的幂及其前一个数的二进制表示。例如：

8 的二进制是 1000
7 的二进制是 0111

如果我们对 2 的幂和它的前一个数进行按位与运算（&），结果总是零。这是因为 2 的幂只有一个 1 位，而它前面的数在该位置为 0，且右边所有位置都为 1。

例如，8 (1000) & 7 (0111) = 0000（即 0）。

这个性质适用于所有正的 2 的幂。任何不是 2 的幂的正数，其二进制表示中至少有两个 1 位。当你对它和它前面的数进行按位与运算时，至少有一个 1 位会与前一个数中的 1 位对齐，从而得到一个非零值。

因此，一个正数 n 是 2 的幂的条件是 (n & (n - 1)) == 0。

让我们创建一个 Java 程序来实现这个检查。

在 WebIDE 编辑器中打开 HelloJava.java 文件。

将现有代码替换为以下内容：

public class HelloJava {

    // Function to check if a number is a power of two using bitwise AND
    public static boolean isPowerOfTwo(int n) {
        // A number is a power of two if it's positive and (n & (n - 1)) is 0
        return (n > 0) && ((n & (n - 1)) == 0);
    }

    public static void main(String[] args) {
        int number1 = 8;
        int number2 = 12;
        int number3 = 1;

        System.out.println(number1 + " is a power of two: " + isPowerOfTwo(number1));
        System.out.println(number2 + " is a power of two: " + isPowerOfTwo(number2));
        System.out.println(number3 + " is a power of two: " + isPowerOfTwo(number3));
    }
}

在这段代码中：

我们定义了一个静态方法 isPowerOfTwo，它接受一个整数 n 作为输入。
在方法内部，我们检查 n 是否大于 0，以及 n 和 n - 1 的按位与是否等于 0。
main 方法演示了如何使用 isPowerOfTwo 方法，并给出了几个示例数字。

保存文件（Ctrl+S 或 Cmd+S）。
在终端中编译 Java 程序：
```
javac HelloJava.java
```
如果没有错误，编译就成功了。

运行编译后的程序：

java HelloJava

你应该会看到类似以下的输出：

8 is a power of two: true
12 is a power of two: false
1 is a power of two: true

这个输出证实了我们的按位检查能够正确识别 2 的幂。

使用基于循环的方法进行测试

在上一步中，我们学习了一种使用按位运算来检查 2 的幂的简洁方法。虽然这种方法很高效，但对于初学者来说可能不是那么直观。在这一步中，我们将使用循环实现一种更直接的方法，这有助于你巩固对该概念的理解。

如果一个数 n 可以通过将 1 不断乘以 2 得到，那么它就是 2 的幂。例如：

1 = 1 * 2^0
2 = 1 * 2^1
4 = 1 * 2^2
8 = 1 * 2^3

我们可以使用一个循环，从 1 开始，不断将其乘以 2，并检查是否能得到给定的数 n。

让我们在 HelloJava.java 文件中添加一个新方法，使用循环来检查 2 的幂。

在 WebIDE 编辑器中打开 HelloJava.java 文件。
在 HelloJava 类内部、isPowerOfTwo 方法下方添加以下方法：
```
    // Function to check if a number is a power of two using a loop
    public static boolean isPowerOfTwoLoop(int n) {
        if (n <= 0) {
            return false; // Powers of two are positive
        }
        int power = 1;
        while (power < n) {
            power *= 2; // Multiply by 2 in each iteration
        }
        return power == n; // Check if we reached the original number
    }
```
在这个新方法中：
- 我们首先处理 n 为非正数的情况，返回 false。
- 我们将变量 power 初始化为 1。
- 我们使用一个 while 循环，只要 power 小于 n 就继续循环。
- 在循环内部，我们在每次迭代中将 power 的值翻倍（power *= 2 是 power = power * 2 的简写）。
- 循环结束后，我们检查 power 的最终值是否等于 n。如果相等，则 n 是 2 的幂。

现在，让我们修改 main 方法来测试这个新的基于循环的方法。将现有的 main 方法替换为以下更新后的版本：

    public static void main(String[] args) {
        int number1 = 8;
        int number2 = 12;
        int number3 = 1;
        int number4 = 0; // Test a non-positive number

        System.out.println("--- Using Bitwise Approach ---");
        System.out.println(number1 + " is a power of two: " + isPowerOfTwo(number1));
        System.out.println(number2 + " is a power of two: " + isPowerOfTwo(number2));
        System.out.println(number3 + " is a power of two: " + isPowerOfTwo(number3));
        System.out.println(number4 + " is a power of two: " + isPowerOfTwo(number4)); // Test with 0

        System.out.println("\n--- Using Loop Approach ---");
        System.out.println(number1 + " is a power of two: " + isPowerOfTwoLoop(number1));
        System.out.println(number2 + " is a power of two: " + isPowerOfTwoLoop(number2));
        System.out.println(number3 + " is a power of two: " + isPowerOfTwoLoop(number3));
        System.out.println(number4 + " is a power of two: " + isPowerOfTwoLoop(number4)); // Test with 0
    }

我们添加了一个对 0 的测试用例，并包含了打印语句，以清晰显示按位方法和基于循环的方法的结果。

保存文件（Ctrl+S 或 Cmd+S）。
在终端中编译更新后的 Java 程序：
```
javac HelloJava.java
```

运行编译后的程序：

java HelloJava

你应该会看到类似以下的输出：

--- Using Bitwise Approach ---
8 is a power of two: true
12 is a power of two: false
1 is a power of two: true
0 is a power of two: false

--- Using Loop Approach ---
8 is a power of two: true
12 is a power of two: false
1 is a power of two: true
0 is a power of two: false

对于这些测试用例，两种方法产生的结果相同。基于循环的方法可能一开始更容易理解，而按位方法通常性能更高，尤其是对于较大的数字。

处理非正数

在前面的步骤中，我们实现了两种方法来检查一个数是否为 2 的幂。在基于循环的方法中，我们简单提及了处理非正数（零和负数）的情况。在这一步，我们将明确关注处理这些情况的重要性，并确保我们的两种方法对于非正输入都能正确返回 false。

根据定义，2 的幂是正整数。因此，零和任何负数都不可能是 2 的幂。我们的方法应该体现这一点。

让我们重新审视 HelloJava.java 中的现有方法，以确保它们能正确处理非正数。

在 WebIDE 编辑器中打开 HelloJava.java 文件。
查看 isPowerOfTwo 方法（按位方法）：
```
    public static boolean isPowerOfTwo(int n) {
        // A number is a power of two if it's positive and (n & (n - 1)) is 0
        return (n > 0) && ((n & (n - 1)) == 0);
    }
```
此方法已经包含了 (n > 0) 检查。这确保了如果 n 为零或负数，条件 (n > 0) 将为 false，并且由于 && 运算符，整个表达式将评估为 false。因此，按位方法能正确处理非正数。

现在，查看 isPowerOfTwoLoop 方法：

    public static boolean isPowerOfTwoLoop(int n) {
        if (n <= 0) {
            return false; // Powers of two are positive
        }
        int power = 1;
        while (power < n) {
            power *= 2;
        }
        return power == n;
    }

此方法在开始时明确检查 if (n <= 0)，如果条件为真则返回 false。这也能正确处理非正数。

让我们在 main 方法中添加更多测试用例，专门检查零和负数。修改 main 方法以包含负数：

    public static void main(String[] args) {
        int number1 = 8;
        int number2 = 12;
        int number3 = 1;
        int number4 = 0;
        int number5 = -4; // Test a negative number
        int number6 = -1; // Test another negative number

        System.out.println("--- Using Bitwise Approach ---");
        System.out.println(number1 + " is a power of two: " + isPowerOfTwo(number1));
        System.out.println(number2 + " is a power of two: " + isPowerOfTwo(number2));
        System.out.println(number3 + " is a power of two: " + isPowerOfTwo(number3));
        System.out.println(number4 + " is a power of two: " + isPowerOfTwo(number4));
        System.out.println(number5 + " is a power of two: " + isPowerOfTwo(number5));
        System.out.println(number6 + " is a power of two: " + isPowerOfTwo(number6));

        System.out.println("\n--- Using Loop Approach ---");
        System.out.println(number1 + " is a power of two: " + isPowerOfTwoLoop(number1));
        System.out.println(number2 + " is a power of two: " + isPowerOfTwoLoop(number2));
        System.out.println(number3 + " is a power of two: " + isPowerOfTwoLoop(number3));
        System.out.println(number4 + " is a power of two: " + isPowerOfTwoLoop(number4));
        System.out.println(number5 + " is a power of two: " + isPowerOfTwoLoop(number5));
        System.out.println(number6 + " is a power of two: " + isPowerOfTwoLoop(number6));
    }

保存文件（Ctrl+S 或 Cmd+S）。
编译更新后的 Java 程序：
```
javac HelloJava.java
```

运行编译后的程序：

java HelloJava

你应该会看到类似以下的输出：

--- Using Bitwise Approach ---
8 is a power of two: true
12 is a power of two: false
1 is a power of two: true
0 is a power of two: false
-4 is a power of two: false
-1 is a power of two: false

--- Using Loop Approach ---
8 is a power of two: true
12 is a power of two: false
1 is a power of two: true
0 is a power of two: false
-4 is a power of two: false
-1 is a power of two: false

如你所见，两种方法都能正确识别 0 和负数不是 2 的幂。这证实了我们的实现对于所有整数输入都是可靠的。

在编程中，理解像非正数这样的边界情况至关重要，以确保你的代码在所有有效输入下都能正确运行。

总结

在本次实验中，我们学习了如何在 Java 中使用按位运算高效地检查一个数是否为 2 的幂。我们发现，一个正数 n 是 2 的幂，当且仅当 n 和 n - 1 进行按位与运算的结果为零。这是因为 2 的幂具有独特的二进制表示。我们实现了一个 Java 函数 isPowerOfTwo 来运用这种按位方法，该方法通常比基于循环的方法性能更高。

我们还探索了对这种按位方法进行测试，并考虑了如何处理非正数，以确保我们的检查对于各种输入都具有鲁棒性。这次实践经验让你对运用按位运算解决常见编程问题有了实际的认识。