Calculate Percentage in Java

1. Introduction

In this quick tutorial, we’re going to implement a CLI program to calculate percentage in Java.

But first, let’s define how to calculate percentage mathematically.

2. Mathematical Formula

In mathematics, a percentage is a number or ratio expressed as a fraction of 100. It’s often denoted using the percent sign, “%”.

Let’s consider a student that obtains x marks out of total y marks. The formula to calculate percentage marks obtained by that student would be:

percentage = (x/y)*100

3. A Simple Java Program

Now that we are clear on how to calculate percentage mathematically, let’s build a program in Java to calculate it:

public class PercentageCalculator {

    public double calculatePercentage(double obtained, double total) {
        return obtained * 100 / total;
    }

    public static void main(String[] args) {
        PercentageCalculator pc = new PercentageCalculator();
        Scanner in = new Scanner(System.in);
        System.out.println("Enter obtained marks:");
        double obtained = in.nextDouble();
        System.out.println("Enter total marks:");
        double total = in.nextDouble();
        System.out.println(
          "Percentage obtained: " + pc.calculatePercentage(obtained, total));
    }
}

This program takes the marks of the student (obtained marks and total marks) from CLI and then calls calculatePercentage() method to calculate the percentage out of it.

Here we’ve chosen double as a data type for input and output as it could store decimal numbers with up to 16 digits of precision. Hence, it should be adequate for our use case.

Let’s run this program and see the result:

Enter obtained marks:
87
Enter total marks:
100
Percentage obtained: 87.0

Process finished with exit code 0

4. A Version Using BigDecimal

BigDecimal in Java is a class for high-precision arithmetic with decimal numbers. It improves over the native double or float types by allowing precise control over scale and rounding, making them essential for applications where accuracy is crucial.

Used extensively in financial computations like currency and tax calculations, BigDecimal is also vital in scientific, engineering, and statistical domains, where even minor numerical errors can lead to adverse outcomes.  When used in applications that transmit data, they usually transform to and from strings.

4.1. Implement a Utility Class Using BigDecimal

First, let’s set up a constant, ONE_HUNDRED, which will be handy in our calculations. Now, for the method toPercentageOf, the idea is simple: we want to find what percentage a specific value is of a total. This is a standard calculation, so having a neat method makes sense:

public class BigDecimalPercentages {

    private static final BigDecimal ONE_HUNDRED = new BigDecimal("100");

    public BigDecimal toPercentageOf(BigDecimal value, BigDecimal total) {
        return value.divide(total, 4, RoundingMode.HALF_UP).multiply(ONE_HUNDRED);
    }

    public BigDecimal percentOf(BigDecimal percentage, BigDecimal total) {
        return percentage.multiply(total).divide(ONE_HUNDRED, 2, RoundingMode.HALF_UP);
    }
}

In the toPercentageOf() method, we calculate which percentage from the total is the value by dividing it by the total, rounding to 4 decimal places for a standard percentage calculation, and multiplying by 100.

The other method is the opposite, and it calculates a value equivalent to the passed percentage of the total.

But let’s spice things up a bit. We know that some methods can multiply or divide by powers of ten faster, movePointLeft(), which shifts the decimal point to the right. Still, it is implemented to prevent the result from having negative scale values, which is great for some cases but not all. For example, dividing values that result in numbers smaller than 1 won’t give us the correct result.

On the other hand, scaleByPowerOfTen() is a bit more versatile. It scales the number by a power of ten, like moving the decimal point without the risk of losing precision with minimal numbers. If we give it a negative number, it will be equivalent to dividing. For example, using -2 will be the same as dividing by 10. Let’s see how this approach looks:

import java.math.BigDecimal;
import java.math.RoundingMode;

public class FastBigDecimalPercentage {

    public static BigDecimal toPercentageOf(BigDecimal value, BigDecimal total) {
        return value.divide(total, 4, RoundingMode.HALF_UP).scaleByPowerOfTen(2);
    }

    public static BigDecimal percentOf(BigDecimal percentage, BigDecimal total) {
        return percentage.multiply(total).scaleByPowerOfTen(-2);
    }

}

4.2. Improving Usability Using Lombok’s @Extensionmethod

The classes FastBigDecimalPercentage and BigDecimalPercentageCalculator are functional for BigDecimal percentage calculations, but their traditional Java syntax needs more elegance and fluency. This is where Lombok’s @ExtensionMethod comes into play, offering a way to enhance the readability and usability of our code:

import lombok.experimental.ExtensionMethod;
import java.math.BigDecimal;
import java.util.Scanner;

@ExtensionMethod(FastBigDecimalPercentage.class)
public class BigDecimalPercentageCalculator {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        System.out.println("Enter obtained marks:");
        BigDecimal obtained = new BigDecimal(in.nextDouble());
        System.out.println("Enter total marks:");
        BigDecimal total = new BigDecimal(in.nextDouble());

        System.out.println("Percentage obtained :"+ obtained.toPercentageOf(total));
    }

}

We can transform our standard methods into a more intuitive interface by applying Lombok’s extensions. We are able to call the methods we created as if they were declared in BigDecimal directly.

5. Conclusion

In this article, we took a look at how to calculate percentage mathematically and then wrote a Java CLI program to calculate it.