How to find power of a number raised to another number in java

This article will outline various methods in which a number can be raised to the power of another number in java.

Method 1: Using while loop
Power of a number raised to another number is calculated by multiplying the number by itself for the same number of times as the power.
That is, if you want to calculate 2 raised to power of 3, then you should multiply 2 by itself for 3 times(same as the power to be raised).
Based on the above approach, java program to find power of a number can be written as

public class PowerCalculator {
  public static void main(String[] args) {
    // initialize values
    int power = 3;
    int number = 4;
    int result = 1;
    System.out.print(number +" raised to power " + power +" is : ");
    // loop till power is 0
    while (power > 0) {
      // multiply number by itself
      result = result * number;
      // reduce loop counter
      power--;
    }
    System.out.print(result);
  }
}

Output of the above program will be

Statement which multiplies the number by itself can be written in shorthand notation as

result *= number;

Method 2: Using for loop
This method uses the same approach as the earlier one except that it replaces the while loop with a for loop. Modified program will be as below.

public class PowerCalculator {
   public static void main(String[] args) {
     // initialize values
     int power = 3;
     int number = 4;
     int result = 1;
     System.out.print(number +" raised to power " + power +" is : ");
     // loop till power is 0
     for(; power > 0; power--) {
       // multiply number by itself
       result = result * number;
     }
     System.out.print(result);
   }
}

Note that the for loop does not contain the initialization section since the variable is already initialized before the loop. Output remains the same.

Method 3: Using recursion
This method also follows the same approach as the above two methods but it replaces the loop with a recursive method.
A recursive method keeps on calling itself till some condition.
In order to calculate power of a number using recursive method, follow below steps.

1. Create a method that accepts two int arguments, one representing the number or the base and second representing the power.
2. This method should return an int which is the product of the number and the result of a call to this method with the value of power reduced by 1 in every call.
3. This method should also check if the power is greater than 0 and return 1 if the power is 0. This is the terminating condition of recursive method. If it is not provided, then the recursive method will keep on running forever.

Java program written as per the above algorithm is given below.

public class PowerCalculator {
   public static void main(String[] args) throws IOException {
      // initialize values
      int power = 3;
      int number = 4;
      int result = calculatePower(4, 3);
      System.out.print(number + " raised to power " + power + " is : ");
      System.out.print(result);
   }

   /**
    * Recursive method to calculate power of a number
    * @param number
    * @param power
    * @return
    */
   private static int calculatePower(int number, int power) {
     if (power == 0) {
       return 1;
     }
     // multiply the number with the result of the recursive call
     return number * calculatePower(number, --power);
   }
}

From the program, it can be seen that the recursive method multiplies the number with the value returned by the recursive call to itself and in every call the power is reduced by 1.
Thus, when the power becomes 0, the recursive calls start returning and in turn multiply the number by itself for the number of times the method is called recursively, which is the same as the value of power.
Output of above program is

Method 4: Using Math.pow function
java.lang.Math class has a pow method which can calculate a number raised to the power of another. It takes two arguments with the first argument as the number and second as the power.
It returns a double value which is the result of number raised to the power. Java program for this method is given below.

public class PowerCalculator {
   public static void main(String[] args) {
     // initialize values
     int power = 3;
     int number = 4;
     int result = 1;
     int result = (int) Math.pow(number, power);
     System.out.print(number + " raised to power " + power + " is : ");
     System.out.print(result);
   }
}

Output of above program will be

Note that the value returned by Math.pow is casted to an int. Without casting, the result will be in displayed with leading decimal, that is, 64.0.
Advantages of using Math.pow over for and while loops are

• This method is shorter than the other two.
• It can be used with negative exponent, that is, you can raise a number to negative power.

Hit the clap button if the article was useful.