Linea de Codigo

Estaba haciendo unas pruebas con ficheros y no había caído en que el directorio con el que estaba trabajando tenía algunos ficheros ocultos que no estaba moviendo.cY me he dicho, porqué no escribir unas pequeñas líneas de código con Java para listar los ficheros ocultos de un directorio. Y es que el programa es muy sencillo.

Te recomiendo que empieces echando un ojo al artículo que explica como listar los ficheros de un directorio con Java. Ya que la base del listado de ficheros está en ese ejemplo.

Lo siguiente será saber que el método que nos dice si un fichero es oculto o no es .isHidden(). Algo que, por otro lado, cabía esperar. Así que listemos los ficheros del directorio.

String sDirectorio = "d:\\test";
File f = new File(sDirectorio);
 
if (f.exists()){
	File[] ficheros = f.listFiles();
	for (int x=0;x<ficheros.length;x++){
		System.out.println(ficheros[x].getName());
	}
} else{
	System.out.println("No existe ese directorio");
}

Con este código hemos listado todos los ficheros. Si queremos listar los ocultos añadimos el método .isHidden() sobre el objeto File sobre el que estamos iterando.

if (f.exists()){
	File[] ficheros = f.listFiles();
	for (int x=0;x<ficheros.length;x++){
		if (ficheros[x].isHidden())
			System.out.println(ficheros[x].getName());
	}
} else{
	System.out.println("No existe ese directorio");
}

Algo muy sencillo y útil para no dejarnos o encontrar esos ficheros ocultos.

En los siguientes artículos intentaremos hablar de todas las novedades que trae Java SE 7 sobre la gestión de ficheros.

Como mi primera colaboración en Linea de Codigo les voy a presentar una forma muy simple para poder descargar cualquier archivo desde Java.

Sin duda, es una solución simple a un problema relativamente recurrente, pero que con un poco de maña pueden hacer algo muy poderoso, y quizás hasta profesional, como lo es un programa Auto-Actualizable.
(Abajo del todo les cuento un poco sobre mi experiencia sobre este tema.)

Pero primero es lo primero, y para empezar vamos a necesitar los siguientes elementos Java para realizar una descarga.
Estos son:

String url = "http://i.imgur.com/HZ1hq.jpg"; //dirección url del recurso a descargar
String name = "lineadecodigo.jpg"; //nombre del archivo destino

Por cuestiones de prolijidad y organización está bueno que los archivos sean destinados a una carpeta especial encargada de almacenarlos, en vez de que anden dando vueltas por ahí.

Lo siguiente que debemos hacer en nuestro programa Java es crear la carpeta destino, si es que esta no existe. En caso de no poder crearla el programa se abortará, ya que si no puede crear una carpeta, es muy probable que tampoco pueda crear el archivo destino de la descarga.

//Directorio destino para las descargas
String folder = "descargas/";
 
//Crea el directorio de destino en caso de que no exista
File dir = new File(folder);
 
if (!dir.exists())
  if (!dir.mkdir())
    return; // no se pudo crear la carpeta de destino

Por como esta planteado, si ya existía un archivo con el mismo nombre que el archivo destino, este va a ser reemplazado, con el uso del metodo public boolean exists() se puede solucionar.

Además, tengan en cuenta que el método public boolean renameTo(File dest) no funciona bien en Windows, siempre retornara false y nunca hará su cometido. Esto lo digo por si quieren usar archivos con un nombre temporal, puede que tengan problemas a la hora de renombrarlo.

Una vez hecho esto estamos en condiciones de empezar la descarga del archivo elegido en Java.

Esto se realiza de la siguiente forma:

1. Crear el archivo destino.
2. Establecer la conexión con la url.
3. Abrir los streams necesarios.
4. Leer y escribir hasta encontrar el fin del archivo.
5. Cerrar los streams (¡Importante!).

Creamos el archivo destino, en caso de existir lo elimina:

File file = new File(folder + name);

Establece la conexion con la url mediante una clase URLConnection:

URLConnection conn = new URL(url).openConnection();
conn.connect();
System.out.println("\nempezando descarga: \n");
System.out.println(">> URL: " + url);
System.out.println(">> Nombre: " + name);
System.out.println(">> tamaño: " + conn.getContentLength() + " bytes");

Abrimos los Stream:

InputStream in = conn.getInputStream();
OutputStream out = new FileOutputStream(file);

Mediante un bucle vamos leyendo del InputStream y vamos escribiendo en el OutputStream. Vamos leyendo de a un byte por vez y los escribe en un archivo. El -1 significa que se llego al final.

int b = 0;
while (b != -1) {
  b = in.read();
  if (b != -1)
    out.write(b);
}

Cerramos los streams:

out.close();
in.close();

En todo el código de manejo del URLConnection y de los Stream debemos de controlar las excepciones MalformedURLException e IOException.

