Machen Sie Cent mit BigDecimal

Um Java-Programme schreiben zu können, die sich mit Finanzen befassen, müssen Sie sich mit dem auskennen

BigDecimal

Klassen- und numerische Formatierung. Der erste Schritt, um Ihnen diese beiden Themen beizubringen, besteht darin, zuerst zu erstellen

BigDecimal

Objekte. Wir werden die verwenden

BigDecimal

Klasse in der

java.math

Bibliothek zum Speichern von Werten. Sie können eine erstellen

BigDecimal

Objekt auf folgende Weise:

BigDecimal-Betrag = neues BigDecimal ("1115,37"); 

Im obigen Fall bestimmt das StringArgument an den BigDecimalKonstruktor den Wert des erstellten Objekts. Der Wert von "1115.37"kann beispielsweise eine monatliche Hypothekenzahlung in Dollar oder einen Scheckbuchsaldo darstellen. Um den Betrag anzuzeigen, können Sie BigDecimaldie toString()Methode der Klasse verwenden:

 System.out.println (amount.toString ()); 

Ein Programm, das einen BigDecimalBetrag erstellt und anzeigt, wird unten gezeigt:

importiere java.math. *; öffentliche Klasse Hypothek {public static void main (String [] args) {BigDecimal-Zahlung = new BigDecimal ("1115.37"); System.out.println (payment.toString ()); }}

Die Ausgabe des obigen Programms ist:

1115,37 

Währung formatieren

Da es sich um Geld handelt, wäre es schön, wenn die Beträge von BigDecimalObjekten ordnungsgemäß formatiert würden, was für die US-Währung ein Dollarzeichen und ein Komma als Tausendertrennzeichen enthalten würde. (Für andere Währungen siehe den Abschnitt Währung anderer Länder weiter unten). Die NumberFormatin der java.textBibliothek gefundene Klasse kann mit dem folgenden Code ein geeignetes Objekt für die US-Währung erstellen:

 NumberFormat n = NumberFormat.getCurrencyInstance (Locale.US); 

Beachten Sie, dass sich die LocaleKlasse, die als Argument für die getCurrencyInstance()obige Methode verwendet wird, in der java.utilBibliothek befindet.

Die NumberFormat‚s - format()Methode, die wir als nächstes verwenden werden, dauert ein Doppel- oder lange primitiven als Argument, so dass wir zuerst das drehen BigDecimalObjekt in eine doublemit BigDecimal‘ s - doubleValue()Methode:

double doublePayment = payment.doubleValue (); 

Jetzt verwenden wir NumberFormat‚s format()ein Verfahren zu schaffen String:

 String s = n.format (doublePayment); 

Wenn wir diese Schritte in ein Programm einfügen, haben wir:

importiere java.math. *; import java.text. *; import java.util. *; öffentliche Klasse Mortgage2 {public static void main (String [] args) {BigDecimal-Zahlung = new BigDecimal ("1115.37"); NumberFormat n = NumberFormat.getCurrencyInstance (Locale.US); double doublePayment = payment.doubleValue (); String s = n.format (doublePayment); System.out.println (s); }}

Die Ausgabe des obigen Programms ist:

115,37 

Leser sollten beachten, dass das Erstellen eines doubleWerts einen kleinen Verlust an Genauigkeit des Werts mit sich bringt. Während die Ungenauigkeiten zu klein sind, um in den Beispielen dieses Artikels gesehen zu werden, sind sie in sehr großen Mengen sichtbar. Daher können Sie sich nicht darauf verlassen NumericFormat, genaue Ergebnisse mit sehr großen Zahlen (etwa 13 oder mehr Ziffern) zu erzielen.

Währungen anderer Länder

Im vorherigen Beispiel haben wir Locale.USals Argument an die getCurrencyInstance()Methode übergeben, um die Währung des Landes (USA) anzugeben, mit dem wir arbeiten würden. Java ist jedoch nicht auf die Arbeit mit US-Währungen beschränkt. Sie würden beispielsweise die Währungen von Deutschland, Frankreich und Italien verwenden Locale.GERMANY, Locale.FRANCEoder Locale.ITALYangeben. Das Thema Internationalisierung ist ein eigenständiges Thema; Im Abschnitt Ressourcen finden Sie einen Link zu weiteren Informationen.

BigDecimal-Operationen

BigDecimalVerfahren zum Addieren und Subtrahieren Zahlen sind add()und subtract()jeweils. Um beispielsweise 1.115,37 und 115,37 hinzuzufügen, könnten wir Folgendes tun:

BigDecimal balance = new BigDecimal ("1115.37"); BigDecimal-Transaktion = neue BigDecimal-Transaktion ("115,37"); BigDecimal newBalance = balance.add (Transaktion);

