Linea de Codigo

Si aprendiste a leer un fichero con un enconding ISO Latin 1, ahora vamos a ver cómo podemos escribir un fichero ISO Latin 1 con Java.

El punto en el que hay que especificar el encoding es con la clase OutputStreamWriter. Y es que la clase OutputStreamWriter recibe el fichero al que queremos escribir y el encoding con el que escribimos.

OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1")

Como vemos el fichero al que escribimos lo instanciamos mediante FileOutputStream. Y el encoding utilizado para escribir un fichero ISO Latin 1 es "8859_1".

Solo nos quedará apoyarnos en un Buffer, en concreto en un BufferedWriter para enviar el texto al fichero.

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1"));

Una vez que hemos abierto el BufferedWriter, empezamos a ejecutar sentencias de escritura mediante el método .write().

out.write("Esto es un fichero ISO Latin 1");

Por último tenemos que cerrar el stream sobre el fichero. Para esto nos apoyamos en el método .close().

out.close();

Si vemos el código completo veremos que hay que controlar las excepciones UnsupportedEncodingException e IOException.

try {
  BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("FicheroSalidaISO1.txt"), "8859_1"));
  out.write("Esto es un fichero ISO Latin 1");
  out.close();
} catch (UnsupportedEncodingException e) {
  e.printStackTrace();
} catch (IOException e) {
  e.printStackTrace();
}

Con pocas líneas hemos escrito un fichero ISO Latin 1.

jQuery nos permite manejar de forma muy sencilla los formularios con un amplio conjunto de métodos. En este caso vamos a ver cómo podemos acceder a la lista de opciones seleccionadas de un combo y mostrarlas por pantalla utilizando la librería jQuery.

En primer lugar vamos a pintar el combo (esta vez va de fútbol):

 
<form id="myform">
<select id="equipos" multiple="multiple">
<option value="barça" selected="selected">Barça</option>
<option value="real madrid">Real Madrid</option>
<option value="atletico madrid">Atl&eacute;tico Madrid</option>
<option value="valencia">Valencia CF</option>
<option value="betis" selected="selected">Real Betis</option>
<option value="deportivo">Deportivo de la Coruña</option>
</select>
</form>
 

Si queremos que puedan existir varias opciones seleccionadas dentro del combo deberemos de utilizar el atributo multiple="multiple" dentro del select. De igual manera, si queremos prefijar una de las opciones deberemos de utilizar el atributo selected="selected".

Listaremos las opciones seleccionadas del combo cada vez que haya un cambio en dicho combo. Para ello vamos a manejar el método .change() de jQuery. En cada cambio ejecutaremos la función que le digamos al método .change().

$(document).ready(function(){
  $("#equipos").change(function(){
    ...
  });
});

Y ¿qué va a hacer nuestra función? Pues recorrer el elemento select. Pero no todo el elemento select, si no aquellas opciones que estén seleccionadas. Así que vamos a utilizar un selector. El selector será:

#equipos option:selected

Es decir, del combo o select 'equipos' elige aquellas opciones, u option, que estén seleccionadas, es decir 'selected'.

Ahora, de cada opción obtendremos su valor mediante el método .text()

$("#equipos option:selected").each(function() {
  texto += $(this).text() + " - ";
});

Ya solo nos quedará volcar el contenido en alguna capa de nuestra página. Para ello creamos un elemento DIV al que llamaremos 'resultado' y al que volcaremos los datos mediante:

$("#resultado").text(texto);

Solo nos queda un pequeño detalle. Y es que si hemos puesto campos seleccionados de antemano, si queremos que se ejecute nuestro método .change(), podemos simular el ejecutarlo mediante el método .trigger()

$("#equipos").trigger('change');

De esta manera tendremos la primera ejecución del .change(). El código entero nos quedará de la siguiente forma:

$(document).ready(function(){
  $("#equipos").change(function(){
 
    var texto = "Opciones Seleccionadas: ";
    $("#equipos option:selected").each(function() {
      texto += $(this).text() + " - ";
    });
 
    $("#resultado").text(texto);
 
  }).trigger('change');
});

Si el otro día vimos como seleccionar el texto de un campo (por defecto o mediante un click del usuario), hoy vamos a ver como seleccionar texto al posicionarse en un campo con jQuery. Es decir, al ir moviéndonos por los campos y llegar al determinado campo seleccionaremos el texto.

Controlar el posicionarse en un campo lo podremos hacer mediante el método .focus() de jQuery. Pero lo primero, el formulario. Como siempre, algo simple:

 
<form id="miform">
	<label for="texto">Inserta texto:</label>
<input id="texto" type="text" value="Texto por defecto" size="100"/><br/>
	<label for="texto2">Inserta texto:</label>
<input id="texto2" type="text" value="Texto por defecto 2" size="100"/><br/>
</form>
 

