Utilice Java para escribir la clase de entrada 1011 y salida 1011.
Clase pública Trans2RMB { /**
*Prueba la viabilidad del programa
* @param args
*/
Public static void main(String[] args) {
System.out.println("\n -
trans 2 RMB t2r = new trans 2 RMB();
cadena s = t2r . clean zero(t2r . split num(t2r . round string(t2r . getnum())));
// Si la cadena convertida es una cadena vacía, no se producirá ninguna salida en pantalla
If (!"".Equals(s)) {
System.out. println("Convertir. Después de convertirse en chino: "+s);;
}
system out . }
/**
*Recibe un número de la línea de comando llamando al método checkNum()
*Verifica y devuelve el valor correspondiente
* @returnSi la entrada es legal, devuelve el número ingresado
*/
Cadena privada getNum() {
String s = null
System.out.println("Ingrese un número (con una precisión de dos decimales):");
//Ingrese este número de punto flotante desde la línea de comando <. /p>
Java .escáner escáner = nuevo Java .escáner(sistema . en); este escáner
p>scanner . close();
//Determina si la entrada del usuario es legal
//Si es legal, devuelve esto. valor; si "0" es ilegal, devuelva
if(this.checkNum(s)) {
Devuelva s; >
Devolver "";
p>
}
}
/**
*Para determinar si los datos ingresados por el usuario son legales, el usuario solo puede ingresar números mayores que cero. No se pueden ingresar otros caracteres
* @param s string
* @return Devuelve verdadero. si los datos ingresados por el usuario son legales, en caso contrario devuelve falso.
*/
CheckNum booleano privado(string){
//Si el número ingresado por el usuario contiene caracteres no numéricos, se considerará como datos ilegales y devueltos falsos.
Pruebe {
float f = float value of(s);
//Si este número es menor que cero, se considera dato ilegal y devuelve falso.
if(f & lt; 0) {
System.out.println("¡Datos ilegales, verifíquelos!");
Devuelve falso
p>
} En caso contrario {
Devuelve verdadero
}
} catch(NumberFormatException e){
System.out println("Datos ilegales, ¡compruébelos!");
Devuelve falso
}
}
/. **
* Divide el número ingresado por el usuario por el punto decimal y llama al método numFormat().
*Convierte la cantidad china correspondiente en forma de capital.
*Nota: El número entrante debe redondearse usando el método roundString().
* @param s string
* @Devuelve la cadena china convertida en mayúsculas.
*/
Cadena privada splitNum(String s) {
//Si se pasa una cadena vacía, continúa devolviendo una cadena vacía.
If ("". Igual a (s)) {
Return ""
}
//Convierte esta cadena Dividir por punto decimal.
int index = s.indexOf(" . ");
//Intercepta y convierte la parte entera de este número.
cadena en solo = s . substring(0, index);
cadena parte 1 = this num format(1, en solo); /Intercepta y convierte la parte decimal de este número.
cadena pequeña solamente = s. substring(index+1);
Cadena part2 = this.numFormat(2, solo pequeña);
//Will La parte entera convertida y la parte decimal se vuelven a ensamblar en una nueva cadena.
Cadena newS = parte 1+parte 2;
Mensaje de respuesta;
}
/**
* Redondea el número pasado.
* @param s String Número ingresado desde la línea de comando.
* @Devuelve el nuevo valor redondeado.
*/
Cadena privada roundString(String s) {
//Si se pasa una cadena vacía, continúa devolviendo una cadena vacía.
If ("". Igual a (s)) {
Return ""
}
//Convierte este número Ser de tipo doble y redondeado.
double d = double . parse double(s);
//Esta operación funciona con dos decimales.
d =(d * 100.5)/100;
//Formato d
s = nuevo formato decimal de Java(" # #. 0,000"). Formato (d);
//Dividimos esta cadena por el punto decimal.
int index = s.indexOf(" . ");
//La parte entera de este número
cadena en solo = s. , index);
//La longitud máxima del valor especificado solo puede alcanzar billones de unidades; de lo contrario, se devuelve "0".
if(into only . length()& gt; 13) {
System.out.println("¡Los datos de entrada son demasiado grandes! (La parte entera es hasta 13 dígitos!)") ;
Return "";
}
//La parte decimal de este número
cadena pequeña solamente = s . substring(index +1);
//Si la parte decimal excede los dos dígitos, solo se truncarán los dos dígitos después del punto decimal.
if(solo pequeño. longitud()& gt; 2) {
cadena redonda pequeña = solo pequeño subcadena(0, 2); /Vuelva a juntar la parte entera y la parte decimal recién truncada para formar esta cadena.
s = en solo+".+redondo pequeño;
}
Devuelve s;
}
/**
*Convierte el número de la persona que llama a una cantidad china en mayúsculas
* @param flag int flag, 1 significa convertir la parte entera, 0 significa convertir la parte decimal
* p>
* @param s String La cadena que se va a convertir
* @Devuelve la cantidad de RMB convertida en mayúsculas, con unidades. /
Cadena privada numFormat(int flag, String s) {
int sLength = s .
//Moneda en mayúsculas
String bigLetter[] = { "cero", "uno", "dos", "tres", "cuatro", "cinco", "tierra", "siete", "ocho", "nueve" };
//Unidad monetaria
Unidad de cadena[] = { "yuan", "diez", "cien", "mil", "diez mil",
//De cien mil a diez millones
"Shi", "Cien", "Mil",
//De mil millones a un billón de dígitos
"Mil millones", "Diez", "Cien", "Mil", "Diez Mil"};
Cadena pequeña[] = {"puntos", "ángulos"};
//Se usa para almacenar la nueva cadena convertida
String newS =
//Usa la forma mayúscula china poco a poco
para (int I = 0; i<length; i++) {
if(flag == 1) {
//Convierte la parte entera a mayúsculas chinas (con unidades)
nuevoS = nuevoS+letra grande[s . charat(I)-48]+unidad[s longitud-I-1];
} else if(bandera == 2 ) {
//Convertir la parte decimal (con unidad)
newS = newS+big letter[s . charat(I)-48]+small[sLength-I-1] ;
}
}
Mensaje de respuesta;
}
/**
*Mejorar la capitalización de conversión de cantidades chinas y limpia esta palabra
*Los ceros adicionales en la cadena hacen que esta cadena sea más impresionante
*Nota: El número ingresado debe ser manejado por splitNum. () método. La cadena de palabras
* debe estar representada en mayúsculas chinas.
* La cadena de @param se ha convertido a la cadena correcta.
* @Devuelve la cadena mejorada
*/
Cadena privada cleanZero(String s) {
//Si se pasa Si se Si se ingresa una cadena vacía, se seguirá devolviendo la cadena vacía.
If ("". Igual a (s)) {
Return ""
}
//Si el usuario comienza a escribir Muchos ceros, elimine los "ceros" adicionales delante de la cadena para que parezca más idiomática.
While(s.charAt(0) ==' zero') {
//Elimina "cero" y su unidad correspondiente de la cadena.
s = s . substring(2);
//Si el usuario solo ingresa 0 al principio, solo se devolverá un "cero".
if(s.length() == 0) {
Devuelve "cero"
}
}
//Cuando hay varios "ceros" en la cadena, lea solo un "cero" e ignore las unidades adicionales.
/*Debido a que mi investigación sobre algoritmos es demasiado pobre, solo puedo usar cuatro expresiones regulares para convertir, así que no te preocupes...*/
String regex1[] = { "cero mil", "cero cien", "cero selección" };
String regex2[] = { "cero mil millones", "cero millones", "cero yuanes"
String regex3[] = { "Mil millones", "Wan", "Yuan" };
String regex4[] = { "Ángulo cero", "Punto cero" }; >
//En la primera ronda de conversión, cadenas como "cero mil", "cero cien" y "selección cero" se reemplazan por "cero"
for(int I = 0; I & lt3;i ++) {
S = s.replaceAll(regex1[i], "zero");
}
//Segundo Gire el cálculo y considere "cero mil millones", "cero millones" y "cero yuanes".
//Las unidades de "100 millones", "10.000" y "10.000 yuanes" en algunos casos no se pueden guardar y es necesario guardarlas.
for(int I = 0;i<3;i++) {
//Es posible que haya muchos ceros apilados después de la primera ronda de conversiones.
//Convierte muchos ceros repetidos en unos.
S = s.replaceAll ("cero cero", "cero");
S = s.replaceAll ("cero cero", "cero");
s = s.replaceAll(regex2[i], regex 3[I]);
}
//La tercera ronda de conversión omite el "ángulo de cero grados" y Cadena "Punto cero".
for(int I = 0;i<2;i++) {
s = s.replaceAll(regex4[i], " ");
}
//Cuando todo entre "diez mil" y "cien millones" sea "cero", ignore la unidad de "cien millones" y conserve solo uno "cien millones".
S = s.replaceAll("mil millones", "mil millones");
Devuelve
}
}
p>