A cópia do código é a seguinte:
importar java.io.bufferedReader;
importar java.io.ioException;
importar java.io.inputStreamReader;
importar java.util.regex.matcher;
importar java.util.regex.pattern;
/**
* A simples implementação de multiplicação de grandes números não é muito perfeita ainda
* Consertar:
* 1. Alguns erros de excluir 0 antes e depois da modificação
* 2. Suporte a operação de número negativo
* 3. Para determinar se a sequência de entrada atende à definição decimal, use expressões regulares para julgar
* @Author Icejoywoo
* @Since 2012.2.16
* @version 0.1.1
*/
classe pública Bignumber {
public static void main (string [] args) lança ioexception {
System.out.println ("Entre dois números inteiros grandes:");
BufferReader buffer = new BufferredReader (new InputStreamReader (System.in));
String [] Strarray = buffer.readline (). Split ("//*");
System.out.println (BigMumberMultiply (Strarray [0], Strarray [1]));
}
/**
* Calcule o produto de dois números de qualquer tamanho e precisão
* @param primeiro primeiro parâmetro
* @param segundo segundo parâmetro
* @return Multiply de dois números
*/
String estática privada bignumberMultiply (string primeiro, string segundo) {
// sinal de sinal positivo e negativo
bandeira booleana = false;
if (primeiro.charat (0) == '-') {
sinalizador =! sinalizador;
primeiro = primeiro.substring (1);
}
if (Second.Charat (0) == '-') {
sinalizador =! sinalizador;
segundo = segundo.substring (1);
}
// a posição do ponto decimal
int apoios = primeiro.length () - primeiro.IndexOf ('.') - 1;
int BPoints = Second.Length () - Second.IndexOf ('.') - 1;
int Pointpos = Apoints + BPoints;
// Exclua o ponto decimal
StringBuffer abuffer = new StringBuffer (First.Replaceall ("//.", ""));
StringBuffer bBuffer = new StringBuffer (Second.Replaceall ("//.", ""));
int [] a = string2intary (abuffer.toString ());
int [] b = string2intary (bbuffer.toString ());
int [] resultado = new int [A.Length + B.Length - 1];
// calcular
for (int i = 0; i <A.Length; i ++) {
for (int j = 0; j <b.length; j ++) {
resultado [i + j] + = a [i] * b [j];
}
}
// Se um certo no resultado for maior que 9, ele precisa ser transportado.
for (int i = resultado.length -1; i> = 0; --i) {
if (resultado [i]> 9) {
resultado [i - 1] += resultado [i] / 10;
resultado [i] = resultado [i] % 10;
}
}
StringBuffer buffer = new StringBuffer ();
for (int i = 0; i <resultado.length; ++ i) {
// Adicionar pontos decimais
if (resultado.length - i == Pointpos) {
buffer.append (".");
}
buffer.append (string.valueof (resultado [i]));
}
if (buffer.indexof (".")! = -1)
{
// Exclua o primeiro 0
int i = 0;
while (i <buffer.length ()) {
if (buffer.length ()> 2 && buffer.charat (i+1) == '.') {// Há apenas um número 0 antes do ponto decimal.
quebrar;
} else if (buffer.charat (i) == '0') {// exclua o primeiro 0 0
buffer.deleteCharat (i);
i = 0;
continuar;
} else {// quando a primeira posição não é 0
quebrar;
}
}
// Exclua o fim 0
i = buffer.length () - 1;
while (i> = 0) {
if (buffer.length ()> 2 && buffer.charat (i-1) == '.') {// O ponto decimal é diretamente um número
quebrar;
} else if (buffer.charat (i) == '0') {// exclua o 0 no final
buffer.deleteCharat (i);
i = buffer.length () - 1;
continuar;
} else {// quando o último bit não é 0
quebrar;
}
}
}
// De acordo com o bit de sinal, as bandeiras positivas e negativas do valor de retorno
if (flag) {
return "-" + buffer.toString ();
} outro {
retornar buffer.toString ();
}
}
/**
* Substitua a string em uma matriz
* Número @param
* @retornar
*/
private static int [] string2intary (número da string) {
// determinar se a entrada atende aos requisitos dos números de ponto flutuante
Padrão padrão = padrony.compile ("^(-? // d+| // d*) //.?// d*$");
Matcher Matchaer = Pattern.Matcher (número);
if (! Matcher.find ()) {
jogue novo ilegalArgumentException ("O número de entrada está incorreto!");
}
int [] resultado = new int [número.Length ()];
for (int i = 0; i <número.Length (); i ++) {
resultado [i] = (int) (número.Charat (i) - '0');
}
resultado de retorno;
}
}
Os resultados da operação são os seguintes:
1. Julgamento de entrada incorreta
A cópia do código é a seguinte:
Entre dois números inteiros grandes:
1A*A22
Exceção no thread "Main" java.lang.illegalargumentException: o número de entrada está incorreto!
em BigMumber.String2INTARRAY (BigMUMBRO.JAVA:132)
em BigMumber.bignumberMultiply (bignumber.java:54)
em bignember.main (bignumber.java:22)
2. Operação com números negativos, com 0 antes e depois
A cópia do código é a seguinte:
Entre dois números inteiros grandes:
-23424.2300*02345.234000000
-54935300.61982
O cálculo resulta em Python é o seguinte
A cópia do código é a seguinte:
Python 2.6.5
>>> -23424.2300*02345.23400000
-54935300.619819999
Pode -se observar que os resultados do python estão distorcidos