En esta corta y sencilla entrada vamos a tratar un problema de los más comunes que se pueden presentar al programar en Java: ¿cómo puedo transformar un texto en un tipo int o long?

Pues es tan fácil como esto:

int i = 0;
long l = 0;
 
String s = "100000";
 
try {
 
    // Convertimos s en un entero
    i = Integer.parseInt(s);
 
    // Convertimos s en un long
    l = Long.parseLong(s);
 
} catch(NumberFormatException nfe) {
 
    System.err.println("La cadena " + s + " no es un número válido");
    nfe.printStackTrace();
 
}

Continuando con las anteriores entregas de Manejo de cadenas en Java, hoy vamos a comentar un método que es muy útil para ordenar listados de palabras.

Como su nombre indica, el método compareTo(String str) realiza una comparación entre un String (en este caso) y otro objeto de tipo String.

Lo que realmente hace este método, es observar una cadena con respecto a otra y devolverá un número entero int. Este número determinará cuál de las dos cadenas va antes o después. El entero valdrá menos que 0 si la cadena argumento es lexicográficamente mayor que la cadena a comparar, 0 si son iguales y será mayor que 0 si es menor. Por ejemplo:

public class StringTest {
    public static void main(String[] args) {
        String s = "a";
        String s2 = "b";
 
        System.out.println(s.compareTo(s2)); // -1
        System.out.println(s2.compareTo(s)); // 1
 
        s2 = "aa";
 
        System.out.println(s.compareTo(s2)); // -1
        System.out.println(s2.compareTo(s)); // 1
 
        s2 = "c";
 
        System.out.println(s.compareTo(s2)); // -2
        System.out.println(s2.compareTo(s)); // 2
    }
}

El lenguaje de programación Java nació hace 15 años, según su creador, James Gosling, Desde Java-Spain queremos agradecerle su creación, ya que sin ella no sería posible este blog ni muchos otros.

Hoy el tema que nos ocupa es uno sencillo, pero que no debe pasarse por alto, por ser estas clases unas de las más usadas, dado su sencillo funcionamiento.

En primer lugar, vamos a inicializar un array de String, que como sabéis tiene longitud fija, lo que es un pequeño inconveniente a la hora de trabajar con algunos conjuntos de elementos. Para solucionar este problema, tenemos otras clases llamadas colecciones.

Dos de ellas son ArrayList y Vector. Un ArrayList es una implementación de la clase List, que es una colección que admite elementos duplicados y nulos, así como acceso por índice y otros métodos para trabajar con sus elementos. Vector también hereda de List es muy similar a ArrayList, con la diferencia de que la clase Vector es segura para trabajar con hilos (sincronizada). Esta ventaja penaliza ligeramente el rendimiento del Vector.

Antes de mostrar un ejemplo, añadir que a partir de la versión 1.6 1.5 de Java, si no me equivoco (me equivoqué :P), se introdujeron las colecciones genéricas, que suponen una ventaja en cuanto a que soportan comprobación de tipos en tiempo de compilación. Para definir el tipo de la colección simplemente se añade el tipo del objeto entre los símbolos '<' y '>' (ej.: Vector<String>).

A continuación, un sencillo ejemplo de uso de estas clases.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;
 
public class Test1 {
 
    public static void main(String[] args) {
 
        String[] arrayString = new String[]{"1", "2", "3", "4"};
        for (int i = 0; i < arrayString.length; i++) {
            System.out.println(arrayString[i]);
        }
 
        ArrayList<String> arrayList = new ArrayList<String>(arrayString.length);
        for (int i = 0; i < arrayString.length; i++) {
            arrayList.add(arrayString[i]);
        }
 
        Iterator it = arrayList.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
 
        Vector<String> vector = new Vector<String>(arrayString.length);
        for (int i = 0; i < arrayString.length; i++) {
            vector.add(arrayString[i]);
        }
 
        it = vector.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

Para comenzar, simplemente comentar que esta clase es muy útil para presentar números por pantalla, teniendo el control en todo momento del formato que tendrán. Más adelante dedicaremos otro post a DecimalFormat, que hereda de esta primera.

NumberFormat es la clase más sencilla de las dos. Principalmente presenta los siguientes métodos:

• getInstance() - Simplemente obtiene el formato del idioma actual.
• getCurrencyInstance() - Igual que el anterior, pero con formato de moneda.

y sus respectivas variantes con un parámetro de tipo Locale, que sustituirá al idioma actual.

Para realizar el formato será necesario llamar al método format, como veréis en el ejemplo.

Esta clase supone un componente muy flexible a la hora de formatear números. Como siempre, me apoyaré en la documentación de Java para la explicación, dado que es nuestro más preciado recurso ;-).

import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
 
public class PruebaFormatos {
 
