Archivos Java – Clase Files de java.nio.file

Tutoriales
Java

La clase Files de Java fue introducida en Java 1.7 y forma parte del paquete java.nio.file.

Clase Files de Java

  • La clase Files de Java contiene métodos estáticos que trabajan con archivos y directorios.
  • Esta clase se utiliza para operaciones básicas de archivos, como crear, leer, escribir, copiar y eliminar archivos o directorios en el sistema de archivos.

Antes de seguir adelante, echemos un vistazo a los términos a continuación:

  1. Path: Esta es la interfaz que reemplaza a la clase java.io.File como representación de un archivo o directorio cuando trabajamos en Java NIO.
  2. Paths: Esta clase contiene un método estático para crear una instancia de Path.

java.nio.file.Path interface es similar a la antigua clase java.io.File. Path representa la ubicación del archivo y cuando creamos un Path para un nuevo archivo, no crea el archivo real hasta que lo creamos usando Files.createFile(Path filePath). Como se puede ver en el diagrama anterior, la clase Paths se utiliza para crear una instancia de Path y la clase Files utiliza la instancia de Path para trabajar en un archivo. Los objetos File y Path saben cómo convertirse entre sí, así es como podemos utilizar código más antiguo para interactuar con la nueva utilidad Files.

Java IO vs NIO

Cómo crear un Path

Podemos crear un objeto Path llamando al método Paths.get(String first, String... more) de la clase Paths. 

Path path1 = Paths.get("/tmp/file.txt"); // For UNIX

Path path2 = Paths.get("D:/data/file.txt"); // For Windows

También podemos crear un objeto Path separando las partes de la ruta en el método Paths.get(). 

Path path1 = Paths.get("/tmp", "file.txt");

Path path2 = Paths.get("D:", "data", "file.txt");

Path path3 = Paths.get("D:/data", "file.txt") ;

Como se puede ver, podemos pasar el nombre de la carpeta y del archivo por separado en el método Paths.get().

Métodos de Archivos Java

