Suplemento Nº 4 de New 2 Java (Oct-2001)
Lenguaje Java Básico
Convertir un String a un Valor Numérico
Una necesidad común de los desarrolladores en Java es convertir Strings a valores numéricos. Una vez convertido, podemos manipular ese valor como cualquier otro dato primitivo (por ejemplo, un int, float, o double). El problema es que, cuando leemos desde un fichero, obtenemos un argumento de la línea de comandos, o sólo solicitamos una entrada desde un campo de texto en un formulario, siempre empezamos con un objeto String. Tratar este String como un tipo primitivo requiere un paso extra, la conversión.
Para convertir un String a un tipo primitivo, debemos entender cómo usar una clase envolvura. Todo tipo primitivo tiene asociada una clase envoltura. Estas clases nos permiten tratar a los tipos primitivos como objetos. Además, estas clases contienen métodos que permiten la manipulación de estos objetos, apropiados para el tipo de datos.
La siguiente lista muestra el mapeo entre el tipo primitivo y su clase envoltura. En casi todos los casos, la clase envoltura tiene el mismo nombre que el tipo de datos primitivo con la primera letra en mayúsculas.
byte - Byte
short - Short
int - Integer
long - Long
char - Character
float - Float
double - Double
boolean - Boolean
Cada una de estas clases envoltura (excepto la clase Character) tiene un método que nos permitie convertir desde un String al tipo primitivo específico. Simplemente llamando al método desde la clase envoltura apropidada, y nuestro String será convertido en un tipo primitivo. Por ejemplo:
String myString = "12345";
int myInt = Integer.parseInt(myString);
convierte el contenido de la variable String myString a un objeto myInt. La conversión es así de fácil. El único truco es que la converisón para cada tipo implica un único nombre de método en cada clase envoltura. Todas excepto las conversiones booleanas se hacen por métodos con nombres similares. Pero los nombres de los métodos son diferentes:
byte - Byte.parseByte(aString)
short - Short.parseShort(aString)
int - Integer.parseInt(aString)
long - Long.parseLong(aString)
float - Float.parseFloat(aString)
double - Double.parseDouble(aString)
boolean - Boolean.valueOf(aString).booleanValue();
Hay una excepción: la clase Character no tiene dicho método, por eso tenemos que preguntar al String por el carácter con el método charAt:
// The variable e is the character e in the string Hello
String hello = "Hello";
char e = hello.charAt(1);
Si el contenido del String no se puede convertir al tipo primitivo solicitado, se lanzará una NumberFormatException. Esta es una excepción de tiempo de ejecución, por lo que la conversión no tiene que estar en un bloque try-catch.
Entender la Librería de Clases Java
La Clase NumberFormat
Imprimir números en la pantalla puede producir algunos resultados no desados. Por ejemplo:
public class PrintNum {
public static void main(String args[]) {
double amount = 400000.00;
System.out.println("He paid " + amount
+ " for the house.");
}
}
resulta en:
He paid 400000.0 for the house.
Añadir el símbolo $ en el string no mejorará estos resultados porque los tipos primitivos se imprimen con el número máximo de dígitos distintos de cero para ese tipo, y las comas no están incluidas en el resultado.
Podemos controlar la forma de mostrar y ordenar entradas en el formato de salida necesario usando la clase abstracta NumberFormat del paquete java.text. Esta clase proporciona el interface para formatear y analizar números, e incluye métodos para determinar que localidades tienen formatos numéricos y cuáles son sus nombres. La clase tiene métodos para tres formatos estándards:
- getInstance o getNumberInstance obtiene un formato para el formato de número normal, como 600,000.
- getCurrencyInstance obtiene un formato para el formato de número monetario, como $600,000.00.
- getPercentInstance obtiene un formato para mostrar porcentajes, como 56%
Para formatear un primitivo, empezamos devolviendo un objeto del tipo NumberFormat llamando a uno de los métodos de arriba. Para usar el ejemplo anterior para que muestre $400,000, llamamos a:
NumberFormat nf = NumberFormat.getCurrencyInstance();
Para asegurarnos de que la cantidad está formateada correctamente para un país específico, especificamos la localidad con:
NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US);
Ahora, el program de arriba se puede reescribir como:
import java.text.*;
import java.util.Locale;
public class PrintNum {
public static void main(String args[]) {
// Amount to be formatted
double amount = 400000.00;
// Returns an object of type NumberFormat
NumberFormat nf =
NumberFormat.getCurrencyInstance(Locale.US);
// Calls the format method on the NumberFormat object
// to format the amount as desired and prints the
// results to the screen
System.out.println("He paid " + nf.format(amount)
+ " for the house.");
}
}
Resultando en:
He paid $400,000.00 for the house.
Programa Ejercicio
Usa lo que has aprendido para crear una aplicación que lea argumentos desde la línea de comandos. Las reglas para manejar estos argumentos son éstas:
- Si el argumento es un entero, añade el valor a la respuesta.
- Si el argumento es un número en coma flotante, multiplica la respuesta por el valor.
- Si no hay argumento, muestra el argumento inválido
Una vez procesados los argumentos, muestra el valor resultante como moneda, con el símbolo de la moneda, las comas para separar los miles (asumiendo la Localidad US), el punto decimal, y dos dígitos después del decimal. Cuando se ejecute con la siguiente línea de comando:
java Numbers 1 2 3 4 5 2.3 3 4 4444.4 a
Tu programa deebería presentar un resultado similar a este:
Arg: 10 invalid (a)
The answer is $184,442.60
Un poco de Java
AWT contra Swing
Un error común es pensar que el Project Swing es un reemplazo para el Abstract Window Toolkit (AWT). De hecho, Swing es un conjunto de componentes más ligeros construido sobre AWT.
Originalmente el AWT fue diseñado para crear interfaces sencillos para applets. Swing proporciona reemplazos para los componentes de peso pesado del AWT y también incluye herramientas comunmente utilizadas en interfaces de usuario más complejos.
Un componente de peso pesado trata con el sistema de ventanas de la plataforma local para determinar el aspecto y comportamiento de los componentes. Todo componente de peso pesado tiene un par en el paquete java.awt.peer que es el responsable de las interacciones entre el componente y la plataforma local, como Mac, Windows y Solaris para mostrar y manipular el objeto.
Por otro lado, un componente de peso ligero, está escrito completamente en lenguaje Java y no necesita un par nativo. Para conseguir el aspecto y comportamiento específico de una plataforma, podemos usar la arquiectura Pluggable Look and Feel de Swing y su API.
En programación de aplicaciones, los controladores de distribución del AWT proporcionan una:
- Distribución para componentes organizados dentro de un panel.
- Mecanismos de manejo de eventos para menejar la funcionalidad de los componentes AWT o Swing como botones, campos de texto o áreas de texto.
Para completar una aplicación compleja escrita en Java, necesitarás entender un poco sobre el AWT, y mucho sobre Project Swing.
Solución al Programa de Ejercicio
Esta es una posible solución al Programa del Ejercicio:
import java.text.*;
import java.util.Locale;
public class Numbers {
public static void main(String args[]) {
// Initialize total
double answer = 0;
// Working variable
double number;
// Loop through all the command line args
for (int i=0; i < args.length; i++) {
try {
// First try to convert arg to an int
number = Integer.parseInt(args[i]);
// Add to total if int
answer += number;
} catch (NumberFormatException intTry) {
try {
// Next try to convert arg to a double
number = Double.parseDouble(args[i]);
// Multiple to total if double
answer *= number;
} catch (NumberFormatException doubleTry) {
// Display message if neither int nor double
System.err.println("Arg: " + (i+1) +
" invalid (" + args[i] + ")");
}
}
}
// Create a currency display format with Local included
NumberFormat nf =
NumberFormat.getCurrencyInstance(Locale.US);
// Display output as US currency format
System.out.println("The answer is " + nf.format(answer));
}
}
Descargar la Plataforma Java 2
Para la mayoría del desarrollo Java, necesitas las librerías de clases Java, el compilador, las herramientas, y el entorno de ejecución proporcionado por el kit de desarrollo de Java 2, Standard Edition.
Tutoriales