Como la selección del texto al posicionarse en un campo lo vamos a aplicar a todos los campos input (de tipo text) vamos a utilizar un selector.

input[type=text]

Así que el método .focus() se quedará de la siguiente forma:

$("input[type=text]").focus(function(){ ... });

Ya solo nos quedará realizar la selección del campo de texto mediante el método .select() de jQuery.

$("input[type=text]").focus(function(){
  this.select();
});

Cuándo accedemos a un fichero tenemos que tener cuidado en su codificación. Como ya vimos al leer un fichero en ISO Latin 1. En este caso vamos a leer un fichero UTF-8.

Hay que tener especial cuidado con la codificación del fichero ya que dependiendo del encoding hay carácteres que se representan de diferente forma, o simplemente que no se representan.

Los pasos para leer el fichero UTF-8 son muy sencillos. Ya que la lectura se hace sobre un BufferedReader, al cual hay que darle un InputStreamReader de entrada.

BufferedReader in = new BufferedReader(new InputStreamReader());

Y será sobre el InputStreamReader donde indiquemos el encoding del fichero. En nuestro caso al ser uft-8 deberemos de utilizar el charset "uft-8". Quedándonos la siguiente línea de código:

BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("FicheroUTF8.txt"), "utf-8"));

Cabe notar que el origen de lectura, es decir, el fichero, lo indicaremos con un FileInputStream.

Ya solo nos quedará recorrer el fichero mediante un bucle:

String sCadena;
while ((sCadena = in.readLine())!=null) {
  System.out.println(sCadena);
} 

Al trabajar con los encoding hay que tener especial cuidado de controlar la excepción UnsupportedEncodingException para aquellos encodings no soportados. Y al acceder a ficheros la típica excepción IOException.

Seleccionar el texto de un campo nos posibilita guiar al usuario de nuestra web en la edición de textos. La idea es dejarle un campo marcado dentro del formulario. Para ello nos vamos a apoyar en jQuery.

Lo primero es poner el formulario. Nada complicado si sabes HTML:

 
<form id="miform">
	<label for="texto">Inserta texto:</label>
<input id="texto" type="text" value="Texto por defecto" size="100"/><br/>
	<textarea id="areatexto">Texto por defecto</textarea><br/>
	<button id="selectall">Seleccionar todo el texto</button>
</form>
 

Ahora, y tras haber cargado nuestra librería jQuery...

<script type="text/javascript" src="jquery.js"></script>

... nos apoyamos en el método .select() para aplicarselo a un campo. Por ejemplo si queremos seleccionar el texto del campo con id 'texto' tendremos que codificar lo siguiente:

$("#texto").select();

Otra opción es hacerlo bajo demanda. Lo que viene a ser el típico botón de "Seleccionar Todo". Que en nuestro caso hemos representado con un elemento button.

En jQuery conseguiremos capturar el click sobre el botón con el método .click(). Así el código quedará de la siguiente forma:

$("#selectall").click( function(){
  $("#areatexto").select();
  return false;
});

Hay que tener en cuenta dos cosas. Que para acceder a los id de los elementos utilizamos una almohadilla delante del nombre. Y que al final del .click() hemos utilizado un return false para parar el evento generado por el botón.

Ya hemos visto dos formas muy sencillas de seleccionar el texto de un campo. ¿Se te ocurre otra forma?

Cuando ponemos campos de entrada en nuestras páginas web, el usuario podrá seleccionar parte del texto que haya en dichos campos. Vamos a ver como detectar el texto seleccionado utilizando jQuery.

Lo primero será poner un textarea con un texto de ejemplo:

 
<form id="miform">
  <textarea id="texto" rows="20" cols="100">Lorem ipsum dolor sit amet...</textarea>
</form>
 

Para utilizar jQuery tendremos que cargar la librería de jQuery:

<script type="text/javascript" src="jquery.js"></script>

El método de jQuery que nos ayudará a detectar el texto seleccionado es .select(). Este método habrá que asignarlo al elemento de la página sobre el que queremos detectar el texto seleccionado. En nuestro código el textarea 'texto'.

$("#texto").select(function(){	... });

El contenido que ha sido seleccionado se puede recuperar mediante el método .getSelection() de Javascript. Así que solo tendremos que ejecutar este método y volcarlo sobre la pantalla.

$("#texto").select(function(){
  selectedText = document.getSelection();
  $("#resultado").html("Se ha seleccionado el texto " + selectedText);
});

Para volcarlo en pantalla utilizamos el método .html() sobre una capa.

En este ejemplo vamos a ver como podemos listar todo el contenido del ordenador, es decir, ver todos los ficheros de las diferentes unidades de nuestro sistema (disco duro, tartejas SD, DVD,...).

Para poder listar el contenido del ordenador solo tenemos que aplicar lo explicado en los artículos listar un directorio de forma recursiva en Java y unidades del sistema de ficheros con java.