try {
 ...
} catch (MalformedURLException e) {
  System.out.println("la url: " + url + " no es valida!");
} catch (IOException e) {
  e.printStackTrace();
}

Un poco mas sobre programas auto-actualizables. ¿Cuál es la clave de esto?

1. Conseguir un servidor (como googlecode) que permita almacenar archivos en una url que no se vea modificada entre cambios.
2. Una forma de versionado, por mas simple que sea, para poder reconocer si hay versiones nuevas o no.

De esta forma, podrían almacenar en un txt una lista de direcciones url correspondientes a los archivos que deben ser actualizados. Entonces, descargan ese txt, luego lo recorren como a cualquier archivo y por cada url que encuentre en él, inicien una descarga. Finalmente, reemplazan esos archivos con sus predecesores y mediante un dialogo le piden al usuario que reinicie el programa y luego lo cierran con:

System.exit (0);

O algo por el estilo.

Esto, sinceramente, les va a solucionar muchos problemas en cuanto a tiempo, ya que pueden actualizar sus programas directamente desde la comodidad de su casa.

¿Se les ocurre alguna otra utilidad? ¿Le harían alguna modificación al código Java?

Hoy un artículo sencillo pero de mucha utilidad. Como bien sabéis, dependiendo del sistema operativo que estemos utilizando en Java, las rutas de los ficheros (llamados path) se crean de diferente forma.

Así cuando creemos una ruta para un sistema operativo Windows pondremos:

c:\midirectorio\mifichero.txt

Mientras que si estamos en un sistema Linux utilizaremos:

/midirectorio/mifichero.txt

Es por ello que tenemos que tener especial cuidado en construir la ruta del fichero en nuestro programa Java. Para poder resolver esto tenemos varias alternativas. La primera sería chequeando las propiedades del sistema "os.name" y "file.separator" con .getProperty().

String so = System.getProperty("os.name");
String separador = System.getProperty("file.separator");

En el caso de "os.name" obtenemos el nombre del sistema operativo y en el caso de "file.separator" obtenemos el separador de directorios. Así, montar nuestra ruta de un fichero sería:

sPath = separador + sDirectorio + separador + sFichero;
System.out.println(sPath);

Pero, si no queremos consultar las propiedades del sistema, tenemos la constante File.separator. La cual tiene almacenado el separador de directorios del sistema operativo sobre el que nos ejecutemos. De esta forma construir la ruta de un fichero se haría de la siguiente manera:

String sPath = File.separator + sDirectorio + File.separator + sFichero;
System.out.println(sPath);

Hay que tener un poco de cuidado con la versión de Java que utilices, ya que File.separator solo está disponible desde Java 5.

¿Cual de las dos formas utilizarías? ¿Conoces alguna más?

Ya vimos en un artículo cómo obtener la fecha de modificación de un fichero con Java. En este caso vamos a ver cómo realizar la operación contraria, el cambiar la fecha de modificación de un fichero con Java. Esto puede ser útil, por ejemplo, si estamos haciendo una revisión de ficheros y queremos utilizar la fecha de modificación del fichero como flag para siguientes revisiones.

Lo primero instanciamos un fichero con un objeto File.

File fichero = new File("test.txt");

La fecha de modificación del fichero se la vamos a pasar en milisegundos, así que utilizaremos la función currentTimeMillis() del sistema para obtener la fecha actual en milisegundos.

long ms = System.currentTimeMillis();

Ya solo nos quedará volcar el contenido de la fecha sobre el fichero mediante .setLastModified() el cual recibirá los milisegundos como parámetro. En el caso de que la asignación haya ido correctamente la función devolverá true, en caso contrario devolverá false.

boolean cambio = fichero.setLastModified(ms);
if (cambio)
  System.out.println("Se ha cambiado la hora del sistema satisfactoriamente");
else
  System.out.println("NO se ha podido cambiar la hora");

Tres pasos sencillos para cambiar la fecha de modificación de un fichero con Java.

En este ejemplo vamos a ver como obtener el directorio padre de un fichero con Java. Es decir, el directorio del cual depende el fichero que instanciemos.

Lo primero será instanciar un fichero mediante la clase File.

File fichero = new File("test.txt");

Ahora se podría pensar que es tan sencillo como utilizar el método .getParent() y ya obtendríamos el directorio padre del fichero. Es decir, que el siguiente código:

fichero.getParent();

Ya nos retornará el directorio. Pero, por desgracia, no funciona ya que no hemos instanciado el fichero con un path y por lo tanto el método .getParent() devolverá null.

Así que, dado el fichero text.txt, vamos a obtener su ruta absoluta mediante .getAbsolutePath() e instanciaremos el fichero.

File fichero = new File("test.txt");
File fichero2 = new File(fichero.getAbsolutePath());
System.out.println("El directorio padre del fichero es " + fichero.getParent());

Con esas líneas ya podremos obtener el directorio padre de un fichero con Java.

