Linea de Codigo

El directorio temporal del sistema será aquel directorio dónde volquemos los ficheros que no tengan utilidad final, aquellos que solo estemos utilizando para fines temporales.

Si queremos saber cual es el directorio temporal del sistema en Java deberemos de utilizar la clase System y acceder a las propiedades del sistema. En concreto deberemos de acceder a la propiedad java.io.tmpdir. Para ello utilizamos el método .getProperty().

Solo tenemos que volcarlo por la consola:

System.out.println("El directorio temporal del sistema es "
  + System.getProperty("java.io.tmpdir"));

En sucesivos artículos trabajaremos con ficheros temporales que dejaremos en el directorio temporal del sistema.

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 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?

Una de las cosas útiles en los lenguajes de programación es saber en que directorios concretos tenemos ciertas instalaciones. Por ejemplo, si estamos codificando una página ASP y queremos generar ficheros podríamos tener la necesidad de saber cual es el directorio dónde se dejan los ficheros temporales en la máquina que nos ejecutamos.

De esta manera, en ASP y mediante el objeto FileSystemObject podemos tener conocimiento donde estan instaladas algunas de las carpetas de Windows. Para ello simplemente tenemos que utilizar el método .GetSpecialFolder(). Este método puede recibir como parámetro tres números

• 0. Carpeta donde está instalado Windows.
• 1. Carpeta del sistema.
• 2. Carpeta del directorio de temporales.

Así el código en ASP que necesitamos sería algo parecido a:

<%
  Response.Write "Carpeta de Windows " & fso.GetSpecialFolder (0) & "<br>"
  Response.Write "Carpeta del Sistema " & fso.GetSpecialFolder (1)  & "<br>"
  Response.Write "Carpeta Temporal "  & fso.GetSpecialFolder (2)  & "<br>"
%>

Una de las cosas que nos permite el objeto FileSystemObject es listar el contenido de un directorio.
Esto nos puede servir si queremos implementar mediante ASP una especie de navegador de carpetas del servidor o algo por el estilo. De esta manera y junto con el resto de características del objeto FileSystemObject podemos llegar a implementar un verdadero gestor de los ficheros de nuestro servidor.

Lo primero que tenemos que hacer es obtener una referencia a dicho objeto:

Set fso = CreateObject("Scripting.FileSystemObject")

Una vez instanciado el objeto FileSystemObject, lo que tenemos que hacer es recuperar una referencia a la carpeta de la cual queremos listar los archivos. Para ello nos apoyamos en el método .GetFolder().

Set directorio = fso.GetFolder ("C:\windows")

Esta referencia, en si, es otro objeto, el cual contendrá el listado de ficheros. A si que, lo que pasaremos a hacer es recorrer dicho objeto ayudándonos de un bucle for..each.

For Each fichero IN directorio.Files
   ...
Next

Directamente podemos volcar el contenido de la variable fichero, lo cual nos dará información sobre el mismo. Por otro lado, si queremos obtener solo el nombre del fichero, podemos crear un objeto File. Del objeto file podemos utilizar la propiedad Name para obtener únicamente el nombre del fichero, sin la ruta.

Set file = fso.GetFile(fichero)
Response.Write fichero.Name &"<BR>"

El código completo nos quedaría de la siguiente forma:

For Each fichero IN directorio.Files
   Set file = fso.GetFile(fichero)
   Response.Write (fichero.Name)&"<BR>"
Next
 

La clase File nos permite en Java instanciar cualquier elemento del sistema de ficheros y trabajar con él de una forma genérica. A la hora de instanciar el elemento podremos pasar al constructor bien un directorio o bien un fichero.

La instanciación de un objeto File sería de la siguiente forma:

File fRuta = new File("c:\\prueba");

Solo tendremos que apoyarnos en el método .isDirectory() para saber si una ruta es un directorio con Java :

if (fRuta.isDirectory())
  System.out.println("Es un directorio");
else
  System.out.println(" NO es un directorio");

La forma de crear un directorio con ASP es muy sencilla. Al igual que el resto de operaciones con ficheros utilizaremos el objeto FileSystemObject. Así tendremos una primera línea como esta:

Set fso = CreateObject("Scripting.FileSystemObject")

Los objetos siempre los creamos mediante la clausula CreateObject(nombreDelObjeto). Una vez creado el objeto simplemente deberiamos de usar el método CreateFolder(nombreDelDirectorio), pero si existe el directorio nos va a dar un error. Es por ello que deberemos de validar la existencia del directorio mediante FolderExits(nombreDelDirectorio).

if (Not fso.FolderExists(carpeta)) then
     Set fol = fso.CreateFolder(carpeta)
   end if