La clase Files de Java NIO contiene métodos estáticos que se utilizan para manipular archivos y directorios, y estos métodos funcionan principalmente en un objeto Path. Echemos un vistazo a los siguientes métodos de la clase Files:

  1. copy(InputStream in, Path target, CopyOption… options): Este método copia todos los bytes desde el flujo de entrada especificado al archivo de destino especificado y devuelve la cantidad de bytes leídos o escritos como un valor largo.
  2. copy(Path source, OutputStream out): Este método copia todos los bytes desde el archivo de origen especificado al flujo de salida dado y devuelve la cantidad de bytes leídos o escritos como un valor largo.
  3. copy(Path source, Path target, CopyOption… options): Este método copia el archivo de origen dado al archivo de destino especificado y devuelve la ruta del archivo de destino.
  4. createDirectories(Path dir, FileAttribute<?>… attrs): Este método crea directorios utilizando la ruta dada, creando primero todos los directorios padres que aún no existen. Este método no arrojará una excepción si no se pudo crear el directorio porque ya existe. FileAttribute es un parámetro opcional para configurar automáticamente al crear los directorios no existentes y devuelve la ruta del directorio creado.
  5. createDirectory(Path dir, FileAttribute<?>… attrs): Este método crea un directorio usando el camino dado. Si el directorio se crea correctamente, devolverá el camino del directorio creado. Si el directorio ya existe, lanzará nio.file.FileAlreadyExistsException.
  6. createFile(Path path, FileAttribute<?>… attrs): Este método crea un nuevo archivo vacío usando el camino dado y devuelve el camino del archivo recién creado si se crea correctamente. Si el archivo ya existe, lanzará nio.file.FileAlreadyExistsException.
  7. createTempDirectory(Path dir, String prefix, FileAttribute<?>… attrs): Este método crea un directorio temporal usando el camino dado y generará el nombre del directorio usando el prefijo dado. Devolverá el camino del directorio temporal recién creado.
  8. createTempDirectory(String prefix, FileAttribute<?>… attrs): Este método crea un directorio temporal en el directorio de archivos temporales predeterminado y genera el nombre del directorio usando el prefijo dado. Devolverá el camino del directorio temporal recién creado que está asociado con el Sistema de Archivos predeterminado.
  9. createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>… attrs): Este método crea un archivo temporal en el directorio especificado y genera el nombre del archivo usando el prefijo y sufijo dados, y devuelve el camino del archivo recién creado.
  10. createTempFile(String prefix, String suffix, FileAttribute<?>… attrs): Este método crea un archivo temporal en el directorio predeterminado de archivos temporales y genera el nombre del archivo usando el prefijo y sufijo dados, devolviendo la ruta del archivo recién creado.
  11. delete(Path path): Este es un método void y simplemente elimina el archivo del camino especificado. Este método lanza NoSuchFileException si el archivo no existe en el camino especificado y si el archivo es un directorio que puede no estar vacío y no se puede eliminar, en este caso lanzará
  12. deleteIfExists(Path path): Este método verifica si el archivo existe antes de eliminarlo y devuelve un valor booleano verdadero si el archivo en el camino dado se elimina correctamente, y falso si el archivo no existe en el camino dado. Si el archivo es un directorio que puede no estar vacío y no se puede eliminar, en este caso lanzará
  13. exists(Path path): Este método verifica si el archivo existe en el camino especificado y, si existe, devuelve true; de lo contrario, devuelve false.
  14. getLastModifiedTime(Path path, Linkoption… options): Este método devuelve el tiempo de la última modificación de un archivo desde el camino dado como
  15. getOwner(Path path, Linkoption… options): Este método devuelve UserPrincipal que representa al propietario del archivo en el camino dado.
  16. isDirectory(Path path, Linkoption… opciones): Este método verifica si el archivo es un directorio desde la ruta dada. Devuelve true si el archivo es un directorio y false si el archivo no existe o no es un directorio, o si no se puede determinar si el archivo es un directorio o no.
  17. isExecutable(Path path): Este método verifica si el archivo en la ruta dada es ejecutable o no, y también comprueba si el archivo existe y si esta JVM tiene el privilegio adecuado para ejecutar el archivo. Devuelve true si el archivo existe en la ruta dada y es ejecutable, y false si el archivo no existe, la JVM no tiene suficientes privilegios para ejecutar el archivo o no se puede determinar el acceso.
  18. isHidden(Path path): Este método indica si el archivo en la ruta dada se considera oculto o no. La definición exacta de oculto depende del sistema o proveedor. En el caso del sistema UNIX, un archivo se considera oculto si el nombre del archivo comienza con el carácter de punto (‘.’). Y en el caso de WINDOWS, un archivo se considera oculto si no es un directorio y el atributo oculto de DOS está configurado. Devuelve true si el archivo en la ruta dada se considera oculto, de lo contrario, devuelve false.
  19. isReadable(Path path): Este método comprueba si el archivo en la ruta dada es legible o no. Devuelve true si el archivo en la ruta especificada existe y es legible, y false si el archivo no existe o se deniega el acceso de lectura porque la JVM no tiene los privilegios suficientes o no se puede determinar el acceso.
  20. isWritable(Ruta ruta): Este método prueba si el archivo en la ruta especificada es escribible o no. Retorna true si el archivo en la ruta especificada existe y es escribible, y false si el archivo no existe o el acceso de escritura es denegado porque la JVM no tiene suficientes privilegios o no se puede determinar el acceso.
  21. mover(Ruta fuente, Ruta objetivo, OpciónCopia… opciones): Este método mueve o renombra un archivo de origen al archivo de destino y devuelve la ruta del archivo de destino. Los parámetros de opción pueden incluir lo siguiente: REEMPLAZAR_EXISTENTE: Significa que si el archivo de destino existe, lo reemplaza si no es un directorio no vacío. MOVIMIENTO_ATÓMICO: Significa que el movimiento se realiza como una operación atómica del sistema de archivos y se ignoran todas las demás opciones. Este método lanza una ExcepciónArchivoYaExistente si el archivo de destino existe pero no se puede reemplazar porque la opción REEMPLAZAR_EXISTENTE no está especificada. Este método lanza una ExcepciónDirectorioNoVacio si la opción REEMPLAZAR_EXISTENTE está especificada pero el archivo no puede ser reemplazado porque es un directorio no vacío.
  22. nuevoBufferedReader(Ruta ruta, ConjuntoCaracteres cs): Este método abre un archivo usando la ruta dada para lectura, devolviendo un BufferedReader que se utiliza para leer texto del archivo. Los bytes del archivo se decodifican en caracteres usando el conjunto de caracteres especificado.
  23. newBufferedWriter(Path path, Charset cs, Openoption… options): Este método abre o crea un archivo utilizando la ruta proporcionada para escribir, devolviendo BufferedWriter que se utiliza para escribir texto en el archivo. El parámetro options especifica cómo se crea o abre el archivo. Si no se especifica ninguna opción, se consideran las opciones CREATE, TRUNCATE_EXISTING y WRITE de forma predeterminada, lo que significa que abre el archivo para escritura y lo crea si el archivo no existe o trunca el archivo existente al tamaño 0 si existe. Este método lanza UnsupportedOperationException si se especifica una opción no admitida.
  24. newByteChannel(Path path, OpenOption… options): Este método crea o abre el archivo utilizando la ruta especificada, devolviendo un canal de bytes buscable para acceder al archivo. Este método lanza UnsupportedOperationException si se especifica una opción no admitida.
  25. newDirectoryStream(Path path): Este método abre un directorio devolviendo un DirectoryStream para iterar sobre todas las entradas en el directorio desde la ruta especificada. Los elementos devueltos por el iterador de DirectoryStream son de tipo Path y cada uno representa una entrada en el directorio. Este método lanza NotDirectoryException si el archivo en la ruta especificada no se pudo abrir porque no es un directorio.
  26. newDirectoryStream(Path path, Filter<? super Path > filter): Este método abre un directorio devolviendo un DirectoryStream para iterar sobre todas las entradas en el directorio desde la ruta especificada. Los elementos devueltos por el iterador de DirectoryStream son de tipo Path y cada uno representa una entrada en el directorio y estas entradas están filtradas por el filtro especificado. Este método lanza NotDirectoryException si el archivo en la ruta dada no se pudo abrir porque no es un directorio.
  27. newDirectoryStream(Path path, String glob): Este método abre un directorio devolviendo un DirectoryStream para iterar sobre todas las entradas en el directorio desde la ruta especificada. Los elementos devueltos por el iterador de DirectoryStream son de tipo Path y cada uno representa una entrada en el directorio y estas entradas están filtradas por coincidencia con la representación de cadena de sus nombres de archivo contra el patrón de coincidencia especificado. Este método lanza NotDirectoryException si el archivo en la ruta dada no se pudo abrir porque no es un directorio y PatternSyntaxException si el patrón no es válido.
  28. newInputStream(Path path, Openoption… options): Este método abre un archivo devolviendo un flujo de entrada para leer el archivo desde la ruta especificada. El parámetro de opciones determina cómo se abre el archivo y si no se especifican opciones, entonces se abre el archivo con READ. Este método lanza IllegalArgumentException si se especifica una combinación no válida de opciones y UnsupportedOperationException si se especifica una opción no admitida.
  29. newOutputStream(Path path, Openoption… options): Este método abre un archivo devolviendo un flujo de salida para escribir bytes en el archivo en la ruta especificada. El parámetro options determina cómo se abre el archivo y si no se especifica ninguna opción, se consideran las opciones CREATE, TRUNCATE_EXISTING y WRITE de forma predeterminada, lo que significa que abre el archivo para escribir y lo crea si el archivo no existe o trunca el archivo existente al tamaño de 0 si existe. Este método genera una excepción IllegalArgumentException si se especifica una combinación de opciones no válida y una excepción UnsupportedOperationException si se especifica una opción no admitida.
  30. notExists(Path path, LinkOption options): Este método comprueba si el archivo en la ruta especificada no existe. El parámetro options se utiliza para indicar cómo se manejan los enlaces simbólicos si el archivo es un enlace simbólico. De forma predeterminada, se siguen los enlaces simbólicos. Si la opción NOFOLLOW_LINK está presente, entonces los enlaces simbólicos no se siguen. Este método devuelve true si el archivo no existe en la ruta especificada y false si el archivo existe o si no se puede determinar su existencia.
  31. readAllBytes(Path path): Este método lee todos los bytes del archivo en la ruta dada y devuelve la matriz de bytes que contiene los bytes leídos del archivo.
  32. readAllLines(Path path, Charset cs): Este método lee todas las líneas del archivo en la ruta dada y devuelve la Lista que contiene las líneas del archivo.
  33. tamaño(Path ruta): Este método devuelve el tamaño del archivo en la ruta especificada en bytes.
  34. caminarPorÁrbolDeArchivos(Path inicio, FileVisitor<? super Path> visitante): Este método se utiliza para recorrer el directorio. Recorre el directorio en la ruta especificada de forma recursiva y devuelve el archivo inicial.
  35. escribir(Path ruta, byte[] bytes, OpenOption… opciones): Este método escribe bytes en un archivo en la ruta especificada. El parámetro de opciones especifica cómo se crea o abre el archivo. Si no se especifica ninguna opción, se consideran las opciones CREAR, TRUNCAR_EXISTENTE y ESCRIBIR de forma predeterminada, lo que significa que abre el archivo para escribir y lo crea si el archivo no existe o trunca el archivo existente al tamaño de 0 si existe. Todos los bytes en la matriz de bytes se escriben en el archivo. Este método asegura que el archivo se cierre cuando se hayan escrito todos los bytes y devuelve la ruta del archivo escrito.