Y es que en el fondo, las unidades del sistema son directorios en si mismo que podemos recorrer. Así tenemos que recorrer las unidades del sistema, recordemos que para obtener las unidades utilizamos el método .listRoots() de la clase File.

File[] roots = File.listRoots();
for (int i=0; i<roots.length; i++) {
  System.out.println("--- LISTANDO UNIDAD " + roots[i] + " ---");
  listarDirectorio(roots[i],"");
}

Por cada unidad del sistema llamaremos al método recursivo listarDirectorio(), el cual, como vimos en listar un directorio de forma recursiva en Java, nos va mostrando los ficheros que contiene cada directorio y si el fichero es un directorio en sí mismo, se vuelve a llamar de forma recursiva.

Veamos su código:

public static void listarDirectorio(File f, String separador){
  File[] ficheros = f.listFiles();
  if (ficheros!=null){
    for (int x=0;x<ficheros.length;x++){
      System.out.println(separador + ficheros[x].getName());
 
      if (ficheros[x].isDirectory()){
        String nuevo_separador;
        nuevo_separador = separador + " ";
        listarDirectorio(ficheros[x],nuevo_separador);
      }
    }
  }
}

Hay que tener cuenta que ciertos sistemas de archivos dan problema al obtener el listado de ficheros, es por ello que comprobamos si el objeto ficheros tiene contenido.

El lenguaje Java nos da la capacidad de acceder a ficheros que tengan diferentes codificaciones. Posiblemente, muchos de nuestros ficheros vengan codificados en ISO Latin 1, o lo que es lo mismo ISO-8859-1, Latin Alphabet No. 1.

Al existir diferentes codificaciones para el contenido, Java nos permite indicar el tipo de contenido al que accedemos, para poderlo leer los ficheros de la forma correcta.

Pero vamos por partes, lo primero que haremos será abrir el fichero. Para ello y como vimos en el artículo leer un fichero de texto con Java, necesitaremos de un BufferedReader.

BufferedReader in = new BufferedReader();

Al BufferedReader tendremos que proveerlo de un stream de entrada, o lo que es lo mismo un InputStreamReader.

BufferedReader in = new BufferedReader(new InputStreamReader());

El InputStreamReader será la clave, ya al InputStreamReader podemos indicarle un charset de entrada. Es decir, el tipo de codificación que queremos.

En este caso, si queremos leer un fichero en ISO Latin 1 deberemos de utilizar el charset "8859_1". Pero al InputStreamReader le falta el origen, el nombre del fichero. Es decir, será de la siguiente forma:

 new InputStreamReader(new FileInputStream("FicheroISO1.txt"), "8859_1")

Asegúrate que el fichero tiene un encoding ISO-8859-1, Latin Alphabet No. 1.

El código de la instanciación incial quedaría de la siguiente forma:

BufferedReader in = new BufferedReader(
   new InputStreamReader(new FileInputStream("FicheroISO1.txt"), "8859_1"));

Ahora solo nos quedará leer el contenido del fichero, como hacíamos en leer un fichero de texto con Java.

String sCadena;
while ((sCadena = in.readLine())!=null) {
  System.out.println(sCadena);
} 

Puedes echar un vistazo a los encodings soportados en Java 7.

Las unidades del sistema de fichero son las diferentes particiones que tenemos de un disco, así como cualquier otro dispositivo o unidad de almacenamiento que tengamos conectado a nuestro ordenador. Ya sean lectores de DVD, tarjetas SD,...

Mediante el lenguaje Java y la librería Java IO podemos acceder al listado de las unidades del sistema de ficheros. Para ello nos apoyaremos en el método .listRoots() de la clase File. Hay que señalar que este método es un método estático de la clase File. Así que solo tendremos que invocarlo directamente.

File[] roots = File.listRoots();

El método .listRoots() nos devuelve un array de File. Así que solo tendremos que recorrerlo para ver cual es el listado de las unidades del sistema de ficheros.

for (int i=0; i<roots.length; i++) {
  System.out.println(roots[i]);
}

Vemos que con pocas líneas de código y la librería Java IO podemos sacar el listado de unidades del sistema. A partir de ahí, lo que nuestra imaginación nos proponga.

El directorio de trabajo de Java es el directorio dónde se está ejecutando el programa Java. Si queremos conocer cual es el directorio de trabajo del programa Java podemos utilizar las propiedades del sistema.

Para manejar las propiedades del sistema tenemos la clase System y en concreto el método .getProperty().

La propiedad del sistema que nos permite conocer el directorio de trabajo de Java es "user.dir". Así el código será el siguiente:

String sDirectorioTrabajo = System.getProperty("user.dir");
System.out.println("El directorio de trabajo es " + sDirectorioTrabajo);

¿Qué otras propiedades del sistema conoces y crees que puedes ser útiles?