School project, Double round to nearest cent.

Question

Im doing a Loan Calculator for class. I'm nearly done but the only thing missing is how to round INTEREST_RATE instead of $298.95833333333337 i would like to get $298.96. But i don't know how.

Enter your old Principle = 25000
Enter your current payment = 450

Previous Balance: $25000.0
Payment: $450.0
Interest Paid: $151.04166666666666
Principle Paid: $298.95833333333337
New Principal: $24701.041666666668

import java.util.Scanner; 

public class LoanCalculator {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

    /**
     * Declaration Section  
     * 
     */
    Scanner keyboard = new Scanner(System.in); 
    double INTEREST_RATE; 
    double currentPayment;
    double oldPrincipal;
    double interestPaid;
    double principalPaid;
    double newPrincipal; 


    /**
     * Process Section
     * 
     */

    System.out.println("Enter your old Principle = ");
    oldPrincipal = keyboard.nextDouble(); 

    System.out.println("Enter your current payment = ");
    currentPayment = keyboard.nextDouble();  

    INTEREST_RATE = 7.25 / 100.0; //fix this 

    interestPaid = oldPrincipal * INTEREST_RATE / 12;

    principalPaid = currentPayment - interestPaid; 

    newPrincipal = oldPrincipal - principalPaid; 


    /**
     * Output Section
     * 
     * */
    System.out.println("Previous Balance: " + "$"+ oldPrincipal);
    System.out.println("Payment: " + "$"+ currentPayment);
    System.out.println("Interest Paid: " + "$"+ interestPaid);
    System.out.println("Principle Paid: " + "$"+ principalPaid);
    System.out.println("New Principal: " + "$"+ newPrincipal); 


}//Main()

}//LoanCalculator

Answer 1

Never use double for financial calculations! It's really dangerous.

From the Java language specification:

float: The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.

double: The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.

Use BigDecimal, it also have the rounding functionalities that you're looking for.

Answer 2

BigDecimal

Never use the floating-point types (float, Float, double, Double) for matters such as money where accuracy is important. Floating-point trades away accuracy for speed-of-execution. Instead use the slow but accurate class BigDecimal.

Choose your mode of rounding. I chose “Banker’s rounding”.

Covered already in Stack Overflow many times. So search for more info. Briefly here is some code to get you started. I have not run this code.

BigDecimal interestPecentage = 
    new BigDecimal( "7.25" )
    .setScale( 2 , RoundingMode.HALF_EVEN )    // Round using Banker’s rounding.
;   

BigDecimal interestRateAnnual = 
    interestPecentage.divide(                 // Divide percentage by 100 to get an interest rate as a decimal fraction.
        new BigDecimal( "100" ) 
    )
    .setScale( 2 , RoundingMode.HALF_EVEN )
; 

Answer 3

Use this Method is perfect and secure

only transform the value to String and the result to Double or Float

public String PerfectRound(String number, int limit){
//        System.out.println(numero);
        String t="";int c=0,e=number.length();
        do {            
            try {
                if(String.valueOf(number.charAt(c)).equals(".")){if(limit==0){break;}e=c+limit+1;}
                t=t+number.charAt(c);
            } catch (Exception je) {
                t=t+"0";
            }
            c++;
//            System.out.println(t);
        } while (c<e);
//        System.out.println(t);
        return t;
    }

Example:

double a=23.32313232;
a=Double.valueOf(PerfectRound(a+"", 2));
System.out.println(a);

Answer 4

Edit: we should use BigDecimal class for financial calculation. BigDecimal class has built-in formatter so I add it.

Edit: changed the rounding mode to half even as @Basil Bourque suggested.

      public class LoanCalculator {public static void main(String[] args) {
   Scanner keyboard = new Scanner(System.in);
    BigDecimal INTEREST_RATE, currentPayment, oldPrincipal, interestPaid, principalPaid, newPrincipal, month;
    System.out.println("Enter your old Principle = ");
    oldPrincipal = keyboard.nextBigDecimal();
    System.out.println("Enter your current payment = ");
    currentPayment = keyboard.nextBigDecimal();
    NumberFormat formatter = new DecimalFormat("#0.00");
    INTEREST_RATE = new BigDecimal(7.25 / 100.0);
    formatter.format(INTEREST_RATE);//only format
    month = new BigDecimal(12);
    interestPaid = INTEREST_RATE.multiply(oldPrincipal);
    interestPaid = interestPaid.divide(month, 2);
    principalPaid = currentPayment.subtract(interestPaid);
    newPrincipal = oldPrincipal.subtract(principalPaid);
    System.out.println("Previous Balance: " + "$" + oldPrincipal);
    System.out.println("Payment: " + "$" + currentPayment);
    System.out.println("Interest Paid: " + "$" + interestPaid.setScale(2, RoundingMode.HALF_EVEN)
            + " $" + formatter.format(interestPaid));
    System.out.println("Principle Paid: " + "$" + principalPaid.setScale(2, RoundingMode.HALF_EVEN)
            + " $" + formatter.format(principalPaid));
    System.out.println("New Principal: " + "$" + newPrincipal.setScale(2, RoundingMode.HALF_EVEN)
            + " $" + formatter.format(newPrincipal));}}