Persigue el objetivo de mejorar el rendimiento de una aplicación impidiendo la creación de varias instancias de una clase.

public class SingletonClass {
	
	private static final SingletonClass instance = new SingletonClass();
	
	private SingletonClass() {}
	
	public static SingletonClass getInstance() {
		return instance;
	}
}

Por último se añade un método público y estático el cuál podrá acceder al campo estático y devolver su valor.

              public static SingletonClass getInstance() {
                  return instance; 
              }

Patrón Dao (Data-Acces-Object)

La  clase FileStore es útil para proporcionar información de uso sobre el sistema de archivos como el total de disco utilizable y asignado.

En este enlace oficial de Oracle puede estudiarse la implementación de FileStore.

Interfaz WatchService

La implementación de la interfaz de WatchService representa un servicio de vigilancia que observa los cambios producidos en los objetos Path registrados.

Por ejemplo, una instancia de WatchService puede usarse para identificar cuándo fueron añadidos, borrados o modificados archivos en un directorio.

NOTA:
La implementación del mecanismo de observación del sistema de ficheros es dependiente de la plataforma de ejecución.

Por defecto, se intentan mapear los eventos que se observan a través del WatchService con los eventos nativos que el Sistema Operativo genera ante los cambios de ficheros. Esto hace que sea posible encontrarse diferentes tipos de eventos resultados de una misma acción.

En caso que no sea posible consumir los eventos nativos, la implementación en caso de error se encargará de polling consultar el estado de los elementos del sistema de ficheros indicado.

La contra partida de este mecanismo de fallback es que ante eventos muy seguidos, es posible que no se reciban todos los eventos generados si el tiempo entre muestra y muestra es superior al tiempo transcurrido entre los eventos.

En todo caso, la utilización de este servicio ha de tener en cuenta esta particularidad para no obtener resultados inesperados.

En este enlace oficial de Oracle puede estudiarse con más detalle el funcionamiento de la interfaz WatchService.

Operaciones recursivas

La classe Files ofrece un método para recorrer el árbol de archivos en busca de operaciones recursivas, como de copia y de supresión.

Interfaz FileVisitor<T>

La interfaz FileVisitor<T> permite realizar el recorrido de un nodo raíz de forma recursiva. Puede encontrarse la implementación en la API del JDK 7 en el siguiente enlace.

Para poder llevar a cabo el recorrido recursivo mencionado con anterioridad se detallan los siguientes métodos, representando puntos clave del recorrido recursivo. Son métodos a los que se vaya llamando cada vez que se visita uno de los nodos del árbol:

El objeto FileVisitResult es el tipo de retorno para la interfaz FileVisitor. Contiene  cuatro constantes  que permiten procesar el archivo visitado e indicar que debe ocurrir en el próximo archivo (Enum FileVisitResult – para un mayor detalle se puede consultar directamente la API de JDK 7 en este enlace). Estas constantes representan  las acciones que tomar tras alcanzar un nodo (antes o después):

A continuación se muestra un código Java que ilustra la utilización de los cuatro métodos definidos con anterioridad:

package recursiveoperations;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import static java.nio.file.FileVisitResult.CONTINUE;
import java.nio.file.FileVisitor;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;

public class PrintTree implements FileVisitor<Path> {

    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attr) {
        System.out.print("preVisitDirectory: ");
        System.out.println("Directory : " + dir);
        return CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attr) {
        System.out.print("visitFile: ");
        System.out.print("File : " + file);
        System.out.println("(" + attr.size() + " bytes)");
        return CONTINUE;
    }

    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
        System.out.print("postVisitDirectory: ");
        System.out.println("Directory : " + dir);
        return CONTINUE;
    }

    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
        System.out.print("vistiFileFailed: ");
        System.err.println(exc);
        return CONTINUE;
    }
}

A continuación se muestra un código de ejemplo utilizando la clase PrintTree:

Path path = Paths.get("D:/Test");
try{
    Files.walkFileTree(path, new PrintTree())
} catch (IOException e) {
    System.out.println("Exception: "+e);
}

En este ejemplo la clase PrintTree implanta cada uno de los métodos en FileVisitor e imprime el tipo, nombre y el tamaño del directorio y el archivo de cada nodo.

Búsqueda de Archivos

En java.nio.file se incluye la interfaz PathMatcher la cuál define el método matches(Parth path).  Éste método  permite determinar si un objeto Path coincide con una cadena de búsqueda especificada.Cada implantación de sistema de archivos proporciona un objeto PathMatcher recuperable mediante FileSystems:

PathMatcher matcher = FileSystems.getDefault().getPathMatcher(String syntaxPattern);

La cadena syntaxPattern presenta la siguiente forma sintaxis:patrón dónde sintaxis puede ser «glob» o  «regex».Y cúando la sintaxis es «regex«, el componente patrón es una expresión regular definida por la clase Pattern.

Se incluye el siguiente código Java. Esta clase se utiliza para recorrer el árbol en busca de coincidencias entre el archivo y el archivo alcanzado por el método VisitFile.

package findingfiles;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import static java.nio.file.FileVisitResult.CONTINUE;
import java.nio.file.FileVisitor;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.attribute.BasicFileAttributes;

