Pregunta simple de Java: un conjunto de datos de cantidad, mostrados en letras mayúsculas de RMB
*?No utilicé ningún algoritmo muy sofisticado, pero usé algunas clases de la biblioteca Java, como expresiones regulares *? */
public?class?Trans2RMB?{
/**
?*?La viabilidad del programa de prueba
? * ?@param?args
?*/
público?{
System.out.println("\n-------- El número se convertirá a la forma mayúscula de la cantidad china-----------\n");
Trans2RMB?t2r?=?new?Trans2RMB();
String?s?=?t2r .cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum())));
//Si la cadena convertida está vacía cadena, entonces No mostrar la pantalla
if(!"" .equals(s))?{
System.out.println("Convertido a chino como: "? ? s);;
}
System.out.println("\n---------------------- ---- ------------------");
}
/**
?*?Desde la línea de comando recibe un número y llama al método ?checkNum()?
?*?Verifica y devuelve el valor correspondiente
?*?Si la entrada es legal , devuelve el número de entrada
?*/
privado?{
Cadena?Ingrese el número de punto flotante desde la línea de comando
java.util.Scanner? escáner?=?new?java.util.Scanner(System.in);
s?=?scanner.next();
// Cerrar el escáner
p>scanner.close();
// Determinar si la entrada del usuario es legal
// Si es legal, devolver este valor; si es ilegal, devolver? 0"
if(this.checkNum(s))?{
Devolver s;
} else ?{
Regresar?"" ;
}
}
}
/**
?*? Determinar los datos ingresados por el usuario ¿Es legal? Los usuarios solo pueden ingresar números mayores que 0 y no pueden ingresar otros caracteres
?*?@param?s?String
?*@param?s?String
?Si los datos ingresados por el usuario son legales, devuelve verdadero, en caso contrario devuelve falso
?*/
private?boolean?checkNum(String?s)?{
//Si el número ingresado por el usuario contiene caracteres no numéricos, se considera datos ilegales y devuelve falso
try {
float f = Float.valueOf( s);
//Si el número es menor que cero, ¿se considera dato ilegal y se devuelve? false
if(f?lt;?0)?{
System.out.println("Ille
datos gal, ¡compruébalo!");
return?false;
}¿else?{
return?true;
}
}?{
System.out.println("¡Datos ilegales, verifíquelos!");
return?false; > }
}?
}
/**
?*?Dividir la entrada del usuario en decimales y llamar a numFormat () método
?*?Convertir la cantidad china correspondiente a mayúsculas
?*?Nota: El número entrante debe redondearse usando el método ?roundString()
private?{
///Si se pasa una cadena vacía, se seguirá devolviendo la cadena vacía
if("".equals(s))?{
¿Devolver?""; Pulsa Dividir la cadena con un punto decimal
int? Interceptar y convertir la parte entera de este número
String?intOnly?=?s.substring(0,?index);
String?part1?=?this.numFormat(1,?intOnly);
///?Interceptar y convertir la parte decimal del número
String? smallOnly?=?s .substring(index? ?1);
String?part2?=?this.numFormat(2,?smallOnly);
//Convertir el convertido partes enteras y decimales Reensamblar en una nueva cadena
String?newS?=?part1 ?part2;
return?newS;
}
/**
?*?Redondea el número ingresado
?*?El número ingresado desde la línea de comando
?*@param?s ?String ?@return?El nuevo valor después del redondeo
?*/
private?String?roundString(String?s) ?{
///? Si se aprueba, ingrese una cadena vacía y luego continúe devolviendo una cadena vacía
if("".equals(s))?{
Return?"";
}
///?Convierta este número a tipo doble y redondeelo
double d = double.parseDouble(s);
///?Esto operación Se aplica a dos dígitos después del punto decimal
d?=?(d?*?100? ?0.5)?/?100;
//Formato d?
s?=?new?java.text.DecimalFormat("##0.000").format(d);
// Dividir la cadena con puntos decimales
int?La parte entera del número
String?intOnly?=?s.substring(0,?index);
//La longitud máxima del el valor especificado es solo ¿Puede alcanzar billones de unidades; de lo contrario, devolverá "0"
if(intOnly.length()? gt;?13)?{
System.out.println ("¡Los datos de entrada son demasiado grandes! (¡La parte entera tiene hasta 13 dígitos!)");
Retorno?"";
}
//La parte decimal del número
String?smallOnly?=?s .substring(index? ? 1);
///?Si la parte decimal es mayor que dos dígitos, solo se interceptarán los dos dígitos después del punto decimal
if(smallOnly .length()? gt;?2) ?{
String?roundSmall?=?smallOnly.substring(0,?2);
//Reensamblar la cadena con parte entera y la parte decimal recién interceptada
s?=?intOnly? ?" ."?? roundSmall;
}
return?s;
}
/**
?*?Convierta el número ingresado a la forma mayúscula de la cantidad china
?*?@ param?flag?int?flag dígito, 1 Indica convertir la parte entera, 0 indica convertir la parte decimal
?*?@param?s?String?*?@return?Forma mayúscula convertida de cantidad china con unidades
?*/
private?{
int?sLength?=?s.length();
// ?Forma de capital en moneda
Cadena ?{"Cero",?"Uno",?"Dos",?"tres",?""4",?"Cinco.L","7", "8","9".
Ocho",?" Nueve"};
///? Unidad monetaria
Cadena?{"yuan",? "peso",? "cien",? "mil", ? "Diez mil", ?
// Gigabit a mil
"Gigabit", "cien", "mil",
// Miles de millones a billones
"Miles de millones", "Diez", "Cientos", "Miles", "Diez mil"};
¿Cadena?{"centavos" "分"}
//Utilizado para guardar la nueva cadena convertida
String?newS?=?""
/ /?Reemplazar poco a poco con chino letras mayúsculas
for(int?i?=?0;?i?lt;?sLength;?i? )?{
if(bandera? ==?1)? {
//Convertir la parte entera a mayúsculas chinas (con unidad)
newS ?unit[sLength?-?i?-?1] ;
}?else?if(flag?==?2)?{
//Convertir la parte decimal (con unidad)
newS ? ?i?-?1];
}
}
}
return?newS;
p>}
/**
?*?Mejorar la capitalización de cantidades chinas convertidas limpiando esta palabra
?*? cadena para hacerlo más compacto
?*?Nota: El número pasado debería haber sido procesado por el método splitNum()?
?* ?La cadena ya debería ser china. cantidad en letras mayúsculas
?*?@param?s?String?cadena ya convertida
?*?@return?*/
privado?{
///?Si se pasa una cadena vacía, se seguirá devolviendo la cadena vacía
if("".equals(s))?{
Return?"";
}
//Si el usuario comienza a escribir muchos "0", elimine los "0" adicionales delante de la cadena. para hacerlo legible Parece más idiomático
while(s.charAt(0)? ==?0')?{
///Establecer "?0"? cadena y su La unidad correspondiente se elimina
s?=?s.substring(2);
//Si el usuario solo ingresa "0" al escribir inicialmente, solo devuelve "?Cero"
if(s.length()?{
Devuelve "cero";
}
}
}
///? Cuando hay varios "ceros" en la cadena, solo se lee un "cero" y se omiten las unidades adicionales
/*? Como soy demasiado nuevo en la investigación de algoritmos, solo puedo usar 4 expresiones regulares para la conversión. ¿No te importa, gambas...? */
Cadena?{"cero-mil", ?" cero cien", ?" ZeroPercent"}
Cadena?{"cero mil millones", ?"Cero millones "; ,?" cero dólares"};
String?regex3[]?{"billion",?"diez mil","yuan"};
String? {"cero centavos","cero centavos"};
//Primero
Esta conversión convierte cadenas como "cero mil", "cero cien" y "cero diez" en "cero"
for(int?i?=?0;?i?lt;?3; ?i? )?{
s?=?s.replaceAll(regex1[i],?" Cero");
}
// La segunda conversión considera "cero mil millones", "cero millones", "cero yuanes", etc.
//Las unidades "mil millones", "diez mil" y "yuan" no se pueden omitir en algunos casos y deben conservarse
for(int?i?= ?0; ?i?lt;?3;?i? )?{
//Después de la primera conversión, puede haber varios ceros apilados
/ /?Convertir. múltiples ceros repetidos en un cero
s?=?s.replaceAll("Zero Zero",?" Zero");
s?=?s .replaceAll("Zero Zero" ",?" cero");
s?=?s.replaceAll(regex2[i],?regex3[i]);
}
///?La tercera conversión omite las cadenas "ángulo cero" y "puntos cero"
for(int?i?=?0;?i?lt;?2 ;?i? )?{
s?=?s.replaceAll(regex4[i],?"")
}
// Cuando "millones" y "miles de millones" son ambos ceros, la unidad "mil millones" se ignora y solo se retiene una unidad "mil millones"
s?=?s.replaceAll("mil millones" ,?" mil millones");
retorno?s;
}
}
}