Java doesn’t have an exponents operator like “**” in Python, but you can still calculate exponents in a different way. You can make exponents in Java with Math.pow(), it’s a good option for floating point numbers, or you can use BigInteger.pow() for large ones.
You can also use for-loop and while-loop to do exponents, but the Math.pow () is the most suitable, in my opinion, as it can be used to measure power for any number, both negative and positive. Moreover, it doesn’t require you to define user-defined logic, which means you don’t need to write your own loop or define a recursive function. That saves your time while coding and makes the code easier to read.
Different ways to do exponents in Java
- Math.pow(): It’s part of Java’s built-in Math class. Easy to use, handles both integer and floating-point numbers. And can handle both positive and negative exponents. However, it returns in double so that they may be errors in extremely large fractions/numbers.
- BigInteger.pow(): It’s part of Java’s BigInteger class. It works only if you must deal with large values and accept only positive integer exponents. It’s also slower and uses much more memory compared to Math class.
- For-loop: That’s a manual method, so I don’t recommend it. It works only with non-negative number exponents. It also doesn’t require additional classes, but in my opinion, is less efficient compared to Math.pow(). We can define arguments as int, so it would work with integers only, or as double, so it will work with both integers and floating-point numbers.
- While-loop: Almost the same as for-loop, but uses, obviously, while-loop instead. The same as for-loop, it works only with non-negative numbers.
| Method | Floating-point numbers | Negative exponents | Very large numbers | Efficiency |
|---|---|---|---|---|
| Math.pow() | Yes | Yes | No | High |
| BigInteger.pow() | No | No | Yes | Low |
| For-loop | No | No | Depends on the JVM | Medium |
| While-loop | No | No | Depends on the JVM | Medium |
How to do exponents with Math.pow()
The Math class is part of the java.lang package is pre-built; it’s implicitly imported, java.lang. Java automatically imports classes. So, you don’t need to write import java.lang.Math; and you can just use Math.pow() and any other methods from Math class.
The syntax of Math.pow() is simple; it includes two arguments: the base and the exponent. The base is the number you’re rising to power; the exponent is the power to raise the number.
Here’s how it works:
double base = 2.0;
double exponent = 3.0;
double result = Math.pow(base, exponent);
System.out.println("The exponent is: " + result);Here:
- Math is the class name containing the pow() method.
- pow() is the method to perform exponentiation. It’s static, and you call the Math class itself without the need to create a class instance.
- base and exponent are two parameters; the first is the number to raise to power; the second is the power itself.
- I used 2 as the base and 3 as the power. The mathematical equation would be x=2^3
- Math.pow(base, exponent) executes the raise of the base into power (exponent) and assigns the result to the result variable.
If you try this code in the compiler, it may not work, giving you the output that: “At least one public class is required in the main file.”
In this case, the right structure for the code would be:
public class Main {
public static void main(String[] args) {
double base = 2.0;
double exponent = 3.0;
double result = Math.pow(base, exponent);
System.out.println("The exponent is: " + result);
}
}Here:
- public means the method is accessible anywhere, including from outside the class it’s declared in. That’s necessary for JVM (Java Virtual Machine) to call this method.
- class declares the class in Java.
- Main is the class name.
- { is the opening that marks the beginning of the class definition; everything between the opening and closing brace would be part of the class.
- static means that the method belongs to the class itself. So the JVM would call the class itself.
- void means that the method isn’t returning anything back.
- main is the name of the method.
- String[] args) are parameters of the method. Here we have one parameter in an array of Strings. Now you can provide command-line arguments, and these arguments are passed to your main method through this parameter.
Here’s the code executed:
How to do exponents with BigInteger.pow()
BigInteger.pow() is a method in the BigInteger class in Java, and it can be used to do exponents on very large values.
The BigInteger class belongs to java.math package.
The pow() method to do exponents has the following syntax:
public BigInteger pow(int exponent)Here’s full code to execute:
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
BigInteger base = new BigInteger("20");
BigInteger result = base.pow(10);
System.out.println("The result is: " + result);
}
}- import java.math.BigInteger; states that Java needs to include BigInteger class from the java.math package into the current file.
After you import BigInteger from java.math package, you can use BigInteger directly in your code without referring to java.math.BigInteger
- BigInteger is the class that contains the pow() method.
- You call the pow() method on an instance of the BigInteger class.
- BigInteger instances are immutable, so they can’t be altered once the instance is created.
- pow() is the method to perform the exponentiation.
- exponent is the integer argument. That’s our exponent to which the base would be raised. It should be non-negative.
- BigInteger base = new BigInteger(“base”); creates a new instance for BigInteger class that represents the integer.
- BigInteger result = base.pow(power); calls a pow() method on the base to raise it to power.
- The result would be stored as a result variable.
Here’s the code for BigInteger.pow() executed:
How to do an exponent with for-loop
The for-loop isn’t the best one to use, but it may be suitable if you know the number of iterations.
In the case of for-loop operation, the power should be greater than 1.
Here’s an example of code for base 2, power 3:
public class Main {
public static void main(String[] args) {
int base = 2;
int exponent = 3;
int result = 1;
for (int i = 0; i < exponent; i++) {
result = result * base;
}
System.out.println("The exponent is: " + result);
}
}Here’s the code executed:
This code uses int for base and exponent, assuming that the number should be an integer. But you can also use double, to allow floating-point numbers. But you can define a double only for a base; that won’t work for an exponent; you still need to convert it to int, and if even we define it as double and then convert it to int, this will truncate any decimal portion of the exponent.
public class Main {
public static void main(String[] args) {
double base = 2.5;
int exponent = 3;
double result = 1.0;
for (int i = 0; i < exponent; i++) {
result *= base;
}
System.out.println("The exponent is: " + result);
}
}- public class Main {
Here we declare a public class named Main.
- public static void main(String[] args) {
Here we declare the start of JVM execution; the main method is declared as public (meaning the method is accessible anywhere), static (the method belongs to the class itself), and void (the method isn’t returning anything back).
- double declares the base variable as a type of floating-point number that can hold decimal values.
- exponent is declared as an int so that it can be only an integer.
- result is declared as double.
- for (int i = 0; i < exponent; i++) {
This line starts for-loop, which would be run from i=0 to i=exponent-1, as the condition is i < exponent; for each iteration, it would be incremented by 1 (i++)
- result *= base;
In each iteration of the loop, the result value would be multiplied by the base. The result would then be assigned back to the result. Like result = result*base.
In our case, it’s 3*(2.5)=2.5*2.5*2.5
- System.out.println(“The exponent is: ” + result);
Displays the final number of the result to the console.
The code executed:
How to do an exponent with while-loop
A for-loop and a while-loop in Java are used to perform almost the same task – to execute a code. But there’s one key difference: a loop variable is declared and initialized directly in the declaration, and the condition is checked in the beginning. That’s great when you know the exact number of loop rounds beforehand.
In a while loop, you need to declare and initialize the variable before the loop itself, and the condition is checked before each iteration. That can be used when you don’t know the number of iterations beforehand, so the loop needs to proceed until the condition is met.
Here’s is an example of code to do an exponent with a while-loop; the base is declared as double so that it can be a floating-point number:
public class Main {
public static void main(String[] args) {
double base = 2.5;
int exponent = 3;
double result = 1.0;
while (exponent > 0) {
result *= base;
exponent--;
}
System.out.println("The exponent is: " + result);
}
}From a mathematical point of view, it looks like this:
- We start with a base of 2.5, an exponent of 3, and a result of 1.0.
- We then enter the while loop. The condition for the while loop is exponent > 0. The exponent is 3 at the start, so we enter the loop.
- Inside the loop, we first perform the operation result *= base; This multiplies the result by the base and assigns the result back to the result. The base is 2.5, and the result is 1.0, so the result becomes 2.5 * 1.0 = 2.5.
- We then decrement the exponent by 1 using the exponent– operation. The exponent is now 2.
- The program then goes back to the top of the while loop and rechecks the condition. Since the exponent is still greater than 0, we go through the loop again. The result is now 2.5 * 2.5 = 6.25, and the exponent is decremented to 1.
- We go through the loop one more time. The result is 6.25 * 2.5 = 15.625, and the exponent is decremented to 0.
- We then return to the top of the while loop again. The exponent is not greater than 0 this time, so we do not enter the loop again.
- The final value of the result is 15.625, which is equal to 2.5 to the power of 3.
The code executed:
