La copie de code est la suivante:
Importer java.io.bufferedReader;
Importer java.io.ioException;
Importer java.io.inputStreamReader;
import java.util.regex.matcher;
import java.util.regex.pattern;
/ **
* L'implémentation simple de la multiplication de grands nombres n'est pas encore très parfaite
* Réparer:
* 1. Quelques erreurs de suppression de 0 avant et après modification
* 2. Soutenir le fonctionnement du nombre négatif
* 3. Pour déterminer si la chaîne d'entrée répond à la définition décimale, utilisez des expressions régulières pour juger
* @author icejoywoo
* @Since 2012.2.16
* @version 0.1.1
* /
classe publique Bignumber {
public static void main (String [] args) lance ioException {
System.out.println ("saisir deux grands entiers:");
BufferedReader Buffer = new BufferedReader (new InputStreamReader (System.in));
String [] starray = buffer.readline (). Split ("// *");
System.out.println (BignumberMultiply (StraRray [0], StraRray [1]));
}
/ **
* Calculez le produit de deux nombres de toute taille et précision
* @param premier premier paramètre
* @param deuxième deuxième paramètre
* @return Multiply de deux nombres
* /
String statique privé bignumbermultiply (String First, String second) {
// signe de signe positif et négatif
booléen drapeau = false;
if (first.charat (0) == '-') {
Flag =! Flag;
premier = first.substring (1);
}
if (second.charat (0) == '-') {
Flag =! Flag;
second = second.substring (1);
}
// la position du point décimal
int appoints = first.length () - first.indexof ('.') - 1;
int bpoints = second.length () - second.indexof ('.') - 1;
int pointPos = appoids + bpoints; // la position du point décimal du résultat
// Supprimer le point décimal
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];
// Calculer
pour (int i = 0; i <a.Length; i ++) {
pour (int j = 0; j <b.length; j ++) {
résultat [i + j] + = a [i] * b [j];
}
}
// Si un certain résultat est supérieur à 9, il doit être transporté.
for (int i = result.length - 1; i> = 0; --i) {
if (résultat [i]> 9) {
résultat [i - 1] + = résultat [i] / 10;
résultat [i] = résultat [i]% 10;
}
}
StringBuffer Buffer = new StringBuffer ();
for (int i = 0; i <result.length; ++ i) {
// ajouter des décimaux
if (result.length - i == Pointpos) {
Buffer.APPEND (".");
}
Buffer.APPEND (String.ValueOf (résultat [i]));
}
if (buffer.indexof (".")! = -1)
{
// Supprimer le premier 0
int i = 0;
while (i <buffer.length ()) {
if (buffer.length ()> 2 && buffer.charat (i + 1) == '.') {// Il n'y a qu'un seul numéro 0 avant le point décimal.
casser;
} else if (buffer.charat (i) == '0') {// supprimer le premier 0
tampon.deletecharat (i);
i = 0;
continuer;
} else {// Lorsque la première position n'est pas 0
casser;
}
}
// supprime la fin 0
i = buffer.length () - 1;
while (i> = 0) {
if (buffer.length ()> 2 && buffer.charat (i-1) == '.') {// Le point décimal est directement un nombre
casser;
} else if (buffer.charat (i) == '0') {// supprimer le 0 à la fin
tampon.deletecharat (i);
i = buffer.length () - 1;
continuer;
} else {// Lorsque le dernier bit n'est pas 0
casser;
}
}
}
// Selon le bit de signe, les drapeaux positifs et négatifs de la valeur de retour
if (Flag) {
return "-" + buffer.toString ();
} autre {
retour tamper.toString ();
}
}
/ **
* Remplacez la chaîne en un tableau
* numéro @param
* @retour
* /
private static int [] string2IntArray (numéro de chaîne) {
// déterminer si l'entrée répond aux exigences des numéros de points flottants
Motif motif = motif.compile ("^ (-? // d + | // d *) //.?// d * $");
Matcher Matcher = Pattern.matcher (numéro);
if (! Matcher.find ()) {
Jetez un nouveau IllégalArgumentException ("Le numéro d'entrée est incorrect!");
}
int [] result = new int [nombre.length ()];
for (int i = 0; i <nomb.length (); i ++) {
Result [i] = (int) (nombre.charat (i) - '0');
}
Résultat de retour;
}
}
Les résultats de l'opération sont les suivants:
1. Jugement d'une entrée incorrecte
La copie de code est la suivante:
Entrez deux grands entiers:
1A * A22
Exception dans Thread "Main" Java.lang.ILLEGALArgumentException: le numéro d'entrée est incorrect!
sur bignumber.String2IntArray (bignumber.java:132)
sur bignumber.bignumberMultiply (bignumber.java:54)
sur bignumber.main (bignumber.java:22)
2. Fonctionnement avec des nombres négatifs, avec 0 avant et après
La copie de code est la suivante:
Entrez deux grands entiers:
-23424.2300 * 02345.234000000
-54935300.61982
Le calcul des résultats en python est le suivant
La copie de code est la suivante:
Python 2.6.5
>>> -23424.2300 * 02345.23400000
-54935300.619819999
On peut voir que les résultats de Python sont déformés