El paquete java.sql consiste en ejecutar sentencias SQL de tipo consulta, aunque también permite leer y escribir datos  mediante operaciones de modificación realizando su conexión des de cualquier fuente de datos utilizando un formato tabular (en forma de tupla).

La URL del JDBC se construye mediante la plantilla siguiente:

 jdbc : subprotocolo : subnombre

3.-El último paso consiste en ejecutar la sentencia SQL y gestionar la tupla obtenida como resultado de su ejecución parametrizando la información según se requiera.

Por otro lado el paquete javax.sql,  proporciona una API en la capa del servidor para el acceso a la fuente de datos y procesado del lenguaje de programación Java. Incorpora los siguientes añadidos:

• La interfície de DataSource  como una alternativa al DriverManager para establecer la conexión con una fuente de datos.
• Pooling de conexiones y sentencias de SQL.
• Transacciones distribuidas.
• Conjuntos de filas.
• Aplicaciones para utilizar directamente las API’s DataSource y RowSet,  aunque las API’s del pooling de conexiones y de ls transacciones distribuidas se utilizan internamente por intermediarios.

1. El cierre de Connection cierra automáticamente todos los recursos.
2. El cierre del objeto ResultSet debe realizarse explícitamente siempre que no se utilice dado que si se deja automáticamente sólo se cerrará cuándo sea analizado por el recolector de basura. Es una buena práctica siempre cerrarlo explícitamente.
3. Por último siempre cerrar cualquier recurso externo que sea capaz de mantener activa la conexión del SGBD.

try (Connection con = DriverManager.getConnection(url, username, password));
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(query);
{
 // Using resources
}catch(Exception ex) {
}

Sql y JDBC

La API del JDBC:

• No restringe las sentencias que se pueden utilizar en una BBDD.
• No controla que las sentencias enviadas a la BBDD estén correctamente formuladas.
• Suministra tres clases y tres métodos respectivamente para el envío de sentencias SQL:

• Statement: Utiliza el método de createStatement y incluye los métodos de executeQuery (para consultas) y executeUpdate(para operaciones de modificación).

• PreparedStatement: Se utiliza para enviar consultas SQL que tengan uno o más parámetros como argumentos de entrada. Cuenta con métodos propios que nos ayudan a dar valor a estos parámetros.   Se muestra el siguiente código fuente como ejemplo:

PreparedStatement ps = con.prepareStatement(
 "select * from OWNER where ID=? AND NAME=? AND CODE=?");
ps.setInt(1,id-employee);
ps.setString(2,name);
ps.setInt(3,code);

• CallableStatement:  Se usan para ejecutar procedimientos almacenados SQL (Stored Procedures). Éstos son un grupo de sentencias SQL que son llamados mediante un nombre. Un objeto CallableStatement hereda de PreparedStatement los métodos para el manejo de parámetros y además añade métodos para el manejo de estos parámetros.  Se muestra el siguiente código fuente como ejemplo:

String createProcedure = "create procedure SHOW_SUPPLIERS "
 + "as "+"select SUPPLIERS.SUP_NAME, COFFEES.COF_NAME "
 + "from SUPPLIERS, COFFEES "
 + "where SUPPLIERS.SUP_ID=COFFEES.SUP_ID "
 + "order by SUP_NAME";
CallableStatement cs = con.prepareCall("{call SHOW_SUPPLIERS}");

Toda acción que se realice sobre la BBDD de datos abrir/cerrar conexión, ejecutar una sentencia SQL, etc pueden lanzar una excepción del tipo SQLException que se deberá capturar o propagar.

Este error puede resultar crítico para la integridad de los datos de la BBDD: la clase SQLException hereda de Iterable lo que permite recorrer dicha cadena de fallos. Así es posible recorrer todos los objetos de tipo Throwable que haya en una excepción SQLException.

Transacción

Mecanismo para manejar grupos de operaciones como si fueran una acción realizada de forma única.

Cada transacción debe tener las propiedades ACID:

Con JDBC se ejecuta un COMMIT automático  (autoCOMMIT) tras cada insert, update o delete (con excepción de si se trata de un procedimiento almacenado).

Para indicar que una sentencia SQL no se ejecuta de forma automática se utilizará el método setAutommit(boolean); de la interfaz Connection pasándole como parámetro el valor false.

De este modo se pueden agrupar varias sentencias SQL en una misma transacción siendo el programador el que gestiona el momento de realizar el COMMIT de la ejecución.

Api RowSet