Trabajando con ficheros en Java nos puede ser de utilidad obtener fecha de modificación de un fichero. Los pasos para conseguirlo son sencillos.

En primer lugar deberemos de acceder al fichero mediante la clase File.

File fichero = new File("test.txt");

Ahora que ya tenemos instanciada la clase File utilizaremos el método .lastModified(), el cual nos devolverá la fecha de la modificación pero en formato de milisegundos.

long ms = fichero.lastModified();

Así, las siguientes líneas tendrán que servirnos para convertir los milisegundos en una fecha. Esto, en Java, lo podemos conseguir mediante una clase Calendar, la cual instanciaremos mediante un Date y el resultado devuelto por .lastModified().

Date d = new Date(ms);
Calendar c = new GregorianCalendar();
c.setTime(d);

Por último nos apoyaremos en las constantes Calendar.DATE, Calendar.MONTH, Calendar.MINUTE,... para sacar los valores que nos ayuden a obtener la fecha de modificación de un fichero con Java.

dia = Integer.toString(c.get(Calendar.DATE));
mes = Integer.toString(c.get(Calendar.MONTH));
annio = Integer.toString(c.get(Calendar.YEAR));
hora = Integer.toString(c.get(Calendar.HOUR_OF_DAY));
minuto = Integer.toString(c.get(Calendar.MINUTE));
segundo = Integer.toString(c.get(Calendar.SECOND));

Si queremos saber dónde se encuentra un fichero ubicado en el disco duro deberemos de obtener la ruta absoluta del fichero. Para poder llevar a cabo esto nos vamos a basar en los métodos de la clase File de Java.

Lo primero será instanciar la clase File con el fichero del que queremos obtener la ruta absoluta.

File fichero = new File("test.txt");

Ahora simplemente deberemos de apoyarnos en el método .getAbsolutePath() para obtener la ruta absoluta. La línea de código será la siguiente:

System.out.println("La ruta del fichero es: " + fichero.getAbsolutePath());

Como vemos, en un simple método tenemos la ruta absoluta de un fichero con Java.

Ayer nos interesábamos por saber cual es el directorio temporal del sistema con Java. Y es que hoy vamos a generar un fichero temporal con Java y claro está, deberíamos saber dónde ir a buscarlo.

Creo que no hace falta explicar la utilidad de los ficheros temporales. Simplemente tenemos que saber que no todos los datos que utilizamos en nuestros programas tienes porqué ser guardados. En esos casos, utiliza ficheros temporales.

Java nos ofrece un conjunto de métodos muy extensos en la clase File y uno de ellos es createTempFile(). El método createTempFile() nos crea un fichero temporal en el directorio que le digamos o en el directorio temporal del sistema.

Creemos el fichero...

File tempFile = File.createTempFile("mificherotemporal",null);

Es muy importante que el fichero creador por createTempFile() tendrá un número generado aleatoriamente. A dicho número le podemos añadir un prefijo o sufijo para añadirlo. En nuestro caso le hemos antepuesto 'mificherotemporal' y no le hemos asignado sufijo.

Siempre que crees ficheros en Java con la clase File recuerda el manejar la excepción IOException.

Una cosa importante cuando trabajamos con ficheros temporales en Java es que, estos, por defecto no se borran. Si lo que queremos es borrar el fichero cuando termine nuestro programa deberemos de llamar al método .deleteOnExit().

tempFile.deleteOnExit();

Ya solo nos queda volcar algo de contenido sobre nuestro fichero temporal.

BufferedWriter out = new BufferedWriter(new FileWriter(tempFile));
out.write("Esto es un fichero temporal");
out.close();

Y trabajo hecho. Ya tenemos creado nuestro fichero temporal con Java.

Cuando manejamos ficheros de configuración una buena idea es tratar todos los ficheros como si fuesen URL. Así evitaremos el estar chequeando si el fichero de acceso está en nuestra máquina os es una URL destino. Por lo tanto vamos a convertir de Path a una URL utilizando el lenguaje Java.

Lo primero será partir de un fichero, el cual instanciaremos mediante una clase File.

File fichero = new File("test.txt");

Si vemos el path del fichero veremos que es una cosa así:

C:\Users\lineadecodigo\files\test.txt

El siguiente paso será realizar la conversión de fichero a URL. Esto lo hacemos mediante el método .toURL() que trae la clase File.

URL url = null;
url = fichero.toURL();

Tenemos que tener cuidado en esta conversión ya que podemos tener una MalformedURLException y habrá que controlarla mediante un bucle try-catch

Si ahora volcamos el contenido de la URL veremos que tenemos una cosa así:

file:/C:/Users/lineadecodigo/files/test.txt

La conversión de Path a URL la podemos hacer a la inversa, es decir de URL a Path. Para ello utilizamos el método .getFile() de la clase URL.

File fichero2 = new File(url.getFile());

Pero como decíamos al principio, lo mejor tratar con las URL de los ficheros.

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.