public class Finder implements FileVisitor<Path> {
    
    private Path root;
    private PathMatcher matcher;
    
    Finder(Path root, PathMatcher matcher) {
        this.root = root;
        this.matcher = matcher;
        
    }
    
    private void find(Path file) {
        Path name = file.getFileName();
        if (name != null && matcher.matches(name)) {            
            System.out.println(file);
        }
    }
    
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        find(file);
        return CONTINUE;
    }
    
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        return CONTINUE;
    }
    
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
        return CONTINUE;
    }
    
    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
       return CONTINUE;
    }
}

Una vez definido el tipo, se instancia en una clase MyClass y se ejecuta.

package findingfiles;

import java.io.IOException;
import java.nio.file.*;

public class MyClass {

    public static void main(String[] args) {

        Path root = Paths.get("C:\JavaTest");

        PathMatcher matcher = FileSystems.getDefault().getPathMatcher
                                                              ("glob:*.{java,class}");
        
        Finder finder = new Finder(root, matcher);
        try {
            Files.walkFileTree(root, finder);
        } catch (IOException e) {
            System.out.println("Exception: " + e);
        }
       
    }
}

El primer argumento se prueba para ver si es un directorio. El segundo argumento se usa para crear una instancia PatchMatcher con una expresión regular mediante la fábrica FileSystems.Finder es un clase que implanta la interfaz FileVisitor, de modo que se puede transferir a un método walkFileTree. Esta clase se usa para llamar al método de coincidencia en todos los archivos visitados en el árbol.

NIO

Es el acrónimo de New Input Output.

NIO.2  del Jdk 1.7 implementa un nuevo paquete java.nio.file con dos subpaquetes:

–java.nio.file.attribute:  Que permite un acceso masivo a los atributos  de los archivos.

–java.nio.file.spi: Dónde SPI significa Service Provider Interface. Es una interfície que permite establecer la conexión de la implementación de varios sistemas de archivos, permitiendo al desarrollador crear  su propia versión del proveedor de sistema de archivos si así lo requiere.

 

La clase FileSystem

Proporciona un método de intercomunicación con un sistema de archivos y un mecanismo para la creación de objetos usados para la manipulación de archivos y directorios.

Interface Path – java.nio.file.Path

Puede encontrarse informació más detallada en la API oficial. 

Métodos principales de la interfaz Path (se pueden encontrar más métodos en la URL oficial):

La clase Files – java.nio.file.Files

Esta clase contiene métodos estáticos los cuáles podemos utilizar para realizar operaciones en archivos o en directorios. 

Puede encontrarse información más detallada en la API oficial.

La clase Files es sumamente importante para poder realizar operaciones con objetos Path tales como:

El siguiente código ejemplifica su utilización.

package filesclass;

import java.io.IOException;
import java.nio.file.*;
import java.util.Set;

public class FilesClass {
  
    public static void main(String[] args) {

        Path p1 = Paths.get("C:\JavaCourse\src\Example.java");

        System.out.println("exists: " + Files.exists(p1));
        System.out.println("isReadable: " + Files.isReadable(p1));
        System.out.println("isWritable: " + Files.isWritable(p1));
        System.out.println("isExecutable: " + Files.isExecutable(p1));

        //Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-x---");
        //FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(perms);

        try {
            //Path f1 = Paths.get("C:\JavaCourse\src\Hello.txt");
            //Files.createFile(f1, attr);             
            Files.setAttribute(p1, "dos:readonly", true);
            System.out.println("Example.java isWritable: " + Files.isWritable(p1));
            System.out.println(Files.createTempFile("test", ".temp"));

        } catch (IOException e) {
            System.err.println(e);
        }
    }
}

Adicionalmente se puede comprobar y modificar el nivel de accesibilidad de un archivo o directorio mediante los siguientes métodos

El siguiente código muestra un caso de ejemplo de borrado, copia y pegado de ficheros en Java7.

package filesclass;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;


public class FilesClass2 {

    public static void main(String[] args) {

        Path f1 = Paths.get("C:\JavaCourse\src\Hello.txt");
        Path f2 = Paths.get("C:\student\Hello2.txt");
        
        
        try {
                        
            Files.copy(f1,f2,REPLACE_EXISTING);
            Files.delete(f1);
            Files.move(f2,f1,REPLACE_EXISTING);
            
            System.out.println("Hello.txt exists: " + Files.exists(f1));
            System.out.println("Hello2.txt exists: " + Files.exists(f2));

        } catch (NoSuchFileException n) {
            System.err.println(n);
            
        } catch (IOException e) {
            System.err.println(e);
        }
    }
}

Relación y conversión entre  Path y File

Entre la Interface Path y la classe File existen mecanismos para obtener una representación de un tipo a el otro. En el JDK7 no es necesario realizar operaciones de conversión complejas solamente es necesario recurrir al método .toFile de cada uno de ellos:

• path.toFile():  Retorna un objeto File representando su ruta.
• file.toPath(): Retorna un objeto de tipo Path construido desde una ruta abstracta. El objeto Path resultante se encuentra asociado con el sistema de archivos por defecto.

Código fuente de ejemplo.

1 2	File file = path.toFile(); Path file = file.toPath();