Internacionalización de Programas Java

• Convertir Texto No-Unicode
• Bytes Codificados y Strings
• Streams de Caracteres y de Bytes

Convertir Texto No-Unicode

En el lenguaje de programación Java, los valores char representan caracteres Unicode. Unicode es una codificación de caracteres de 16 bits que soporta la mayoría de los idiomas del mundo. Podrás aprender más sobre el estándard Unicode en la web site de Unicode Consortium.

Pocos editores de texto soportan actualmente texto Unicode. El editor de texto que hemos utilizado para escribir los códigos de ejemplo de esta lección sólo soporta caracteres ASCII, que están limitados a 7 bits. Para indicar un caracter Unicode que no puede ser representado en ASCII, como "ö," hemos utilizado la secuencia de escape '\udddd'. Cada "d" en la secuencia de escape es un dígito hexadecimal. El siguiente ejemplo muestra cómo indicar el caracter "ö" con una secuencia de escape.

String str = "\u00F6";
char c = '\u00F6';
Character letter = new Character('\u00F6');

No tenemos que especificar al secuencia de escape Unicode para caracteres ASCII. Cuando se leen ficheros ASCII o ISO Latin-1, el entorno de ejecución de Java convierte automáticamente los caracteres a Unicode. Sin embargo, si se quiere convertir texto desde otras codificaciones a Unicode, debemos realizar las conversiones nosotros mismos.

En esta lección se explica el API que se utiliza para traducir texto no-Unicode a Unicode. Antes de utilizar estos APIs, deberíamos verificar que la codificación que queremos convertir está soportada. La lista de codificaciones soportadas no forma parte de la especificación del lenguaje de programación Java. Por lo tanto, podría variar con las plataformas. Para ver las codificaciones soportadas por el JDK, puedes ver la sección "Supported Encodings" en la documentación Internationalization Overview.

Las siguientes secciones describen dos técnicas para convertir texto no-Unicode.

 Bytes Codificados y Strings

Esta sección muestra cómo convertir arrays de bytes no-Unicode en objetos Strings, y vice-versa.

Si el texto no-Unicode está almacenado en un array de bytes, se pueden convertir a Unicode con uno de los métodos constructores de String. Inversamente, se puede convertir un objeto String en un array de bytes de caracters no-Unicode con el método String.getBytes. Cuando se llama a estos métodos se debe especificar el identificador de la codificacióm como uno de los parámetros.

En los siguientes ejemplos convertiremos caracteres entre UTF8 y Unicode. UTF8 es una forma binaria compacta para codificar caracteres Unicode de 16-bits en 8 bits. El código fuente de este ejemplo está en el fichero llamado StringConverter.java.

Primero creamos un String que contiene los caracteres Unicode.

String original = new String("A" + "\u00ea" + "\u00f1"
                                 + "\u00fc" + "C");

Cuando imprimimos el String llamado original aparecerá como.

AêñüC

Para convertir el objeto String a UTF8, llamamos al método getBytes y le especificamos el identificador de codificación apropiado como un parámetro. El método getBytes devuelve un array de bytes en formato UTF8. Para crear un objeto String desde un array de bytes no-Unicode, llamamos al constructor de String con el parámetro de la codificación, El código que hace estás llamadas está encerrado en un bloque try, para el caso de que la codificación especificada no estuviera soportada.

try {
   byte[] utf8Bytes = original.getBytes("UTF8");
   byte[] defaultBytes = original.getBytes();

   String roundTrip = new String(utf8Bytes, "UTF8");
   System.out.println("roundTrip = " + roundTrip);

   System.out.println();
   printBytes(utf8Bytes, "utf8Bytes");
   System.out.println();
   printBytes(defaultBytes, "defaultBytes");
   }
catch (UnsupportedEncodingException e) {
   e.printStackTrace();
}

Imprimimos los valores de los arrays utf8Bytes y defaultBytes para demostrar un punto importante. La longitud del texto convertido podría no ser la misma que la longitud del texto original. Algunos caracteres Unicode se traducen en bytes sencillos, y otros en parejas de bytes. Nuestra rutina para mostrar los arrays de bytes es esta.

public static void printBytes(byte[] array, String name) {
   for (int k = 0; k < array.length; k++) {
      System.out.println(name + "[" + k + "] = " + "0x" +
         UnicodeFormatter.byteToHex(array[k]));

   }
}

Aquí está la salida de los métodos printBytes. Observa que sólo el primer y último caracteres la "A" y la "C", son los mismos en los dos arrays.

utf8Bytes[0] = 0x41
utf8Bytes[1] = 0xc3
utf8Bytes[2] = 0xaa
utf8Bytes[3] = 0xc3
utf8Bytes[4] = 0xb1
utf8Bytes[5] = 0xc3
utf8Bytes[6] = 0xbc
utf8Bytes[7] = 0x43