Tipos de Excepciones

Excepciones comprobadas (checked).

Representan errores producidos durante la ejecución de un programa por condiciones inválidas en el flujo esperado. Estos errores pueden ser previsibles o esperables y por eso se puede definir un flujo alternativo para tratarlos. Es el caso, por ejemplo, de errores de conexión de red, errores en la localización de ficheros, conexión a base de datos, etc. En estos casos, se puede aplicar una política de re-intentos o bien informar al usuario del error de forma controlada si se trata de un entorno interactivo.

Los métodos están obligados a tratar de alguna manera las excepciones de este tipo producidas en su implementación, ya sea relanzándolas, apilándolas o tratándolas mediante un bloque try/catch.

Exception y subclases, excepto RuntimeException y subclases.

Excepciones no comprobadas (unchecked).

Representan errores producidos durante la ejecución de un programa de los que no se espera una posible recuperación o no se pueden tratar. Se incluyen entre estos casos errores aritméticos, cómo divisiones entre cero, excepciones en el tratamiento de punteros, cómo el acceso a referencias nulas (NullPointerException) u errores en el tratamiento de índices, cómo por ejemplo el acceso a un índice incorrecto de un array.

Este tipo de errores pueden ocurrir en cualquier lugar de la aplicación y no se requiere su especificación en la firma de los métodos correspondientes o su tratamiento a través de bloques try/catch (aunque es posible hacerlo) lo que facilita a la legibilidad del código.

RuntimeException, Error y subclases de éstas.

En concreto la excepción no comprobada Error representa errores producidos por condiciones anormales en la ejecución de una aplicación que nunca deberían darse. En su mayoría se trata de errores no recuperables y por esta razón, este tipo de excepciones no extienden de Exception y si de Throwable con el propósito que no sean capturadas accidentalmente por ningún bloque try/catch que pueda impedir la finalización de la ejecución. A nivel de compilación, estos se tratan de igual forma que las excepciones no comprobadas, por lo que no hay la obligación de declarar su lanzamiento en las firmas de los métodos.

Ejemplos:

Jerarquía de Excepciones

La jerarquía de las excepciones en Java 7 puede visualizarse en el siguiente esquema:

Fig. 1. Jerarquía de excepciones

La superclase de todas las excepciones es Throwable.

La clase Exception sirve como superclase para crear excepciones de propósito específico, es decir, adaptado a nuestras necesidades.

La clase Error está relacionada con errores de compilación, del sistema o de la JVM. Normalmente estos errores son irrecuperables.

RuntimeException (Excepciones Implícitas): Excepciones muy frecuentes relacionadas con errores de programación. Existen pocas posibilidades también de recuperar situaciones anómalas de este tipo.

Lanzamiento de Excepciones

//  Crear una excepcion
MyException me = new MyException("Myexception message");

//  Lanzamiento de la excepción
throw me;

import java.util.*;

public class ExTryCatch {
 public static void main(String[] args){
  
  int i=-3;
  
  try{
   String[] array = new String[i];
   System.out.println("Message1");
  }
  
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
  
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
  
  System.out.println("Message2");
  
 }
}

import java.util.*;

public class ExFinally {
 public static void main(String[] args){
  
  int i=5;
  
  try{
   String[] array = new String[i];
  }
  
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
  
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
  
  finally{
   System.out.println("This always executes");
  }
  
  
 }
}

public enum Day {

    SUNDAY("Sunday"),
    MONDAY("Monday"),
    TUESDAY("Tuesday"),
    WEDNESDAY("Wednesday"),
    THURSDAY("Thursday"),
    FRIDAY("Friday"),
    SATURDAY("Saturday");

    private final String name;

    private Day(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }   
}

Cuándo hay campos, métodos o constructores, la lista de constantes de la enumeración debe terminar con un punto y coma.

Las enumeraciones pueden implementar interfaces pero no pueden extender otras enumeraciones. Una posible utilidad de esto es «esconder» la enumeración referenciando a la interfaz:

public enum Day implements IDayOfWeek
{
             SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
             SATURDAY;
}

...

IDayOfWeek dow = Day.SUNDAY;

Las variables miembro de una clase se declaran siempre dentro de una clase pero de forma externa al constructor de la clase. Java es un lenguaje fuertemente tipado y esto obliga a que las variables deban inicializarse antes de ser utilizadas. En Java todos los parámetros son pasados por valor.

Constructores

Sentencias de control de flujo

Pueden encontrarse las sentencias for, if…else, do…while, while.

La sentencia switch

Fig. 3 Implementación de Switch en Java 7

evalúa el valor de una variable de tipo int, char o String.  Permite una acción u otra según el resultado de una comparación o un valor lógico. Permite también agrupar un mismo resultado para varios case.

Paso por valor

Encapsulación

En general se llaman métodos asignadores y recuperadores a los métodos que disponen de los valores encapsulados dentro de una clase.

Herencia

Consiste en un mecanismo de relación entre clases. Aunque cada clase sólo tiene una SUPERCLASE,  existe una clase que se encuentra en la parte superior de la estructura de herencia.

Es la clase Object, clase de la que derivan TODAS las clases Java y a la que TODOS sus hijos pueden acceder a sus variables miembro y métodos miembro.

La herencia se implementa mediante la palabra clave:

Polimorfismo

Sobrecarga de métodos (overloading)

Dentro de una misma clase es posible agrupar varias sobrecargas en Java para disponer de un sólo método pero que puede recibir distintas cargas o parámetros.

El mecanismo que permite la sobrecarga se llama varargs (o argumentos variables) y permite escribir un método más génerico del tipo siguiente

A nivel de JVM, el compilador siempre prefiere utilizar un método que contenga tipos de parámetros a los cuáles podamos convertir los tipos de argumentos utilizados en la llamada que utilizar un método que acepte argumentos variables.

Por ejemplo, la internacionalización puede permitir utilizar distintos formatos de fecha, y la localización consiste en escoger el adecuado para una región específica.

Puede encontrase información adicional en los siguientes enlaces: aquí y aquí.

• Permite que se adapte un software para una región o idioma específicos añadiendo componentes específicos locales y texto traducido a la región o idioma.

• La mayor parte de la tarea consiste en la traducción del idioma pero existen también otras tareas como formatos de fechas, cambio de moneda,  tipo de calendario, y cualquier otro elemento distintivo de la región.

Ejemplos prácticos de localización: Establecer el idioma al inglés, salir de la aplicación, etc…

Ejemplo clave-valor:

my.hello=Hello

my.goodbye=Bye

Para un fichero de properties:    Message_Bundle_<language>_<country>.properties

Para una clase:   Message_Bundle_<language>_<country>.java

Ejemplo de los ficheros de properties:

MessageBundle_en_EN.properties

my.hello=Hello
my.goodbye=Bye
my.question=Do you speak English?

my.hello=Hola
my.goodbye=Adios
my.question=u00bfHablas inglu00e9s?

my.hello=Hejsan
my.goodbye=Hejd?
my.question=Pratar du engelska?

Ejemplo de implementación mediante clases

En el ejemplo que se muestra a continuación se implementan 3 clases correspondientes a los mismos casos de uso que en el ejemplo de los ficheros properties. 

Los puntos importantes a resaltar son:

• Las clases implementadas deben extender de la clase ResourceBundle
• En el nombre de la clase se debe incluir el identificador del ResourceBundle así como el idioma y el código de país.
• Se deben implementar el método handleGetObject para acceder a los mensajes a través de su clave
• También se debe implementar el método getKeys para poder acceder al índice de todas las claves que proporciona la implementación del ResourceBundle
• En los ejemplos, se ha utilizado un Map como backend de los textos internacionalizados, pero este mecanismo hace posible obtener los textos des de otros soportes, como por ejemplo base de datos. Para ello sólo se tendría que modificar el método populateData para que obtuviera los datos a través de una conexión jdbc. Este método no forma parte de la API de la clase ResourceBundle y sólo sirve a afectos de mostrar un posible mecanismo para indicarle a la implementación realizada la lista de mensajes que se soporta.

MessageBundle_en_EN.java

public class MessageBundle_en_EN extends ResourceBundle 
{
 HashMap data; 
   
   
 public MessageBundle_en_EN()
 {
  data = new HashMap(); 
  populateData();
 }
 
 protected void populateData()
 {
  data.put("my.hello", "Hello");                               
  data.put("my.goodbye", "Bye");                               
  data.put("my.question", "Do you speak English?");        
 }
 
 @Override
 protected Object handleGetObject(String key) 
 {
  return data.get(key);
 }

 @Override
 public Enumeration getKeys() 
 {
  return Collections.enumeration(data.keySet());
 }
}

MessageBundle_es_ES.java

public class MessageBundle_es_ES extends ResourceBundle 
{
 HashMap data; 
   
   
 public MessageBundle_es_ES()
 {
  data = new HashMap(); 
  populateData();
 }
 
 protected void populateData()
 {
  data.put("my.hello", "Hola");                                
  data.put("my.goodbye", "Adios");                             
  data.put("my.question", "¿Hablas inglés?");                    
 }
 
 @Override
 protected Object handleGetObject(String key) 
 {
  return data.get(key);
 }

 @Override
 public Enumeration getKeys() 
 {
  return Collections.enumeration(data.keySet());
 }
}

MessageBundle_sv_SE.properties

public class MessageBundle_sv_SE extends ResourceBundle 
{
 HashMap data; 
   
   
 public MessageBundle_sv_SE()
 {
  data = new HashMap(); 
  populateData();
 }
 
 protected void populateData()
 {
  data.put("my.hello", "Hejsan");                              
  data.put("my.goodbye", "Hejd?");                             
  data.put("my.question", "Pratar du engelska?");       
 }
 
 @Override
 protected Object handleGetObject(String key) 
 {
  return data.get(key);
 }

 @Override
 public Enumeration getKeys() 
 {
  return Collections.enumeration(data.keySet());
 }
}

Declaraciones de las variables para estos formatos:

NumberFormat currency;

Double money = new Double(1000000.00);

Date date = new Date();

DateFormat dtf;   

A continuación se detalla un caso de ejemplo de localización que muestra mensajes de texto en distintos idiomas (español, inglés y sueco) .

La clase se llama TestLocaleI18N y su implementación es la siguiente:

package i18n; 
 
import java.util.Locale;
import java.util.ResourceBundle;
 
public class TestLocaleI18N { 
 
 /*  
 La carga del ResourceBundle puede hacerse des de fichero, des del contexto de una aplicación,  
 des del propio entorno en el que se esté ejecutando esta clase Java. 
  
 En este caso de ejemplo se utiliza el acceso al fichero properties ubicado dentro  
 del mismo paquete que la clase principal.  
 En un futuro, se realizaran pruebas con el resto de mecanismos de acceso.    
 */ 
 public static void main(String[] args) throws Exception {
 
  ResourceBundle bundle1 = ResourceBundle.getBundle("i18n.TestResourceBundle");
  visualizar(bundle1, null);
 
  Locale deLocale = Locale.getDefault();
  ResourceBundle bundle2 = ResourceBundle.getBundle("i18n.TestResourceBundle", deLocale);
  visualizar(bundle2, deLocale);
 
  Locale svLocale = new Locale("sv", "SE");
  ResourceBundle svBundle = ResourceBundle.getBundle("i18n.TestResourceBundle", svLocale);
  visualizar(svBundle, svLocale);
 
  Locale spLocale = new Locale("es", "ES");
  ResourceBundle spBundle = ResourceBundle.getBundle("i18n.TestResourceBundle", spLocale);
  visualizar(spBundle, spLocale);
   
  Locale enLocale = new Locale("en", "US");
  ResourceBundle enBundle = ResourceBundle.getBundle("i18n.TestResourceBundle", enLocale);
  visualizar(enBundle, enLocale);
   
 } 
 
 public static void visualizar(ResourceBundle bundle, Locale lo) {
  if(lo == null) { lo = Locale.getDefault();}
  System.out.println("Idioma: "+lo.getLanguage()); 
  System.out.println(".........................................................");
  System.out.println("Contenido Mensaje -->hello: " +" "+ bundle.getString("my.hello"));
  System.out.println("Contenido Mensaje -->goodbye: " +" "+ bundle.getString("my.goodbye"));
  System.out.println("Contenido Mensaje -->question: " +" "+ bundle.getString("my.question"));
  System.out.println("=========================================================");
 } 
}

En este apartado se exponen los conceptos básicos referentes del diseño de programas concurrentes y paralelos y los mecanismos que la especificación estándar de Java pone a disposición del programador para conseguirlo.

• Cómo el sistema operativo gestiona los procesos e hilos.
• Ciclo de vida de un hilo de ejecución.
• Sincronización y comunicación de datos entre hilos de ejecución.

Gestión de procesos e hilos

La Multitarea se describe cómo la habilidad de ejecutar varias tareas aparentemente al mismo tiempo compartiendo uno o varios procesadores. 

Existen dos tipos de tareas:

• Procesos: Conjunto de instrucciones de código que se ejecutan secuencialmente y que tiene asociados un estado y recursos de sistema (espacio de memoria, punteros a disco, recursos de red…).
• Hilos de ejecución: También llamado proceso ligero, es un flujo de ejecución secuencial dentro de un proceso. En un proceso se pueden estar ejecutando uno o más hilos de ejecución a la vez. Los hilos permiten evitar «los cuellos de botella» en el rendimiento del sistema. Su origen puede venir determinado por varias razones: bloqueo de operaciones de E/S, bajo uso de CPU o debido al recurso contencioso, consistente en que dos o más tareas queden a la espera del uso exclusivo de un recurso.

 

El planificador es el componente de los sistemas multitarea y multiproceso encargado de repartir el tiempo de ejecución de un procesador entre los diferentes procesos que estén disponibles para su ejecución.

En los sistemas operativos de propósito general, existen tres tipos de planificadores:

• Planificador a corto plazo: Planificador encargado de repartir el tiempo de proceso entre los procesos que se encuentran en memoria principal en un momento determinado.
• Planificador a mediano plazo. Relacionado con aquellos procesos que no se encuentran en memoria principal. Se encarga de mover procesos entre memoria principal y la memoria de Swap (Disco).
• Planificador a largo plazo:Planificador encargado del ciclo de vida de los procesos, desde que son creados en el sistema hasta su finalización.

 

Existen diferentes políticas de planificación con multitud de variaciones y especializaciones que permiten ser utilizadas para diferentes propósitos. En el apartado de referencias se encuentran enlaces a las explicaciones de algunas de ellas.

Paralelismo

Se definen como procesos paralelos aquellos que se ejecutan en el mismo instante de tiempo, debido a esto, este tipo de computación sólo es posible en sistema multiprocesador.

Concurrencia

Se definen como procesos concurrentes aquellos que se ejecutan en un mismo intervalo de tiempo pero no necesariamente de forma simultánea. A diferencia del paralelismo, este tipo de computación se puede realizar en sistema monoprocesador alternando la ejecución de las 2 tareas. En la siguiente imagen se puede observar esta diferencia.

Existe un método en java que permite obtener el número de procesadores disponibles en un sistema:

1	int countProcessors = Runtime.getRuntime().availableProcessors();

Ciclo de vida de un hilo de ejecución

El ciclo de vida de un hilo de ejecución representa los estados por los que este pasa desde que es creado hasta que completa su tarea o finaliza su por otra razón, cómo por ejemplo porque se produce un error que lo interrumpe.

Se pueden enumerar los siguientes estados:

• Nuevo (new): En el momento en que se crea un nuevo Thread, este se sitúa en estado nuevo hasta que el programa inicia su ejecución. En este estado el hilo no se encuentra activo.
• Ejecutable (runnable): En el momento en que se inicia el hilo mediante el método start() se considera que este se encuentra activo. En este momento el control de su ejecución pasa a ser del planificador que decidirá si se ejecuta inmediatamente o se mantiene a la espera en un pool hasta que decida ponerlo en ejecución.
• En ejecución (running): En el momento en que el planificador escoge un hilo del pool para ser ejecutado, este pasa a estar en ejecución. Una vez en este estado, el hilo puede volver al estado de espera (ejecutable) si el planificador decide que su tiempo asignado de CPU ha finalizado aunque no haya completado su tarea. En este supuesto, deberá esperar a que el planificador vuelva a escogerlo para devolverlo a ejecución. Otras causas por las que un hilo puede abandonar este estado son los bloqueos o esperas o por su finalización.
• Bloqueado/esperando (bloqued/waiting): Un hilo activo puede entrar en un estado de espera finito, por ejemplo durante operaciones de entrada/salida en las que debe esperar para obtener datos de un recurso. Cuando esta espera finaliza, el hilo vuelve al estado de ejecución. Este estado también se puede producir en caso de que el hilo de ejecución deba esperar a la realización de una tarea por parte de otro hilo. En este caso volverá al estado activo cuando el otro hilo envíe le una señal al hilo en espera para que siga su ejecución.
• Finalizado (dead): Un hilo activo entra en este estado cuando completa su tarea o finaliza por otra causa, como por ejemplo que se produzca un error o se le envíe una señal de finalización.

Problemas de concurrencia

Cuando 2 o más hilos se ejecutan al mismo tiempo y tienen que competir por los mismos recursos o colaborar para producir un resultado, es posible que se produzcan situaciones no deseadas que alteren este resultado o incluso produzcan problemas de rendimiento considerables en el sistema.

Entre los problemas más corrientes y conocidos se encuentran los siguientes:

• Condición de carrera (Race condition): Este problema se produce cuando 2 o más hilos de ejecución modifican un recurso compartido en un orden diferente al esperado, provocando un estado erróneo de este recurso. Por ejemplo, 2 hilos de ejecución leen es valor de una variable compartida, realizan un cálculo sobre este y actualizan de nuevo la variable con el resultado. Si no se sincroniza adecuadamente el acceso a dicha variable es posible que los hilos hayan realizado los cálculos en base a un valor obsoleto porque el otro hilo lo haya actualizado antes. En este caso, la solución pasa por disponer de mecanismos para sincronizar el acceso a los recursos compartidos de manera que la lectura y posterior actualización sean atómicas y no puedan producirse de forma concurrente.
• Bloqueo mutuo (Deadlock): Este problema se produce cuando 2 o más hilos de ejecución compiten por un recurso o se comunican entre ellos y no pueden acceder al recurso quedando indefinidamente a la espera de que sea liberado pero esto no se produce nunca. Un ejemplo clásico sería el de 2 hilos A y B que tienen asignados 2 recursos R1 y R2 respectivamente. Si A require R2 y B requiere R1 pero estos no son liberados por sus poseedores en ese momento, tanto A como B se encuentran bloqueados a la espera de poder acceder a los recursos. En este caso, la solución pasa por impedir situaciones en que un hilo de ejecución quede bloqueado esperando un recurso compartido sin liberar antes los que tiene él tiene ocupados.

Referencias

Políticas de planificación de tareas

• Round-Robin: https://es.wikipedia.org/wiki/Planificaci%C3%B3n_Round-robin
• FIFO: https://es.wikipedia.org/wiki/First_in,_first_out
• LIFO: https://es.wikipedia.org/wiki/Last_in,_first_out
• Shortest Job First: https://en.wikipedia.org/wiki/Shortest_job_next

 

public class Echo {
 public static void main(String[] args) {
  for (String s: args) {
   System.out.println(s);
  }
 }
}

La clase Echo puede recibir los siguientes parámetros por línea de consola de comandos.

java Echo Enero Febrero Marzo Abril

Pasándole como argumentos en la línea de comandos los cuatro primeros meses del año.

Cada uno de los meses separados por un salto de línea. Esto es así debido a que el carácter espacio se utiliza para separar los parámetros unos de otros mediante un salto de línea entre cada uno.

Si se quiere mostrar un frase o texto completo, por ejemplo

            java Echo «Enero, Febrero, Marzo, Abril son los cuatro primeros meses…»

se debe indicar la apertura y el cierre del texto mediante comillas dobles («»).

Debe tenerse en cuenta que los arrays SIEMPRE empiezan con el valor 0 nunca con el 1. Para recuperar los parámetros recibidos mediante el método main se utilizan los indices del vector. Así con el código args[0] se recupera el primer parámetro, con args[1] se recupera el segundo, etc.

Este snippet transforma un argumento de consola de comandos en un tipo entero:

int primerArg;
if (args.length > 0) {
    try {
        primerArg = Integer.parseInt(args[0]);

System.out.println("Se ha convertido la cadena "+args[0]+" en el número siguiente -> "+primerArg);
    } catch (NumberFormatException e) {
        System.err.println("Argumento " + args[0] + " debe ser un número entero.");
        System.exit(1);
    }
}

primerArg lanza una excepción del tipo NumberFormatException si el formato de args[0] no es valido. Todas las clases de tipo Number — Integer, Float, Double y demás — disponen de métodos de conversión que transforman un String representando un número en un objeto de su tipo específico.

Formatos de cadena

Los métodos de StringBuilder no son sincronizados por lo que su uso implica un mejor rendimiento cuándo se usan localmente.

En general, la concatenación de Strings ocurre con variables locales a un método por lo que es recomendable utilizar de forma general StringBuilder en lugar de StringBuffer.

public class StringBuilder_vs_StringBuffer {

    public static void main(String[] args) {
        StringBuffer sbuffer = new StringBuffer();
        long inicio = System.currentTimeMillis();

        for (int n = 0; n < 1000000; n++) {
            sbuffer.append("zim");
        }

        long fin = System.currentTimeMillis();
        System.out.println("Time using StringBuffer: " + (fin - inicio));

        StringBuilder sbuilder = new StringBuilder();

        inicio = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++) {
            sbuilder.append("zim");
        }

        fin = System.currentTimeMillis();
        System.out.println("Time using StringBuilder: " + (fin - inicio));


    }
}