	public static void main(String[] args) {
 
		/*
		 * Inicializamos con el método getInstance(), el más sencillo.
		 * Simplemente convierte los números al formato del locale por defecto
		 * (español, en mi caso).
		 */
		NumberFormat nf = NumberFormat.getInstance();
		System.out.println(nf.format(76543210.1234));
		// Resultado: 76.543.210
 
		// Ahora con un locale distinto
		nf = NumberFormat.getInstance(Locale.ENGLISH);
		System.out.println(nf.format(76543210.1234));
		// Resultado: 76,543,210
 
		/*
		 * Método getIntegerInstance, sirve para redondear números decimales.
		 * Ojo, redondear, ¡no truncar!
		 */
		nf = NumberFormat.getIntegerInstance();
		System.out.println(nf.format(123456.789));
		// Resultado: 123.457
 
		// Ahora, en Francés
		nf = NumberFormat.getIntegerInstance(Locale.FRENCH);
		System.out.println(nf.format(123456.789));
		// Resultado: 123 457
 
		/* Os voy a enseñar el cómo se muestra el dinero que tengo en el banco: */
		nf = NumberFormat.getCurrencyInstance();
		System.out.println(nf.format(12345678));
		// Resultado: 12.345.678,00 € (más quisiera yo...)
 
		// Ahora en dólares:
		nf = NumberFormat.getCurrencyInstance(Locale.US);
		System.out.println(nf.format(12345678 * 1.5023));
		// Resultado: $18,546,912.06
 
		/*
		 * Por último, vamos a parsear un número entero. En este caso no aplica
		 * ningún formato.
		 */
		try {
			nf = NumberFormat.getInstance();
			System.out.println(nf.parseObject("76543210 Euros"));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Desde Sun Microsystems han lanzado un concurso para promocionar su producto JavaFX, del que ya hemos tratado en el blog. La iniciativa consiste en animar a los bloggers a utilizar JavaFX y compartir su experiencia con sus lectores. Todos los bloggers que participen en el concurso optarán a los siguientes premios:

• 10 premios de 500 dólares para los 10 mejores posts.
• 50 premios de 25 dólares para Amazon.

El plazo del concurso finaliza el día 3 de Julio, así que ya sabes, ¡participa!.

Continuando con la entrada anterior de manejo de cadenas, voy a analizar los métodos siguientes:

• replace(CharSequence, CharSequence)
• replaceFirst(String, String)
• replaceAll(String, String)

Antes de nada, cabe explicar que un CharSequence es una interfaz que encapsula una secuencia de caracteres de sólo lectura y acceso uniforme. La clase String implementa dicha interfaz, al igual que las clases CharBuffer, Segment, StringBuffer y StringBuilder. Para usar el método replace lo más sencillo será utilizar un String normal.

Hoy os voy a dejar otro de los "imprescindibles" del programador Java, un manual de J2ME escrito por Sergio Gálvez Rojas y Lucas Ortega Díaz. En él se recogen los principios de la programación para móviles, y concretamente en la plataforma Java, presente en la mayoría de los móviles actuales (por no decir en todos).

En su web podemos encontrar enlaces a varias versiones del libro, además de la copia disponible en Google Books.

• Página de descarga en el sitio del autor.

JavaFX es un nuevo lenguaje de Scripts diseñado por Sun Microsystems. El objetivo de este nuevo lenguaje, (mezcla de C y Java, según mi opinión) es ocupar el lugar que ya tiene Flash en el mercado de las RIAs (Rich Internet Applications) y además adaptarse a los nuevos dispositivos móviles, gracias a su versión JavaFX mobile. Ya se dio la noticia del lanzamiento en Java-Spain, pero ahora quería profundizar un poco en su tecnología y los primeros pasos que debemos dar para empezar a conocerlo.

Lo primero de todo es descargar el JavaFX SDK. Yo voy a optar por instalar un plugin para Eclipse, pero en la misma página de descargas tenéis una versión para NetBeans. Si, como es mi caso, vais a instalarlo en Eclipse, será necesario descargar sólo el SDK desde la página de descargas de JavaFX y a continuación abrir Eclipse.

Una vez que tenemos Eclipse abierto, sólo tenemos que utilizar la herramienta de actualizaciones e introducir el siguiente sitio:

http://download.java.net/general/javafx/eclipse/{Sistema Operativo}/site.xml

Sistema Operativo ⇒ windows | linux | macosx

pulsar en instalar y listo. Ahora queda lo más divertido, aprender a programar con JavaFX.

Lo podéis ver en vídeo: