Die Codekopie lautet wie folgt:
Import Java.io.BufferedReader;
importieren java.io.ioException;
importieren java.io.inputStreamReader;
Import Java.util.Regx.Matcher;
Import Java.util.Regex.Pattern;
/**
* Die einfache Implementierung großer Zahlenmultiplikation ist noch nicht sehr perfekt
* Fix:
* 1. Einige Fehler beim Löschen von 0 vor und nach der Änderung
* 2. Unterstützung der negativen Zahl unterstützen
* 3. Um festzustellen, ob die Eingangszeichenfolge die Dezimaldefinition erfüllt, verwenden Sie reguläre Ausdrücke, um zu beurteilen
* @author icejoywoo
* @Sonce 2012.2.16
* @Version 0.1.1
*/
öffentliche Klasse BIGNUMBER {
public static void main (String [] args) löst ioException {aus
System.out.println ("Eingeben zwei große ganze Zahlen:");
BufferedReader buffer = neuer bufferedReader (neuer InputStreamReader (System.in));
String [] strarrray = buffer.readline (). Split ("//*");
System.out.println (BIGNUMBERMULTIPLY (Strarrray [0], Strarrray [1]));
}
/**
* Berechnen Sie das Produkt von zwei Zahlen jeder Größe und Präzision
* @param erster erster Parameter
* @Param Second Second Parameter
* @return multiplizieren Sie zwei Zahlen
*/
private statische Zeichenfolge BIGNUMBERMULTIPLY (String zuerst, String zweitens) {
// Zeichen eines positiven und negativen Vorzeichens
boolesche Flagge = Falsch;
if (first.charat (0) == '-') {
Flagge =! Flag;
first = zuerst.substring (1);
}
if (Second.Charat (0) == '-') {
Flagge =! Flag;
zweite = zweite.substring (1);
}
// die Position des Dezimalpunkts
int apoints = first.length () - first.indexof ('.') - 1;
int bpoints = Second.length () - Second.Indexof ('.') - 1;
int pointpos = ordnungsgemäß + boints;
// den Dezimalpunkt löschen
StringBuffer Abuffer = new StringBuffer (first.replaceAll ("//.", ""));
StringBuffer bbuffer = new StringBuffer (Second.ReplaceAll ("//", ""));
int [] a = string2intArray (Abuffer.ToString ());
int [] b = string2intArray (bbuffer.toString ());
int [] result = new int [A.Length + B.Length - 1];
// berechnen
für (int i = 0; i <A.Length; i ++) {
für (int j = 0; j <B.Length; j ++) {
Ergebnis [i + j] + = a [i] * b [j];
}
}
// Wenn eine bestimmte im Ergebnis größer als 9 ist, muss es getragen werden.
für (int i = result.length -1; i> = 0; --i) {
if (Ergebnis [i]> 9) {
Ergebnis [i - 1] += Ergebnis [i] / 10;
Ergebnis [i] = Ergebnis [i] % 10;
}
}
StringBuffer Buffer = new StringBuffer ();
für (int i = 0; i <result.length; ++ i) {
// Dezimalpunkte hinzufügen
if (result.length - i == pointpos) {
Buffer.Append (".");
}
Buffer.Append (String.ValueOf (Ergebnis [i]));
}
if (buffer.indexof (".")! = -1)
{
// die erste 0 löschen
int i = 0;
while (i <buffer.length ()) {
if (buffer.length ()> 2 && buffer.charat (i+1) == '.') {// Es gibt nur eine Nummer 0 vor dem Dezimalpunkt.
brechen;
} else if (buffer.charat (i) == '0') {// Die erste 0 löschen
Buffer.DeletEcharat (i);
i = 0;
weitermachen;
} else {// Wenn die erste Position nicht 0 ist
brechen;
}
}
// das Ende 0 löschen
i = buffer.length () - 1;
while (i> = 0) {
if (buffer.length ()> 2 && buffer.charat (i-1) == '.') {// Der Dezimalpunkt ist direkt eine Nummer
brechen;
} else if (buffer.charat (i) == '0') {// Löschen Sie die 0 am Ende
Buffer.DeletEcharat (i);
i = buffer.length () - 1;
weitermachen;
} else {// Wenn das letzte Bit nicht 0 ist
brechen;
}
}
}
// Nach dem Vorzeichenbit die positiven und negativen Flaggen des Rückgabewerts
if (Flag) {
return "-" + buffer.toString ();
} anders {
return buffer.toString ();
}
}
/**
* Ersetzen Sie die Zeichenfolge in ein Array
* @param nummer
* @zurückkehren
*/
private static int [] string2intArray (String -Nummer) {
// Bestimmen Sie, ob die Eingabe den Anforderungen der schwimmenden Punktzahlen entspricht
Muster muster = muster.comPile ("^(-? // d+| // d*) //.?/ D*$");
Matcher Matcher = muster.Matcher (Nummer);
if (! matcher.find ()) {
Neue IllegalArgumentException werfen ("Die Eingangsnummer ist falsch!");
}
int [] result = new int [number.length ()];
für (int i = 0; i <nummer.length (); i ++) {
Ergebnis [i] = (int) (number.charat (i) - '0');
}
Rückgabeergebnis;
}
}
Die Betriebsergebnisse sind wie folgt:
1. Beurteilung falscher Eingaben
Die Codekopie lautet wie folgt:
Geben Sie zwei große Ganzzahlen ein:
1a*A22
Ausnahme im Thread "Haupt" java.lang.ILLEGALARGUMENTException: Die Eingabenummer ist falsch!
bei Bignumber.String2intArray (bignumber.java:132)
bei bigumber.bignumbermultiply (bignumber.java:54)
bei bigumber.main (bignumber.java:22)
2. Betrieb mit negativen Zahlen, mit 0 vor und nachher
Die Codekopie lautet wie folgt:
Geben Sie zwei große Ganzzahlen ein:
-23424.2300*02345.234000000
-54935300.61982
Die Berechnung führt zu Python wie folgt
Die Codekopie lautet wie folgt:
Python 2.6.5
>>> -23424.2300*02345.23400000
-54935300.619819999
Es ist ersichtlich, dass die Ergebnisse von Python verzerrt sind