Die BigDecimal‚s - newBalanceObjekt enthält jetzt den Wert von 1,230.74. Um 115,37 von 1.115,37 zu subtrahieren, könnten wir diesen Code verwenden:

BigDecimal balance = new BigDecimal ("1115.37"); BigDecimal-Transaktion = neue BigDecimal-Transaktion ("115,37"); BigDecimal newBalance2 = balance.subtract (Transaktion);

Die BigDecimal‚s - newBalance2Objekt enthält jetzt den Wert von 1.000,00. (Wenn es sich im wirklichen Leben um Scheckbuchguthaben handelt, wird die subtract()Methode natürlich viel häufiger verwendet als die add()Methode, und der vom Scheckbuchguthaben abgezogene Gesamtbetrag übersteigt den hinzugefügten Gesamtbetrag, oder so scheint es oft.) Sie kann mit BigDecimal's multiply()und divide()Methoden multiplizieren und dividieren . Das Multiplizieren wird im folgenden Programm demonstriert:

importiere java.math. *; import java.text. *; import java.util. *; öffentliche Klasse Multiplizieren {public static void main (String [] args) {BigDecimal d = new BigDecimal ("1115.32"); BigDecimal taxRate = new BigDecimal ("0.0049"); BigDecimal d2 = d.multiply (taxRate); System.out.println ("Unformatiert:" + d2.toString ()); NumberFormat n = NumberFormat.getCurrencyInstance (Locale.US); doppeltes Geld = d2.doubleValue (); String s = n.Format (Geld); System.out.println ("Formatiert:" + s); }}

Die Ausgabe für den obigen Code wird unten gezeigt:

Unformatiert: 5.465068 Formatiert: .46 

Beachten Sie die zusätzlichen Dezimalstellen im unformatierten BigDecimalObjekt im Vergleich zur formatierten Ausgabe. Wenn Sie den Wert des BigDecimalObjekts formatieren, wird der Bruchteil - größer als die Hälfte - gelöscht. Um die zusätzliche Dezimalstellen und den Mangel an Runden zu verwalten, können wir verwenden BigDecimal‚s setScale()Methode , um die Anzahl der Dezimalstellen. Bei der Verwendung setScale()müssen wir nicht nur die Anzahl der Dezimalstellen angeben, sondern auch, wie die Zahl gerundet wird, wenn eine Rundung erforderlich ist. Die gebräuchlichste Art der Rundung - Brüche auf die Hälfte oder mehr aufrunden und alle anderen Brüche abrunden - kann mit BigDecimalder Konstante ' angegeben werden ROUND_HALF_UP. Um die Anzahl der Dezimalstellen auf zwei zu setzen und anzugeben, dass Brüche mit der Hälfte und mehr aufgerundet werden, können wir Folgendes schreiben:

d2 = d2.setScale (2, BigDecimal.ROUND_HALF_UP); 

Wenn Sie das obige Programm ändern, um es hinzuzufügen setScale(), haben wir jetzt:

importiere java.math. *; import java.text. *; import java.util. *; öffentliche Klasse Multiply2 {public static void main (String [] args) {BigDecimal d = new BigDecimal ("1115.32"); BigDecimal taxRate = new BigDecimal ("0.0049"); BigDecimal d2 = d.multiply (taxRate); d2 = d2.setScale (2, BigDecimal.ROUND_HALF_UP); System.out.println ("Unformatiert:" + d2.toString ()); NumberFormat n = NumberFormat.getCurrencyInstance (Locale.US); doppeltes Geld = d2.doubleValue (); String s = n.Format (Geld); System.out.println ("Formatiert:" + s); }}

Jetzt ist die Ausgabe:

Unformatiert: 5.47 Formatiert: .47 

Jetzt wird der BigDecimalWert auf zwei Ziffern gerundet, wobei der Wert aufgerundet wird, und der formatierte StringWert zeigt den gerundeten Wert korrekt an. Andere Konstanten, die beim Runden nützlich sind, sind ROUND_HALF_DOWNund ROUND_HALF_EVEN. Der erste ROUND_HALF_DOWNrundet Bruchteile von der Hälfte und darunter ab und alle anderen auf. Die zweite ROUND_HALF_EVENRunde rundet halbe Brüche auf die gerade Zahl (z. B. 2,5 Runden auf 2, während 3,5 Runden auf 4) und Brüche größer oder kleiner als die Hälfte auf die nächste ganze Zahl. Beim Teilen von BigDecimalObjekten müssen wir angeben, wie das Ergebnis gerundet werden soll. Für diesen Artikel werden wir die Hälften aufrunden. Das folgende Programm zeigt eine Beispielaufteilung:

