How to Exponentiate in Java

Math pow

The easiest way to solve this problem is to use the Math class. This is the solution you will use in most cases.

The Math class contains methods related to trigonometry, geometry, and other aspects of mathematics. In it, methods are implemented as static, so you can immediately call them through the name of the Math class without creating a class object.

What does exponentiation look like:

public static int pow(int value, int powValue) {
   return (int) Math.pow(value, powValue);
}

We had to use a type cast (int), since this method of the Math class returns a value of type double (the arguments are also double, but an implicit type cast is used there).

And now - a bonus: additional options.

The value of the square of a number

Let's start, perhaps, with the simplest thing.

This is how the method for squaring is written:

public static int pow(int value){
   return value*value;
}

Call in main:

public static void main(String[] args) {
   System.out.println(Solution.pow(7));
}

That's all - nothing complicated or unnecessary.

Number to the power

But the squared number is not all we need. Most often in our work we will need a number to a certain degree, so what follows is a slightly more complicated version, but with a custom java pow value:

public static void main(String[] args) {
   System.out.println(Solution.pow(7, 4));
}

public static int pow(int value, int powValue) {
   int result = 1;
   for (int i = 1; i <= powValue; i++) {
       result = result * value;
   }
   return result;
}

The algorithm is very simple: we set the starting point result, and then multiply it by our value as many times as the loop with powValue runs (powValue number of times)

Recursion

The next method will be a little more exotic, but no less cool.

Recursion is a feature that allows a method to call itself. In Java, such a mechanism is present, and such methods are accordingly called recursive.

Many, if not all, algorithmic problems can be solved recursively. This one will also be no exception, so let's take a look at how you can raise a number to a certain power in a recursive way:

public static int pow(int value, int powValue) {
   if (powValue == 1) {
       return value;
   } else {
       return value * pow(value, powValue - 1);
   }
}

As we can see, we have two cases:

1. The condition for exiting recursion, or in other words, when our degree value reaches one, we will begin to be thrown back.
2. The mechanism itself for multiplying value by the result of calling the same method, but with powValue - 1.

Well, now it’s time to look at lazier methods, namely, the “out of the box” methods.

BigInteger

The main purpose of the BigInteger class is to store integers of arbitrary size, but at the same time it has various arithmetic methods that allow you to work with these huge (or not so huge) numbers.

You can read more about BigInteger in this article .

So what would exponentiation look like using BigInteger in Java?

public static int pow(int value, int powValue) {
   BigInteger a = new BigInteger(String.valueOf(value));
  return a.pow(powValue).intValue();
}

Quite simple and without any problems, isn’t it?