Java Language
Nuevo archivo I / O

Sintaxis

• Paths.get (Cadena primero, Cadena ... más) // Crea una instancia de ruta por sus elementos de cadena
• Paths.get (URI uri) // Crea una instancia de Path por un URI

Creando caminos

La clase de Path se usa para representar de manera programática una ruta en el sistema de archivos (y, por lo tanto, puede apuntar a archivos y directorios, incluso a los que no existen)

Se puede obtener una ruta utilizando las Paths clase auxiliar:

Path p1 = Paths.get("/var/www");
Path p2 = Paths.get(URI.create("file:///home/testuser/File.txt"));
Path p3 = Paths.get("C:\\Users\\DentAr\\Documents\\HHGTDG.odt");
Path p4 = Paths.get("/home", "arthur", "files", "diary.tex");

Recuperar información sobre una ruta

La información sobre una ruta se puede obtener utilizando los métodos de un objeto Path :

• toString() devuelve la representación de cadena de la ruta

  Path p1 = Paths.get("/var/www"); // p1.toString() returns "/var/www"
  

• getFileName() devuelve el nombre del archivo (o, más específicamente, el último elemento de la ruta)

  Path p1 = Paths.get("/var/www"); // p1.getFileName() returns "www"
  Path p3 = Paths.get("C:\\Users\\DentAr\\Documents\\HHGTDG.odt"); // p3.getFileName() returns "HHGTDG.odt"
  

• getNameCount() devuelve el número de elementos que forman la ruta

  Path p1 = Paths.get("/var/www"); // p1.getNameCount() returns 2
  

• getName(int index) devuelve el elemento en el índice dado

  Path p1 = Paths.get("/var/www"); // p1.getName(0) returns "var", p1.getName(1) returns "www"
  

• getParent() devuelve la ruta del directorio padre

  Path p1 = Paths.get("/var/www"); // p1.getParent().toString() returns "/var"
  

• getRoot() devuelve la raíz de la ruta

  Path p1 = Paths.get("/var/www"); // p1.getRoot().toString() returns "/"
  Path p3 = Paths.get("C:\\Users\\DentAr\\Documents\\HHGTDG.odt"); // p3.getRoot().toString() returns "C:\\"
  

Manipulando caminos

Unirse a dos caminos

Las rutas se pueden unir usando el método resolve() . La ruta pasada tiene que ser una ruta parcial, que es una ruta que no incluye el elemento raíz.

Path p5 = Paths.get("/home/");
Path p6 = Paths.get("arthur/files");
Path joined = p5.resolve(p6);
Path otherJoined = p5.resolve("ford/files");

joined.toString() == "/home/arthur/files"
otherJoined.toString() == "/home/ford/files"

Normalizando un camino

Los caminos pueden contener los elementos . (que apunta al directorio en el que se encuentra actualmente) y .. (que apunta al directorio principal).

Cuando se usa en un camino, . puede eliminarse en cualquier momento sin cambiar el destino de la ruta, y .. puede eliminarse junto con el elemento anterior.

Con la API de rutas, esto se hace usando el método .normalize() :

Path p7 = Paths.get("/home/./arthur/../ford/files");
Path p8 = Paths.get("C:\\Users\\.\\..\\Program Files");

p7.normalize().toString() == "/home/ford/files"
p8.normalize().toString() == "C:\\Program Files"

Recuperando información utilizando el sistema de archivos.

Para interactuar con el sistema de archivos, utilice los métodos de la clase Files .

Comprobando la existencia

Para verificar la existencia del archivo o directorio al que apunta una ruta, utilice los siguientes métodos:

Files.exists(Path path)

y

Files.notExists(Path path)

!Files.exists(path) no necesariamente tiene que ser igual a Files.notExists(path) , porque hay tres escenarios posibles:

• Se verifica la existencia de un archivo o directorio ( exists devuelve true y notExists devuelve false en este caso)
• La inexistencia de un archivo o directorio se verifica ( exists devuelve false y notExists devuelve true )
• No se puede verificar la existencia ni la inexistencia de un archivo o un directorio (por ejemplo, debido a restricciones de acceso): ambos exists y los que no nonExists devuelven falso.

Comprobando si una ruta apunta a un archivo o directorio

Esto se hace usando Files.isDirectory(Path path) y Files.isRegularFile(Path path)

Path p1 = Paths.get("/var/www");
Path p2 = Paths.get("/home/testuser/File.txt");

Files.isDirectory(p1) == true
Files.isRegularFile(p1) == false

Files.isDirectory(p2) == false
Files.isRegularFile(p2) == true

Obteniendo propiedades

Esto se puede hacer usando los siguientes métodos:

Files.isReadable(Path path)
Files.isWritable(Path path)
Files.isExecutable(Path path)

Files.isHidden(Path path)
Files.isSymbolicLink(Path path)

Obteniendo el tipo MIME

Files.probeContentType(Path path)

Esto intenta obtener el tipo MIME de un archivo. Devuelve una cadena tipo MIME, como esta:

• text/plain para archivos de texto
• text/html para páginas HTML
• application/pdf para archivos PDF
• image/png para archivos PNG

Archivos de lectura

Los archivos se pueden leer en bytes y en línea usando la clase Files .

Path p2 = Paths.get(URI.create("file:///home/testuser/File.txt"));
byte[] content = Files.readAllBytes(p2);
List<String> linesOfContent = Files.readAllLines(p2);

Files.readAllLines() opcionalmente toma un conjunto de caracteres como parámetro (el valor predeterminado es StandardCharsets.UTF_8 ):

List<String> linesOfContent = Files.readAllLines(p2, StandardCharsets.ISO_8859_1);

Escribiendo archivos

Los archivos se pueden escribir de forma mordida y lineal utilizando la clase Files

Path p2 = Paths.get("/home/testuser/File.txt");
List<String> lines = Arrays.asList(
    new String[]{"First line", "Second line", "Third line"});

Files.write(p2, lines);

Files.write(Path path, byte[] bytes)

Los archivos existentes se anularán, se crearán archivos no existentes.