importiere java.math. *; import java.text. *; import java.util. *; public class Divide {public statisch void main (String [] args) {BigDecimal d = new BigDecimal ("1115.32"); BigDecimal-Tage = neues BigDecimal ("30"); BigDecimal d2 = d.divide (Tage, 2, BigDecimal.ROUND_HALF_UP); NumberFormat n = NumberFormat.getCurrencyInstance (Locale.US); doppeltes Geld = d2.doubleValue (); String s = n.Format (Geld); System.out.println (s); }}

Die Ausgabe des obigen Programms ist:

7.18 

Zinsen berechnen

For this example, assume that a sum of ,500 will receive interest payments at an annual rate of 6.7 percent. Payments will be calculated quarterly, and we will calculate the first quarterly payment. To do so, we will use the formula I=PRT, where I is the amount of interest, P is the principal (9,500), R is the rate (6.7 percent annually), and T is the time (0.25 years). The program is:

import java.math.*; import java.text.*; import java.util.*; public class Interest { public static void main(String[] args) { BigDecimal principal = new BigDecimal("9500.00"); BigDecimal rate = new BigDecimal("0.067"); BigDecimal time = new BigDecimal("0.25"); BigDecimal temp = principal.multiply(rate); BigDecimal interest = temp.multiply(time); NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US); double money = interest.doubleValue(); String s = n.format(money); System.out.println("First quarter interest: " + s); } } 

Output from the above program is:

First quarter interest: 59.12 

Mutual fund transactions

In this example, an investor owns 754.495 shares in a mutual fund. The investor makes an additional 00.00 purchase of shares at 0.38 per share. We will use the following Java program to answer two questions: How many shares does the investor own after purchase, and what is the current market value of the account after the purchase? We will assume that the mutual fund keeps track of share numbers to three decimal places:

import java.math.*; import java.text.*; import java.util.*; public class Mutual { public static void main(String[] args) { BigDecimal shares = new BigDecimal("754.495"); BigDecimal purchaseAmount = new BigDecimal("200.00"); BigDecimal pricePerShare = new BigDecimal("10.38"); BigDecimal sharesPurchased = purchaseAmount.divide(pricePerShare, 3, BigDecimal.ROUND_HALF_UP); shares = shares.add(sharesPurchased); BigDecimal accountValue = shares.multiply(pricePerShare); NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US); double dAccountValue = accountValue.doubleValue(); String sAccountValue = n.format(dAccountValue); System.out.println("Number of shares = " + shares.toString()); System.out.println("Account value = " + sAccountValue); } } 

The above program outputs:

Number of shares = 773.763 Account value = ,031.66 

More formatting

In the above example, the number of shares happens to be less than 1,000. If it had been greater than 1,000, the program would have outputted the number without a comma to separate the thousands place from the other digits. We can create a NumberFormat object to format numbers in the US style (commas separate thousands, periods separate decimals) by using:

NumberFormat n2 = NumberFormat.getInstance(Locale.US); 

Modifying the previous program to increase the number of shares to more than 1,000 and to display the number of shares formatted as we desire, we have:

import java.math.*; import java.text.*; import java.util.*; public class Mutual2 { public static void main(String[] args) { BigDecimal shares = new BigDecimal("1754.495"); BigDecimal purchaseAmount = new BigDecimal("2000.00"); BigDecimal pricePerShare = new BigDecimal("10.38"); BigDecimal sharesPurchased = purchaseAmount.divide(pricePerShare, 3, BigDecimal.ROUND_HALF_UP); shares = shares.add(sharesPurchased); BigDecimal accountValue = shares.multiply(pricePerShare); NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US); double dAccountValue = accountValue.doubleValue(); String sAccountValue = n.format(dAccountValue); NumberFormat n2 = NumberFormat.getInstance(Locale.US); double dShares = shares.doubleValue(); String sShares = n2.format(dShares); System.out.println("Number of shares = " + sShares); System.out.println("Account value = " + sAccountValue); } } 

The modified version (directly above) now outputs:

Number of shares = 1,947.173 Account value = 0,211.66 

Caveats

If you are writing a program that you or others will depend on for financial calculations, it makes sense to be as careful as possible. First, test your program thoroughly. Second, consult professionals, such as accountants, if you have any doubt as to the correct formula, rounding rule, or any other monetary aspect.

Summing up

BigDecimal objects, which represent values, can be added, subtracted, multiplied, and divided. While you can display BigDecimal objects using the toString() method, it is often preferable to create a NumberFormat object to format doubles obtained from BigDecimal. Now you can add the value of making simple interest calculations and mutual fund transactions in your Java programs.

Robert Nielsen ist ein Sun Certified Java 2 Programmer. Er hat einen Master-Abschluss in Pädagogik, der sich auf computergestützten Unterricht spezialisiert hat, und unterrichtet seit mehreren Jahren im Computerbereich. Er hat auch Computerartikel in verschiedenen Magazinen veröffentlicht.