defaultBytes[0] = 0x41
defaultBytes[1] = 0xea
defaultBytes[2] = 0xf1
defaultBytes[3] = 0xfc
defaultBytes[4] = 0x43

 Streams de Caracteres y de Bytes

En esta sección aprenderás como traducir entre streams de caracteres Unicode y streams de bytes con texto no-Unicode.

El paquete java.io proporciona clases que permiten conversiones entre streams de caracteres y streams de bytes de texto no-Unicode. Con la clase InputStreamReader, se pueden convertir streams de bytes a streams de caracteres. Se utiliza la clase OutputStreamWriter para traducir streams de caracteres a streams de bytes.

Cuando se crean objetos InputStreamReader y OutputStreamWriter, se debe especificar la codificación que se quiere convertir. Por ejemplo, si queremos traducir un fichero de texto en formato UTF8 a Unicode, deberíamos crear un InputStreamReader de la siguiente forma.

FileInputStream fis = new FileInputStream("output.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF8");

Si se omite el identificador de codificación, InputStreamReader y OutputStreamWriter utilizarán la codificación por defecto. Al igual que la lista de codificaciones soportadas, la codificación por defecto puede variar con la plataforma Java. En la versión 1.1 del JDK, la codificación por defecto es 8859_1 (ISO-Latin-1). Este valor se selecciona en la propiedad del sistema file.encoding. Puedes determinar la codificación que utilizará un InputStreamReader o un OutputStreamWriter llamando al método getEncoding. En el siguiente ejemplo, llamamos al método para determinar que la codificación por defecto de nuestra plataforma sea 8859_1.

InputStreamReader defaultReader = new InputStreamReader(fis);
System.out.println(defaultReader.getEncoding());

Se específica un InputStream cuando se crea un InputStreamReader, y un OutputStream cuando se construye un OutputStreamWriter. InputStream y OutputStream son superclases abstractas y todas sus entradas y salidas son streams de bytes, Esto pemite realizar conversiones de cualquiera de los streams de bytes que pertenezcan a sus subclases. Por ejemplo, con un InputStreamReader se puede convertir texto no-Unicode desde un FileInputStream o un PipedInputStream, porque ambas son subclases de InputStream.

En el siguiente ejemplo. veremos como realizar conversiones con las clases InputStreamReader y OutputStreamWriter. El código fuente de este ejemplo lo puedes encontrar en el fichero StreamConverter.java. En este ejemplo, convertimos una secuencia de caracteres Unicode desde un objeto String en un FileOutputStream de bytes codificado en UTF8. El método que realiza la conversión se llama writeOutput.

static void writeOutput(String str) {

    try {
       FileOutputStream fos = new FileOutputStream("output.txt");
       Writer out = new OutputStreamWriter(fos, "UTF8");
       out.write(str);
       out.close();
    } 
    catch (IOException e) {
       e.printStackTrace();
    }
}

En otro método, readInput, leemos los bytes codificados en UTF8 desde el fichero creado con el método writeOutput. Utilizamos un InputStreamReader para convertir los bytes de UTF8 a Unicode, y devolver el resultado en un String. Aquí puedes ver el método readInput.

static String readInput() {

   StringBuffer buffer = new StringBuffer();
   try {
      FileInputStream fis = new FileInputStream("output.txt");
      InputStreamReader isr = new InputStreamReader(fis, "UTF8");
      Reader in = new BufferedReader(isr);
      int ch;
      while ((ch = in.read()) > -1) {
         buffer.append((char)ch);
      }
      in.close();
      return buffer.toString();
   } 
   catch (IOException e) {
      e.printStackTrace();
      return null;
   }
}

En el método main de nuestro programa ejemplo, llamamos al método writeOutput para crear un fichero de bytes codificado en UTF. Luego leemos el mismo fichero, convirtiendo de nuevo los bytes a Unicode. Aquí puedes ver el código del método main.

public static void main(String[] args) {

   String jaString  = 
      new String("\u65e5\u672c\u8a9e\u6587\u5b57\u5217");

   writeOutput(jaString);
   String inputString = readInput();
   String displayString = jaString + " " + inputString;
   new ShowString(displayString, "Conversion Demo");
}

La cadena original (jaString) debería ser idéntica a la recien creada (inputString). Para ver si las dos cadenas son iguales, las concatenamos y las mostramos con un objeto ShowString. La clase ShowString muestra un string con el método Graphics.drawString. El código fuente de esta clases está en el fichero ShowString.java. Cuando ejemplarizamos un ShowString en nuestro programa ejemplo, aparecen las siguientes ventanas. La repetición de los caracteres mostrados verifica que las dos cadenas son idénticas.