Linea de Codigo

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.

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.

Con el siguiente código vamos a ver como podemos copiar el contenido de un directorio en otro utilizando el lenguaje Java.

Lo primero será entender la idea de cómo resolver el problema de la copia de directorios con Java. La cuestión es que no podemos ejecutar una copia tal cual del directorio ya que dicho directorio puede albergar contenido. Además dicho contenido puede ser a su vez otro directorio con más contenido.

Con esto vemos que lo que necesitamos es hacer un programa Java recursivo que vaya recorriendo cada directorio y copiando todo su contenido de uno a otro.

Lo primero será definir el interface de nuestro método que sirve para copiar directorios.

public static void copiarDirectorios(File d1, File d2){...}

El método controlará la recursividad comprobando si el fichero que llega en primer lugar es un directorio, ya que si no lo es asumirá que es un fichero y procederá a su copia.

Es decir, la estructura del programa Java quedará de la siguiente forma:

public static void copiarDirectorios(File d1, File d2){
  if (d1.isDirectory()){
    // Recorremos recursivamente el directorio
  else
    // Copiamos d1 a d2, ya que serán ficheros
  }
}

La parte de cómo se copia un fichero en otro la explicamos en el ejemplo de Copiar ficheros con Java.

Si bien pegamos aquí el código Java para que quede como referencia:

public static void copiarFicheros(File f1, File f2){
 
  try {
    InputStream in = new FileInputStream(f1);
    OutputStream out = new FileOutputStream(f2);
 
    byte[] buf = new byte[1024];
    int len;
 
    while ((len = in.read(buf)) > 0) {
      out.write(buf, 0, len);
    }
 
    in.close();
    out.close();
 
  } catch (IOException ioe){
    ioe.printStackTrace();
  }
}

Ahora pasamos a recorrer el contenido del directorio. Lo primero que tenemos que hacer es la creación del directorio destino. Eso sí, si el directorio no existe. Aquí jugamos con el método .exits() para ver si existe el directorio y .mkdir() para ayudarnos a crear el directorio.

if (!d2.exists()){
  d2.mkdir();
  System.out.println("Creando directorio " + d2.toString());
}

Una vez creado el directorio destino recorremos el directorio origen y procedemos a la copia. Hay que recordar que la lista de ficheros que contiene un directorio nos la proporciona el método .list(). Dicho método nos devuelve un array de String, el cual recorreremos.

String[] ficheros = d1.list();
for (int x=0;x<ficheros.length;x++) {
  copiarDirectorios(new File(d1,ficheros[x]),new File(d2,ficheros[x]));
}

Por cada fichero volvemos a llamar a nuestro método copiarDirectorios de forma recursiva. Si lo que le pasamos es un directorio volverá a realizar la misma operación. Si lo que le pasamos son ficheros, directamente los copiará.

En este ejemplo vamos a ver como podemos copiar un fichero mediante Java. De tal manera que acabemos teniendo un segundo fichero con el mismo contenido del primer fichero.

Lo primero que haremos será crear dos objetos de tipo File, los cuales representarán al fichero origen y al fichero destino:

File origen = new File("origen.txt");
File destino = new File("destino.txt");

La idea principal de la copia será la de abrir un stream de lectura, es decir, un InputStream, sobre el fichero origen, realizar la lectura a la vez que abrimos un stream de escritura sobre el fichero destino, es decir, un OutputStream. Sobre este OutputStream realizaremos la escritura.

Nos apoyamos en los objetos File creados anteriormente, así como en las clases FileInputStream y FileOutputStream para abrir los stream a los ficheros:

InputStream in = new FileInputStream(origen);
OutputStream out = new FileOutputStream(destino);

Realizamos la lectura y escritura mientras existan datos en el stream de lectura

byte[] buf = new byte[1024];
int len;
 
while ((len = in.read(buf)) > 0) {
  out.write(buf, 0, len);
}

Las lecturas las hacemos mediante el método .read().

Ya solo nos quedará cerrar los stream mediante el método .close() para finalizar el código de nuestro programa.

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

Cabe notar que necesitamos controlar la excepción IOException en todo el código. Es por ello, que todo el código lo tendremos en una estructura try-catch.

Si ayer veíamos como Vaciar el contenido de un fichero con Java. Hoy vamos a proponer otra alternativa a lo explicado en dicho artículo.

En este caso el procedimiento para vaciar el contenido de un fichero con Java será el de borrar el fichero y volverlo a crear. Un procedimiento mucho más brusco que el anterior.

Hay que tener especial cuidado ya que en ciertos entornos podemos manipular el contenido de un fichero, si bien no tenemos capacidades de borrado y creación de los mismos. Es por ello que este código no valdría. De igual manera es brusco, ya que el proceso podría realizar solo uno de los dos pasos -el borrado- y dejar incosistente el sistema. Es por ello que seguimos recomendando lo explicado en Vaciar el contenido de un fichero con Java.

Si bien, vamos con ello... Con la clase File obtenemos una instancia del fichero que queremos manipular

String sFichero = "fichero1.txt";
File f = new File(sFichero);

Ahora solo tenemos que enviar los dos comandos: el de borrado mediante el método .delete() y el de creación mediante el método .createNewFile()

f.delete();
try {
  f.createNewFile();
} catch (IOException ioe) {
  ioe.printStackTrace();
}

Cuando lanzamos el método .createNewFile() hay que tener cuidado ya que se puede elevar la excepción IOException.

Ya hemos visto que con unas pocas líneas podemos vaciar el contenido de un fichero mediante borrado y creación.

Nos llegaba una pregunta vía comentarios sobre como vaciar el contenido de un fichero con Java. Y nos pusimos manos a la obra.

El procedimiento es muy sencillo. Lo primero que tenemos que hacer es abrir un stream de escritura sobre el fichero. Para ello necesitaremos de un FileWriter y un BufferedWriter.

BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero));

Una vez que tenemos el stream sobre el BufferedWriter lo que vamos a hacer es escribir una línea vacía. Para ello utilizamos el método .write().

bw.write("");

Así lo que conseguimos es machacar todo el contenido que pudiese existir en el fichero. Vaciándolo de su contenido actual. Ahora, no hay que olvidarnos de cerrar nuestro fichero. Esto lo hacemos mediante el método .close() del BufferedWriter.

bw.close();

Y ya hemos conseguido vaciar el contenido de un fichero con Java.

Ojo, hay que tener cuidado de que el fichero exista o se nos generará una excepción FileNotFoundException o IOException.

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");

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");