Para borrar un directorio en Java podemos utilizar el mismo código que para borrar un fichero.

Los pasos serían muy sencillos, ya que simplemente deberíamos de instanciar el objeto File y ejecutar el método .delete sobre el directorio.

 
String sDirectorio = "c:\\directorio";
File f = new File(sDirectorio);
 
if (f.delete())
 System.out.println("El fichero " + sDirectorio + " ha sido borrado correctamente");
else
 System.out.println("El fichero " + sDirectorio + " no se ha podido borrar");
 

El inconveniente de este código es que solo funciona si el directorio sobre el que lo ejecutamos está vacío.

Es por ello que para borrar un directorio con Java deberemos de borrar cada uno de los ficheros y directorios que este contenga. Al poder almacenar otros directorios, el código debe de recorrer recursivamente el directorio para ir borrando todos los ficheros.

Para ello vamos a realizar un método que recorra los directorios, vaya borrando los ficheros del directorio y vaya entrando en los subdirectorios para hacer la misma operación.

 
public static void borrarDirectorio (File directorio){...}
 

Lo primero que haremos en el método borrarDirectorio es recuperar la lista de ficheros del directorio mediante el método .listFiles(). Mediante un bucle for recorreremos los elementos del directorio

 
 File[] ficheros = directorio.listFiles();
 
 for (int x=0;x<ficheros.length;x++){...}
 

Si el elemento es un directorio, lo sabemos mediante el método .isDirectory, volvemos a llamar al método borrarDirectorio y luego borramos el directorio. En caso contrario, simplemente borramos el fichero.

 
if (ficheros[x].isDirectory()) {
  borrarDirectorio(ficheros[x]);
}
ficheros[x].delete())
 

En el programa principal instanciamos el directorio a borrar y llamamos al método borrarDirectorio. Una vez borrado el directorio, ejecutamos el método .delete() sobre el directorio, que ya estará vacío.

 
String sDirectorio = "c:\\prueba";
File f = new File(sDirectorio);
 
borrarDirectorio(f);
 
if (f.delete())
  System.out.println("El directorio " + sDirectorio + " ha sido borrado correctamente");
else
  System.out.println("El directorio " + sDirectorio + " no se ha podido borrar");
 

Ayer veíamos como listar el contenido de un directorio con Java. En este ejemplo listabamos el contenido, saliendo como resultado los ficheros y directorios que contenía este.

En este caso lo que vamos a hacer es listar el contenido de los directorios de forma recursiva. Es decir, cada vez que nos encontremos un directorio dentro del directorio que estamos listando, entraremos en él y listaremos su contenido. Así de forma recursiva sobre todos los directorios.

En este caso vamos a crear un método listarDirectorio, el cual reciba un elemento File que sea un directorio.

public static void listarDirectorio(File directorio){...}

Lo primero que haremos será recuperar la lista de ficheros del directorio a listar mediante el método .listFiles(). Este método nos devuelve un array de Files.

Mediante un bucle for iremos recorriendo el array y volcando el nombre del fichero mediante el método .getName().

for (int x=0;x<ficheros.length;x++){
	System.out.println(separador + ficheros[x].getName());
}

Ahora viene la diferencia con respecto a listar el contenido de un directorio con Java. Y es que por cada elemento, además de volcar su nombre, comprobaremos si es un directorio mediante el método .isDirectory().

En el caso de que el elemento sea un directorio, volveremos a llamar al método listarDirectorio(), Pasándolo en elemento File que estamos tratando.

if (ficheros[x].isDirectory()){
	String nuevo_separador;
	nuevo_separador = separador + " ";
	listarDirectorio(ficheros[x],nuevo_separador);
}

En el código hemos insertado una variable separador, la cual añadirá un espacio en blanco cada vez que cambiemos de directorio.

Mediante la clase File podremos listar de forma sencilla el contenido de un directorio. Lo primero que tendremos que hacer es crear un objeto de tipo File con el nombre del directorio a a listar.

 
String sDirectorio = "c:\\datos";
File f = new File(sDirectorio);
 

Utilizaremos el método .exists() para comprobar que el directorio existe.

 
if (f.exists()){ // Directorio existe }
else { //Directorio no existe }
 

Una vez pasada esta validación utilizamos el método .listFiles. Este método devuelve todos los ficheros asociados al directorio en un array de Files. Es por ello que solo nos quedará recorrer el array e ir mostrando el nombre de lo ficheros y directorios que componen nuestro directorio.

 
File[] ficheros = f.listFiles();
for (int x=0;x<ficheros.length;x++){
  System.out.println(ficheros[x].getName());
}

Para obtenerel nombre del fichero o directorio utilizamos el método .getName().