Crear archivo usando la Clase Files

La clase Files proporciona el método createFile(Path rutaArchivo, FileAttribute<?>… attrs) para crear un archivo usando la Path especificada. Veamos el siguiente ejemplo de programa.

package com.journaldev.examples;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * Java Create file using Files class
 * 
 * @author pankaj
 *
 */
public class FilesCreateFileExample {

	public static void main(String[] args) {
		
		// inicializar objeto Path
		Path path = Paths.get("D:/data/file.txt");
		// crear archivo
		try {
			Path createdFilePath = Files.createFile(path);
			System.out.println("File Created at Path : "+createdFilePath);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

La salida del programa anterior es la siguiente:

File Created at Path : D:\data\file.txt

Crear directorios usando la clase Files

La clase Files proporciona los métodos createDirectory(Path dir, FileAttribute<?>… attrs) y createDirectories(Path dir, FileAttribute<?>… attrs) para crear directorios de un nivel y de varios niveles utilizando el Path especificado. Echemos un vistazo al siguiente programa de ejemplo.

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * Java Create directories using Files class
 * 
 * @author pankaj
 *
 */
public class FilesCreateDirectoriesExample {

	public static void main(String[] args) {
		// inicializar objetos Path
		Path path1 = Paths.get("D:/pankaj");
		Path path2 = Paths.get("D:/pankaj/java7");
		Path path3 = Paths.get("D:/pankaj/java7/Files");
		
		try {
			Path createdDir1 = Files.createDirectory(path1);//first level directory
			Path createdDir2 = Files.createDirectory(path2);//second level directory
			Path createdDir3 = Files.createDirectory(path3);//all level directories
			System.out.println("First Level Directory Created at Path : "+createdDir1);
			System.out.println("Second Level Directory Created at Path : "+createdDir2);
			System.out.println("All Level Directories Created at Path : "+createdDir3);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

La salida del programa anterior es la siguiente:

First Level Directory Created at Path : D:\pankaj
Second Level Directory Created at Path : D:\pankaj\java7
All Level Directories Created at Path : D:\pankaj\java7\Files

Convertir Archivo a Path y Viceversa

Los objetos File y Path pueden convertirse entre sí utilizando los siguientes métodos:

File file = new File(“D:/data/file.txt”);

Path path = file.toPath();

File file1 = path.toFile();

Leer datos de archivo usando la clase Files

La clase Files proporciona los siguientes métodos para leer archivos.

  1. readAllBytes(Path path): Este método lee todos los bytes del archivo en la ruta dada y devuelve el array de bytes que contiene los bytes leídos del archivo.
  2. readAllLines(Path path,Charsetcs): Este método lee todas las líneas del archivo en la ruta especificada y devuelve la Lista que contiene las líneas del archivo.

Echemos un vistazo al siguiente ejemplo de programa.

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

/**
 * Java Files read file example
 * 
 * @author pankaj
 *
 */
public class FilesReadFileExample {

	public static void main(String[] args) {
		
		Path path = Paths.get("D:/data/file.txt");
		try {
			byte[] bs = Files.readAllBytes(path);
			List<String> strings = Files.readAllLines(path);
			
			System.out.println("Read bytes: \n"+new String(bs));
			System.out.println("Read lines: \n"+strings);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

La salida del programa anterior es la siguiente:

Read bytes: 
Hello world
This is Read file example
Thank you
Read lines: 
[Hello world, This is Read file example, Thank you]

Copiar archivo usando la clase Files

La clase Files proporciona el método copy(Path source, Path target, CopyOption… options) que copia el archivo fuente dado al archivo de destino especificado y devuelve la ruta del archivo de destino. Echemos un vistazo al siguiente ejemplo de programa:

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

/**
 * Java Files copy file example
 * 
 * @author pankaj
 *
 */
public class FilesCopyFileExample {

	public static void main(String[] args) {
		Path sourcePath = Paths.get("D:/data/sourceFile.txt");
		Path targetPath = Paths.get("D:/data/targetFile.txt");
		
		try {
			Path path = Files.copy(sourcePath, targetPath,StandardCopyOption.REPLACE_EXISTING);//copy with REPLACE_EXISTING option
			System.out.println("Target file Path : "+path);
			System.out.println("Copied Content : \n"+new String(Files.readAllBytes(path)));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

La salida del programa anterior es la siguiente:

Target file Path : D:\data\targetFile.txt
Copied Content : 
Hello world
This is Copy file example
Thank you

Mover archivo usando la clase Files

La clase Java Files proporciona el método move(Path source, Path target, CopyOption… options) que mueve o renombra un archivo fuente al archivo de destino y devuelve la ruta del archivo de destino. El parámetro de opción puede incluir lo siguiente: REPLACE_EXISTING: Significa que si el archivo de destino existe, lo reemplaza si no es un directorio no vacío. ATOMIC_MOVE: Significa que el movimiento se realiza como una operación de sistema de archivos atómica y se ignoran todas las demás opciones. Este método lanza una FileAleadyExistsException si el archivo de destino existe pero no puede ser reemplazado porque la opción REPLACE_EXISTING no está especificada. Este método lanza una DirectoryNotEmptyException si la opción REPLACE_EXISTING está especificada pero el archivo no puede ser reemplazado porque es un directorio no vacío. Echemos un vistazo al siguiente programa de ejemplo: 

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

/**
 * Java Files move file example
 * 
 * @author pankaj
 *
 */
public class FilesMoveFileExample {

	public static void main(String[] args) {
		Path sourcePath = Paths.get("D:/data/sourceFile.txt");
		Path targetPath = Paths.get("D:/data/targetFile.txt");
		try {
			Path path = Files.move(sourcePath, targetPath,StandardCopyOption.REPLACE_EXISTING);//move with REPLACE_EXISTING option
			System.out.println("Target file Path : "+path);
			System.out.println("Moved Content : \n"+new String(Files.readAllBytes(path)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

Escribir archivo usando la clase Files

La clase Files de Java NIO proporciona el método write(Path path, byte[] bytes, OpenOption… options) que escribe bytes en un archivo en la ruta especificada. El parámetro options especifica cómo se crea o abre el archivo. Si no se especifica ninguna opción, se consideran las opciones CREATE, TRUNCATE_EXISTING y WRITE por defecto. Esto significa que abre el archivo para escribir y lo crea si no existe, o trunca el archivo existente a un tamaño de 0 si existe. Todos los bytes en el array de bytes se escriben en el archivo. Este método asegura que el archivo se cierre cuando se hayan escrito todos los bytes y devuelve la ruta del archivo escrito.

package com.journaldev.examples;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * Java Files write file example
 * 
 * @author pankaj
 *
 */
public class FilesWriteFileExample {

	public static void main(String[] args) {
		Path path = Paths.get("D:/data/test.txt");
		try {
			String str = "This is write file Example";
			byte[] bs = str.getBytes();
			Path writtenFilePath = Files.write(path, bs);
			System.out.println("Written content in file:\n"+ new String(Files.readAllBytes(writtenFilePath)));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

Recorrer el árbol de archivos

La clase Files proporciona el método walkFileTree(Path start, FileVisitor<? Super Path> visitor) que se utiliza para recorrer el directorio. Recorre el directorio en la ruta especificada de forma recursiva y devuelve el archivo de inicio.

package com.journaldev.examples;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;

/**
 * Java Files walk file tree example
 * 
 * @author pankaj
 *
 */
public class FilesWalkFileTreeExample {

	public static void main(String[] args) {
		Path path = Paths.get("D:/pankaj");
		try {
			Files.walkFileTree(path, new FileVisitor<Path>() {

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

				@Override
				public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
					System.out.println("Pre Visit Directory: "+dir);
					return FileVisitResult.CONTINUE;
				}

				@Override
				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
					System.out.println("Visit File: "+file);
					return FileVisitResult.CONTINUE;
				}

				@Override
				public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
					System.out.println("Visit Failed File: "+file);
					return FileVisitResult.CONTINUE;
				}
			});
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

La salida del programa anterior es la siguiente:

Pre Visit Directory: D:\pankaj
Pre Visit Directory: D:\pankaj\java6
Pre Visit Directory: D:\pankaj\java6\Files
Visit File: D:\pankaj\java6\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java6\Files
Post Visit Directory: D:\pankaj\java6
Pre Visit Directory: D:\pankaj\java7
Pre Visit Directory: D:\pankaj\java7\Files
Visit File: D:\pankaj\java7\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java7\Files
Post Visit Directory: D:\pankaj\java7
Pre Visit Directory: D:\pankaj\java8
Pre Visit Directory: D:\pankaj\java8\Files
Visit File: D:\pankaj\java8\Files\file.txt.txt
Post Visit Directory: D:\pankaj\java8\Files
Post Visit Directory: D:\pankaj\java8
Post Visit Directory: D:\pankaj

Observa que todos los archivos y carpetas se procesan de forma recursiva. Esto es muy útil cuando se desea realizar algún procesamiento común en todos los archivos, como cambiar el nombre de todos los archivos en un directorio de forma recursiva. Eso es todo para la clase Files de Java. Referencia: Documentación de la API

Source:
https://www.digitalocean.com/community/tutorials/java-files-nio-files-class