Manipulando Ficheros en Java 7 (I)

Una de las mejoras que incluye la última versión de Java tiene que ver con el manejo de ficheros. Anteriormente se utilizaba la clase java.io.File para el manejo de archivos, la nueva versión de la JDK nos permite utilizar la clase java.nio.file.Path para manipular las rutas fichero en cualquier sistema de ficheros. Para poder utilizarla en varias implementaciones del sistema de ficheros, esta nueva API se basa en fábricas. De esta manera no nos tenemos que preocupar por la implementación real.En versiones inferiores a la JDK7 un fichero se podía crear así:

[crayon lang=”java”]
File file = new File(“c:/newfile.txt”);

if (file.createNewFile()){
System.out.println(“Fichero creado correctamente”);
} else {
System.out.println(“El fichero ya existe);
}
[/crayon]

y con la nueva versión quedaría así:

[crayon lang=”java”]
Path ruta = Paths.get(“c:/newfile.txt”);
Path file = Files.createFile(ruta);
[/crayon]

Clase PATH

La clase Path es una representación de una ruta en el sistema de archivos. El objeto contiene el nombre del archivo y la lista de directorio utilizado para construir la ruta, y se utiliza para examinar, buscar y manipular archivos. Con la clase Path podemos obtener una gran cantidad de información sobre la ruta. Un pequeño ejemplo para obtener los atributos básicos de una ruta:

[crayon lang=”java”]
Path path = Paths.get(“C:/Users/Documents/fichero.txt”);

//Devuelve la ruta completa del fichero
System.out.format(“toString: %s%n”, path.toString());
//Devuelve el nombre del fichero
System.out.format(“getFileName: %s%n”, path.getFileName());
//Devuelve el elemento correspondiente a la posición de la ruta
System.out.format(“getName(0): %s%n”, path.getName(0));
//Devuelve el numero de elementos del Path: 3
System.out.format(“getNameCount: %d%n”, path.getNameCount());
//Devuelve una secuencia de la ruta: /Users/Documents
System.out.format(“subpath(0,2): %s%n”, path.subpath(0,2));
//Devuelve el directorio padre: /Users/Documents
System.out.format(“getParent: %s%n”, path.getParent());
//Devuelve el elemento raíz: C:/
System.out.format(“getRoot: %s%n”, path.getRoot());
[/crayon]

Muchos sistemas de ficheros utilizan el “.” para referirse al directorio actual y utilizan “..” para referirse al directorio padre. Esto puedo producir redundancias dentro de la clase Path, algunas situaciones que se podrían presentar serian:

/home/./joe/foo
/home/sally/../joe/foo

<

p style=”text-align: justify;”>Para resolver estas redundancias la clase Path nos proporciona el método normalize().El cual nos resuelve las redundancias producidas en estos casos devolviendonos la ruta final, en este caso sería:

/home/joe/foo
/home/joe/foo

En ocasiones necesitamos obtener la dirección del fichero o directorio que estamos tratando. Para ello tenemos tres métodos:

  • toUri: devuelve un string que puede ser abierto por un navegador.

[crayon]
Path path = Paths.get(“/home/logfile”);
// Dcuelce:///home/logfile
System.out.format(“%s%n”, path.toUri());
[/crayon]

  • toAbsolutePath: devuelve la ruta absoluta del fichero.

[crayon]
// Convierte un array de strings en un path
Path inputPath = Paths.get(args[0]);

// Convierte inputPath a un Path absoluto.
Path fullPath = inputPath.toAbsolutePath();
[/crayon]

  • toRealPath: devuelve la ruta real de un fichero existente. Este método devuelve distintos valores según los datos que se le pasan:
    • Si le pasamos el valor true y el sistema de ficheros soporta links simbólicos, devuelve un link simbólico.
    • Si le pasamos una ruta relativa, devuelve la ruta absoluta del fichero.
    • Si la ruta contiene alguna redundancia, el método devuelve la ruta eliminando la redundancia.

    [crayon]
    try {
    Path file = path.toRealPath(true);
    } catch (NoSuchFileException x) {
    System.err.format(“%s: no encontrado” + ” file + “%n”, file);
    } catch (IOException x) {
    System.err.format(“%s%n”, x);
    }
    [/crayon]

Otra gran ventaja que nos proporciona la clase Path es la utilización de los métodos equals(), startsWith() y endsWith() para la comparación de las rutas de dos archivos.

[crayon]
Path path = …;
Path otherPath = …;
Path empieza = Paths.get(“/home”);
Path termina = Paths.get(“foo”);

if (path.equals(otherPath)) {
return “equals”
} else if (path.startsWith(empieza )) {
return “Empieza por //home”
} else if (path.endsWith(termina )) {
return “Termina en foo”
}
[/crayon]

Por último la clase Path implementa las interfaces Comparable e Iterable. Con el interfaz Iterable podremos iterar sobre cada uno de los nombre que forman la ruta.

[crayon]
Path path = …;
for (Path name: path) {
System.out.println(name);
}
[/crayon]

Con esto podemos empezar a manejar ficheros y directorios de una manera sencilla. Más adelante veremos como crear, borrar o leer ficheros y directorios.