NIO.2 OCP - En.es PDF

E / S de archivos Java (NIO.
2)
Cubrimos los fundamentos de E / S en el último capítulo, donde aprendió a leer y escribir desde la consola y cómo usar secuencias para leer y escribir en
archivos. En este capítulo, aprenderá cómo trabajar con sistemas de archivos, por ejemplo, cómo guardar un archivo / directorio; crear un archivo / directorio;
navegar directorios; copiar, mover o eliminar un archivo / directorio; y así. Como programador de Java, debe saber cómo lograr programáticamente estas
operaciones de archivo / directorio.
Java ofrece un amplio conjunto de API para manipular archivos y directorios. De hecho, Java 7 presenta un nuevo conjunto de API de E / S llamado NIO.2 que ofrecen
formas convenientes de realizar operaciones relacionadas con un sistema de archivos. En este capítulo, explorará cómo realizar diversas operaciones de archivo, como crear,
mover, copiar y eliminar. También aprenderá cómo buscar archivos en una estructura de directorios y cómo obtener / establecer propiedades de archivos / directorios.
Un historial rápido de las API de E / S

Inicialmente, Java ofreció Expediente clase (en el java.io paquete) para acceder a los sistemas de archivos. Esta clase representa un archivo / directorio en el sistema de
archivos y le permite realizar operaciones como verificar la existencia de un archivo / directorio, obtener las propiedades y eliminar un archivo / directorio. Sin embargo, la
primera versión de la API no fue suficiente para satisfacer las necesidades de los desarrolladores, y se sintió la necesidad de mejorar las API de E / S. En resumen, se
notaron las siguientes deficiencias en la primera versión de las API de E / S de Java:
• los Clase de archivo carecía de la importante funcionalidad requerida para implementar incluso la funcionalidad de uso común.
Por ejemplo, le faltaba un Copiar Método para copiar un archivo / directorio.
251
Capítulo 9 ■ E / S de archivos Java (NiO.2)
• los Expediente clase definió muchos métodos que devolvieron un Booleano valor. Por lo tanto, en caso de error, falso fue
devuelto, en lugar de lanzar una excepción, por lo que el desarrollador no tenía forma de saber por qué falló esa llamada.
• los Expediente La clase no proporcionó un buen soporte para manejar enlaces simbólicos.
• los Expediente La clase manejaba directorios y rutas de una manera ineficiente (no se escalaba bien).
• los Expediente La clase proporcionó acceso a un conjunto muy limitado de atributos de archivo, que era insuficiente en muchas situaciones.
Para superar estos problemas, Java introdujo NIO (nuevo IO) en Java 4. Las características clave de NIO fueron:
• Canales y Selectores: NIO ofreció soporte para varios tipos de canales UNA canal es una abstracción sobre las características del sistema de
archivos de nivel inferior (como archivos mapeados en memoria y bloqueo de archivos) que le permite transferir datos a una velocidad más
rápida. Los canales no bloquean, por lo que Java proporciona otra característica: un selector —Para seleccionar un canal listo para la
transferencia de datos. UNA enchufe es una función de bloqueo, mientras que un canal es una función sin bloqueo.
• Tampones: Java 4 introdujo el almacenamiento en búfer para todas las clases primitivas (excepto para Booleano). Proporcionó el Buffer
clase que ofrece operaciones como borrar, voltear, marcar, restablecer, y rebobinar. Clases concretas (subclases de la Buffer clase
base) ofrece getters y setters para configurar y obtener datos hacia y desde un búfer.
• Juego de caracteres: Java 4 también introdujo charset ( java.nio.charset), codificadores y decodificadores para asignar bytes y símbolos
Unicode.
Con la versión SE 7, Java ha introducido un soporte integral para las operaciones de E / S. Java 7 presenta el
java.nio.file paquete para un mejor soporte para el manejo de enlaces simbólicos, para proporcionar un acceso completo a los atributos y para soportar el
sistema de archivos extendido a través de interfaces o clases como Camino, caminos, y Archivos. Explorará estos temas con más detalle en el resto de este
capítulo.
Usando la interfaz de ruta

Los sistemas de archivos generalmente forman un árbol. El sistema de archivos comienza con un directorio raíz que contiene archivos y directorios (los directorios también
se denominan carpetas en Windows) Cada directorio, a su vez, puede tener subdirectorios o archivos de retención. Para localizar un archivo, solo necesita juntar los
directorios desde el directorio raíz hasta el directorio inmediato que contiene el archivo, junto con un separador de archivos, siguiendo el nombre del archivo. Por ejemplo,
si el myfile.txt el archivo reside en un mydocs directorio, que reside en el directorio raíz C:\, entonces la ruta del archivo es C: \ mydocs \ myfile.txt. Cada archivo tiene una
ruta única para ubicarlo (aparte de los enlaces simbólicos).
Un camino podría ser un camino absoluto ( como C: \ mydocs \ myfile.txt), que comienza desde un elemento raíz. Por otro lado, una ruta podría
especificarse como camino relativo. Cuando intentas compilar un programa Java, simplemente escribes algo como javac programFileName.java; aquí, ha
especificado la ruta del archivo fuente de Java en relación con el directorio seleccionado actualmente, por lo que esta ruta es relativa. Necesita una ruta de
referencia (como la ruta actual del directorio en este caso) para interpretar una ruta relativa.
Antes de continuar, es importante hablar sobre enlaces simbólicos. Un enlace simbólico es como un puntero o referencia para el archivo real. En general, los
enlaces simbólicos son transparentes para las aplicaciones, lo que significa que las operaciones se realizan directamente en los archivos reales en lugar de estos enlaces
(excepto, por supuesto, para las operaciones específicas de enlaces simbólicos).
252
Java 7 presenta una nueva abstracción de programación para la ruta, a saber, el Camino interfaz. Esta Camino La abstracción se utiliza en nuevas funciones y
API en NIO.2, por lo que es una interfaz importante para comprender. Un objeto de ruta contiene los nombres de directorios y archivos que conforman la ruta
completa del archivo / directorio representado por Camino objeto; la Camino
abstraction proporciona métodos para extraer elementos de ruta, manipularlos y agregarlos. De hecho, verá más adelante que casi todos los métodos que
acceden a archivos / directorios para obtener información sobre ellos o manipularlos usan
Camino objetos. Antes de ver algunos ejemplos que ilustran cómo usar el Camino interfaz, tabla 9-1 resume rápidamente métodos importantes en
esta interfaz.
Tabla 9-1. Métodos importantes en la interfaz de ruta
Método Descripción
Ruta getRoot () Devuelve un Camino objeto que representa la raíz de la ruta dada, o nulo
si la ruta no tiene una raíz.
Ruta getFileName () Devuelve el nombre del archivo o el nombre del directorio de la ruta dada. Tenga en cuenta que el
nombre del archivo / directorio es el último elemento o nombre en la ruta dada.
Ruta getParent () Devuelve el Camino objeto que representa el padre de la ruta dada, o nulo si
no existe un componente padre para la ruta.
int getNameCount () Devuelve el número de nombres de archivo / directorio en la ruta dada;

devuelve 0 si la ruta dada representa la raíz.
Ruta getName (int index) Devuelve el i th nombre de archivo / directorio; el índice 0 comienza desde el nombre más
cercano a la raíz.
Ruta subruta (int beginIndex, int endIndex) Devuelve un Camino objeto que es parte de esto Camino objeto; la
regresado Camino objeto tiene un nombre que comienza en beginIndex
hasta que el elemento en el índice endIndex - 1. En otras palabras,
beginIndex incluye el nombre en ese índice y excluye el nombre en endIndex.
Este método puede arrojar
Argumento de excepción ilegal si beginIndex es> = número de elementos, o
endIndex <= beginIndex, o endIndex es> número de elementos.
Ruta normalizar () Elimina elementos redundantes en la ruta como. (símbolo de punto que indica el
directorio actual) y .. (símbolo de doble punto que indica el directorio principal).
Ruta resuelta (otra ruta) Ruta resuelta Resuelve una ruta contra la ruta dada. Por ejemplo, este método podría
(otra cadena) combinar la ruta dada con la otra ruta y devolver la ruta resultante.
Boolean isAbsolute () Devuelve verdadero si la ruta dada es una ruta absoluta; devuelve falso si no
(cuando la ruta dada es una ruta relativa, por ejemplo).
La ruta comienza con (ruta de cadena) La ruta Devuelve verdadero si esto Camino el objeto comienza con lo dado camino o
comienza con (ruta de ruta) más devuelve falso.
Camino a AbsolutePath () Devuelve la ruta absoluta.

253
Obteniendo información de ruta

Vamos a crear un Camino objetar y recuperar la información básica asociada con el objeto. El Listado 9-1 muestra cómo crear un Camino objetar y
obtener información al respecto.
Listado 9-1. PathInfo1.java
import java.nio.file. *;
// Clase para ilustrar cómo usar la interfaz Path y sus métodos public class PathInfo1 {
public static void main (String [] args) {

// crea un objeto Path llamando al método estático get () en la clase Paths Path testFilePath =
Paths.get ("D: \\ test \\ testfile.txt");
// recupera información básica sobre la ruta System.out.println ("Imprimiendo información del archivo:");
System.out.println ("\ t nombre de archivo:" + testFilePath.getFileName ()); System.out.println ("\ t raíz de la
ruta:" + testFilePath.getRoot ()); System.out.println ("\ t padre del destino:" + testFilePath.getParent ());
// imprimir elementos de ruta

System.out.println ("Imprimir elementos de la ruta:"); for (Elemento de ruta:
testFilePath) {
System.out.println ("\ t elemento de ruta:" + elemento); }}}
El programa imprime lo siguiente:
Imprimir información del archivo:

nombre de archivo: testfile.txt raíz de la
ruta: D: \ padre del destino: D: \ test
Elementos de impresión de la ruta:
elemento de ruta: prueba elemento de

ruta: testfile.txt
La salida se explica por sí misma. Vamos a entender el programa.
• Primero, creas un Camino instancia utilizando el obtener() método de la Rutas clase. los obtener() método espera un cuerda representando
una ruta como entrada. Esta es la forma más fácil de crear un Camino
objeto.
• Tenga en cuenta que utiliza un carácter de escape, \, en Paths.get ("D: \\ test \\ testfile.txt").
Sin eso, \ t significaría un carácter de tabulación, y si ejecuta el programa, obtendrá un
java.nio.file.InvalidPathException ya que no puede tener caracteres de tabulación en los nombres de ruta.
• Luego, extrae el nombre de archivo representado por este Camino objeto usando el getFilename ()
método de la Camino objeto.
• También usas getRoot () para obtener el elemento raíz de la Camino objeto y directorio principal del archivo de destino
utilizando el getParent () método.
254
• Usted itera los elementos en la ruta usando un para cada lazo. Alternativamente, puedes usar
getNameCount () para obtener el número de elementos o nombres en la ruta y usar getName (índice)
iterar y acceder a elementos / nombres uno por uno.
Ahora, intentemos con otro ejemplo. En este ejemplo, explorará algunos aspectos interesantes de un Camino objeto como cómo obtener una ruta
absoluta de una ruta relativa y cómo puede normalizar un sendero.
Antes de ver el ejemplo, primero debe comprender los métodos utilizados en el ejemplo:
• El toUri () El método devuelve el URI (una ruta que se puede abrir desde un navegador) desde la ruta.
• El toAbsolutePath () El método devuelve la ruta absoluta desde una ruta relativa dada. En caso de que la ruta de
entrada ya sea una ruta absoluta, el método devuelve el mismo objeto.
• los normalizar() El método realiza la normalización en la ruta de entrada. En otras palabras, elimina
símbolos innecesarios (como "." Y "..") del Camino objeto.
• toRealPath () Es un método interesante. Devuelve una ruta absoluta desde el objeto de ruta de entrada (como toAbsolutePath ()). Además,
normaliza la ruta (como en normalizar()). Además, si las opciones de enlace se eligen correctamente, también resuelve los enlaces
simbólicos. Sin embargo, para tener éxito con este método, es necesario que el archivo / directorio de destino exista en el sistema de
archivos, que es no un requisito previo para otro Camino métodos.
Ahora, echemos un vistazo al ejemplo en el Listado 9-2. Suponga que el nombre del archivo Prueba no existe en su sistema de archivos.
Listado 9-2. PathInfo2.java
import java.io.IOException; import

java.nio.file. *;
// Para ilustrar métodos importantes como normalize (), toAbsolutePath () y toReativePath () class PathInfo2 {
public static void main (String [] args) lanza IOException {

// obtener un objeto de ruta con ruta relativa Ruta
testFilePath = Paths.get (". \\ Test");
System.out.println ("El nombre del archivo es:" + testFilePath.getFileName ()); System.out.println ("Su URI es:"
+ testFilePath.toUri ()); System.out.println ("Su ruta absoluta es:" + testFilePath.toAbsolutePath ());
System.out.println ("Su ruta normalizada es:" + testFilePath.normalize ());
// obtener otro objeto de ruta con ruta relativa normalizada Ruta testPathNormalized = Paths.get
(testFilePath.normalize (). toString ()); System.out.println ("Su ruta absoluta normalizada es:" +
testPathNormalized.toAbsolutePath ());
System.out.println ("Su ruta real normalizada es:" +
testFilePath.toRealPath (LinkOption.NOFOLLOW_LINKS));
}}
En nuestra máquina imprimió lo siguiente:
El nombre del archivo es: Prueba
Su URI es: archivo: /// D: /OCPJP7/programs/NIO2/./Test Su ruta absoluta

es: D: \ OCPJP7 \ programs \ NIO2 \. \ Test Su ruta normalizada es: Test
255
Su ruta absoluta normalizada es: D: \ OCPJP7 \ programs \ NIO2 \ Test

Excepción en el hilo "principal" java.nio.file.NoSuchFileException: D: \ OCPJP7 \ programs \ NIO2 \ Test
en sun.nio.fs.WindowsException.translateToIOException (WindowsException.java:79) [. . . seguimiento de pila
elidido. . .] en PathInfo2.main (PathInfo2.java:16)
Dependiendo del directorio en el que ejecute este programa, la ruta del directorio será diferente para usted. En este programa creaste una instancia Camino
objeto utilizando una ruta relativa. El método getFileName () devuelve el nombre del archivo de destino, como acaba de ver en el último ejemplo. los getUri () El
método devuelve el URI, que se puede usar con navegadores, y el toAbsolutePath () El método devuelve la ruta absoluta de la ruta relativa dada. (Tenga en
cuenta que estamos ejecutando el programa desde " D: / OCPJP7 / programas / NIO2 / " carpeta, por lo tanto, se convierte en el directorio de trabajo actual y,
por lo tanto, aparece en la ruta absoluta y el URI).
Llamas al normalizar() método para eliminar símbolos redundantes de la ruta, por lo que el normalizar() El método elimina el punto inicial (en
muchos sistemas operativos, el símbolo “.” (punto único) representa el directorio actual y “..” (punto doble) representa el directorio principal). Luego
instancias otro Camino objeto utilizando salida normalizada e imprima la ruta absoluta de nuevo. Finalmente, intentas llamar toRealpath (); sin embargo,
obtienes una excepción ( NoSuchFileException).
¿Por qué? Porque no has creado el Prueba directorio en el directorio de trabajo actual.
Ahora, creemos un Prueba directorio en la D: / OCPJP7 / programas / NIO2 / directorio y ejecute este ejemplo nuevamente. Tenemos el siguiente
resultado:
El nombre del archivo es: Prueba
Su URI es: archivo: /// D: /OCPJP7/programs/NIO2/./Test/ Su ruta absoluta

es: D: \ OCPJP7 \ programs \ NIO2 \. \ Test Su ruta normalizada es: Prueba
Su ruta absoluta normalizada es: D: \ OCPJP7 \ programs \ NIO2 \ Test. Su ruta real
normalizada es: D: \ OCPJP7 \ programs \ NIO2 \ Test.
Ahora la ultima llamada toRealPath () funciona bien y devuelve la ruta normalizada absoluta.
Camino proporciona muchos otros métodos útiles, y algunos de ellos se enumeran en la Tabla 9-1 . Para dar un ejemplo, aquí hay
cómo usar el resolver() método:
Ruta dirName = Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\"); Ruta

resueltaPath = dirName.resolve ("Prueba"); System.out.println (resolvePath);
Este segmento de código imprime lo siguiente:
D: \ OCPJP7 \ programas \ NIO2 \ Test
Esta resolver() El método considera que la ruta dada es un directorio y une (es decir, resuelve) la ruta pasada con ella, como se muestra en este
ejemplo.
la toPath () método en el java.io.File clase devuelve el Camino objeto; este método se agregó en Java 7. De manera similar, puede
usar el archivar() método en el Camino interfaz para obtener un Expediente objeto.
256
Comparar dos caminos
El camino La interfaz proporciona dos métodos para comparar dos Camino objetos: es igual a () y comparar con(). los es igual a ()
método comprueba la igualdad de dos Camino objetos y devuelve un Booleano valor cuando comparar con() compara dos Camino
objetos carácter por carácter y devuelve un entero: 0 si ambos Camino los objetos son iguales; un entero negativo si esta ruta es lexicográficamente menor
que la ruta del parámetro; y un entero positivo si esta ruta es lexicográficamente mayor que la ruta del parámetro.
El Listado 9-3 contiene un pequeño programa para comprender estos métodos.
Listado 9-3. PathCompare1.java
// ilustra cómo usar compareTo y equals y también muestra la diferencia entre los dos métodos de la clase PathCompare1 {

Ruta path1 = Paths.get ("Prueba");
Ruta path2 = Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\ Test"); // comparar dos
rutas utilizando el método compareTo ()
System.out.println ("(path1.compareTo (path2) == 0) es:" + (path1.compareTo (path2) == 0));
// comparando dos caminos usando el método equals ()

System.out.println ("path1.equals (path2) es:" + path1.equals (path2));
// comparar dos rutas usando el método equals () con la ruta absoluta System.out.println
("path2.equals (path1.toAbsolutePath ()) es"
+ path2.equals (path1.toAbsolutePath ()));
}}
Intencionalmente, hemos tomado una ruta como ruta relativa y otra como ruta absoluta. ¿Puedes adivinar la salida del
programa? Imprimió lo siguiente:
(path1.compareTo (path2) == 0) es: false path1.equals

(path2) es: false
path2.equals (path1.toAbsolutePath ()) es verdadero
Comprendamos el programa paso a paso.
• Primero compara dos caminos usando el comparar con() , que compara las rutas carácter por carácter y devuelve
un entero. En este caso, dado que una ruta es relativa y otra es absoluta, se espera obtener primero un mensaje
que indique que ambas rutas no son iguales.
• Luego comparas ambas rutas usando es igual a (). El resultado es el mismo, lo que significa que incluso si dos Camino los
objetos apuntan al mismo archivo / directorio, es posible que es igual a () devuelve falso Debe asegurarse de que ambas
rutas sean rutas absolutas.
• En el siguiente paso, convierte la ruta relativa en una ruta absoluta y luego la compara usando es igual a (). Esta vez
ambos caminos coinciden.
257
incluso si dos Camino los objetos apuntan al mismo archivo / directorio, no está garantizado que obtendrá la verdad del es igual a () método.
Debe asegurarse de que ambas sean rutas absolutas y normalizadas para que una comparación de igualdad tenga éxito en las rutas.
Usando la clase de archivos

La sección anterior discutió cómo crear un Camino instancia y extraer información útil de ella. Ahora usarás
Camino objetos para manipular archivos / directorios. Java 7 ofrece un nuevo Archivos clase (en el java.nio.file paquete) que puede usar para realizar varias operaciones
relacionadas con archivos en archivos o directorios. Tenga en cuenta que Archivos es una clase de utilidad, lo que significa que es una clase final con un constructor privado y
consta solo de métodos estáticos. Para que pueda utilizar el Archivos clase llamando a los métodos estáticos que proporciona, como Copiar() para copiar archivos Esta clase
proporciona una amplia gama de funcionalidades. Con esta clase puede crear directorios, archivos o enlaces simbólicos; crear secuencias como secuencias de directorio,
canales de bytes o secuencias de entrada / salida; examinar los atributos de los archivos; caminar por el árbol de archivos; o realizar operaciones de archivo como leer,
escribir, copiar o eliminar. Mesa 9-2 proporciona una muestra de los métodos importantes en el Archivos clase.
Tabla 9-2. Algunos métodos relacionados con los atributos de archivo en la clase de archivos
Ruta createDirectory (Ruta dirPath, FileAttribute Crea un archivo dado por el dirPath, y establece los atributos
<?>... DirAttrs) dados por dirAttributes. Puede lanzar excepciones como FileAlreadyExistsException
Ruta createDirectories (ruta dir, FileAttribute

o UnsupportedOperationException ( por ejemplo, cuando los atributos del archivo
<?>... Attrs)
no se pueden establecer como se indica en dirAttrs).
La diferencia entre crear directorio y

createDirectories es eso createDirectories crea directorios
intermedios dados por dirPath si aún no están presentes
Ruta createTempFile (directorio de ruta, prefijo de cadena, sufijo de Crea un archivo temporal con prefijo, sufijo y atributos dados en el
cadena, atributo de archivo <?>.. .Trs) directorio proporcionado por dir.
Path createTempDirectory (directorio de ruta, prefijo de Crea un directorio temporal con el prefijo dado, los atributos del
cadena, atributo de archivo <?>.. .Trs) Copia de ruta (fuente de directorio en la ruta especificada por dir.
ruta, destino de ruta, opciones de copia...) Copie el archivo de origen a destino. CopyOption podría ser
REPLACE_EXISTING, COPY_ATTRIBUTES o NOFOLLOW_LINKS.
Puede lanzar excepciones como
FileAlreadyExistsException.
Movimiento de ruta (origen de ruta, destino de ruta, Similar a la operación de copia, excepto que se elimina el archivo fuente; si el
opciones de copia...) origen y el destino están en el mismo directorio, es una operación de cambio de
nombre de archivo.
boolean isSameFile (Path path, Path path2) Comprueba si los dos Camino Los objetos se encuentran en el mismo archivo o no.
existe un valor booleano (ruta de acceso, Comprueba si existe un archivo / directorio en la ruta dada; puede especificar
opciones de enlace... opciones) LinkOption.NOFOLLOW_LINKS para no seguir enlaces simbólicos.
( continuado)
258
Tabla 9-2. ( continuado)
Boolean isRegularFile (ruta de acceso, Devuelve verdadero si el archivo representado por la ruta es un archivo
LinkOption...) normal.
Boolean isSymbolicLink (ruta de acceso de ruta) Devuelve verdadero si el archivo presentado por ruta es un enlace
simbólico.
Boolean isHidden (ruta de acceso de ruta) Devuelve verdadero si el archivo representado por la ruta es un archivo
oculto.
tamaño largo (ruta de acceso) Devuelve el tamaño del archivo en bytes representados por la ruta.
UserPrincipal getOwner (ruta de acceso, LinkOption...), Ruta setOwner Obtiene / establece el propietario del archivo.
(ruta de acceso, propietario de UserPrincipal) FileTime

getLastModifiedTime (ruta de acceso, LinkOption...), Ruta Obtiene / establece el último tiempo modificado para el tiempo especificado.
setLastModifiedTime (ruta de acceso, tiempo de FileTime)
Object getAttribute (ruta de acceso, atributo de cadena, Obtiene / establece el atributo especificado del archivo especificado.
LinkOption...), Ruta setAttribute (ruta de acceso, atributo de cadena,

valor de objeto, LinkOption...)
Comprobación de propiedades de archivo y metadatos

En la última sección sobre el Camino interfaz, trató de averiguar si dos rutas apuntan al mismo archivo o no (consulte el Listado 9-3). Hay
otra forma de descubrir lo mismo. Puedes usar el isSameFile () método de la
Archivos clase. El listado 9-4 muestra cómo hacerlo.
Listado 9-4. PathCompare2.java

java.nio.file. *;
// ilustra cómo usar la clase File para comparar dos rutas class PathCompare2 {
public static void main (String [] args) lanza IOException {

Ruta path1 = Paths.get ("Prueba");
Ruta path2 = Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\ Test");
System.out.println ("Files.isSameFile (path1, path2) es:"

+ Files.isSameFile (ruta1, ruta2));
}}
El programa imprime lo siguiente:
Files.isSameFile (ruta1, ruta2) es: verdadero
En este caso, crea el Prueba directorio en el camino D: \ OCPJP7 \ programas \ NIO2 \ Y funcionó bien. Sin embargo, si el Prueba el archivo /
directorio no existe en la ruta dada, obtendrá un NoSuchFileException. Pero, ¿cómo puede averiguar si existe un archivo / directorio en la ruta
dada? los Archivos la clase ofrece el existe () método para hacer eso.
259
De hecho, puede distinguir entre un archivo y un directorio utilizando otro método llamado isDirectory () desde el Archivos
clase. El Listado 9-5 usa estos métodos.
Listado 9-5. PathExists.java
clase PathExists {
Path path = Paths.get (args [0]);
if (Files.exists (ruta, LinkOption.NOFOLLOW_LINKS)) {

System.out.println ("El archivo / directorio" + ruta.getFileName () + "existe"); // comprueba si es un archivo o
un directorio if (Files.isDirectory (ruta, LinkOption.NOFOLLOW_LINKS)) {
System.out.println (path.getFileName () + "es un directorio");

} más {
System.out.println (path.getFileName () + "es un archivo");

}
} más {
System.out.println ("El archivo / directorio" + ruta.getFileName () + "no existe"); }}}
En este programa, está aceptando un nombre de archivo / directorio desde la línea de comando y está creando un Camino objeto. Entonces, estás
usando el existe () método de la Archivos clase para averiguar si el archivo / directorio existe o no. El segundo parámetro de la existe () El método es la
opción de enlace, que se utiliza para especificar si desea seguir enlaces simbólicos o no; en este caso, no estás siguiendo enlaces simbólicos. Si el
archivo / directorio asociado con la ruta de entrada existe, entonces está verificando si la ruta de entrada indica un archivo o un directorio utilizando isDirectory
()
método de la Archivos clase.
Ejecutamos este programa con dos argumentos de línea de comando diferentes y obtuvimos el siguiente resultado:
D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists PathExists.java El archivo /

directorio PathExists.java existe PathExists.java es un archivo
D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists D: \ OCPJP7 \ El archivo /

directorio OCPJP7 existe OCPJP7 es un directorio
D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists D: \ El

archivo / directorio nulo existe nulo es un directorio
En estas salidas, es posible que haya notado el comportamiento cuando el nombre raíz (nombre de la unidad en Windows en este caso) se proporciona como
argumento. Un nombre raíz es un directorio, pero path.getFileName () devuelve nulo si la ruta es un nombre raíz, de ahí el resultado.
260
Es posible que los archivos existentes no le permitan leer, escribir o ejecutar según sus credenciales. Puede verificar la capacidad de un programa
para leer, escribir o ejecutar mediante programación. los Archivos clase proporciona los métodos isReadable (), isWriteable (), y isExecutable () Para hacer
eso. El Listado 9-6 usa estos métodos en un pequeño ejemplo.
Listado 9-6. FilePermissions.java
clase FilePermissions {
Path path = Paths.get (args [0]);
System.out.printf ("Legible:% b, Escribible:% b, Ejecutable:% b",
Files.isReadable (ruta), Files.isWritable (ruta), Files.isExecutable (ruta));
}}
Ejecutemos este programa con dos entradas diferentes; Aquí está la salida:
D: \ OCPJP7 \ programas \ NIO2 \ src> java FilePermissions readonly.txt Legible: verdadero,

Escribible: falso, Ejecutable: verdadero
D: \ OCPJP7 \ programas \ NIO2 \ src> java FilePermissions FilePermissions.java Legible: verdadero,
Escribible: verdadero, Ejecutable: verdadero
Para el readonly.txt archivo, los permisos son legibles y ejecutables, pero no editables. El archivo
FilePermissions.java tiene los tres permisos: legible, de escritura y ejecutable.
Existen muchos otros métodos que se pueden usar para obtener las propiedades del archivo. Usemos el getAttribute () Método para obtener algunos atributos de
un archivo. El método toma un número variable de parámetros: primero, un Camino objeto; segundo, un nombre de atributo; y posteriormente, las opciones de enlace (ver
Listado 9-7).
Listado 9-7. FileAttributes.java

java.nio.file. *;
class FileAttributes {
Path path = Paths.get (args [0]); tratar {
Object object = Files.getAttribute (ruta, "creationTime",

LinkOption.NOFOLLOW_LINKS);
System.out.println ("Tiempo de creación:" + objeto);
object = Files.getAttribute (ruta, "lastModifiedTime",

LinkOption.NOFOLLOW_LINKS);
System.out.println ("Última hora de modificación:" + objeto);
object = Files.getAttribute (ruta, "tamaño", LinkOption.NOFOLLOW_LINKS); System.out.println

("Tamaño:" + objeto);
object = Files.getAttribute (ruta, "dos: hidden", LinkOption.NOFOLLOW_LINKS); System.out.println

("isHidden:" + objeto);
261
object = Files.getAttribute (ruta, "isDirectory", LinkOption.NOFOLLOW_LINKS); System.out.println

("isDirectory:" + objeto); } catch (IOException e) {
e.printStackTrace ();
}}}
Primero ejecutemos este programa dando el nombre de este programa y luego veamos qué sucede:
D: \> java FileAttributes FileAttributes.java Tiempo de creación:

2012-10-06T10: 20: 10.34375Z Última hora de modificación:
2012-10-06T10: 21: 54.859375Z Tamaño: 914
isHidden: false isDirectory:

false
La parte difícil del ejemplo es el segundo parámetro de la getAttribute () método. Debe proporcionar un nombre de atributo
correcto para extraer el valor asociado. La cadena esperada debe especificarse en
vista: atributo formato, donde view es el tipo de FileAttributeView y atributo es el nombre del atributo admitido por view. Si no se especifica ninguna
vista, la vista se asume como básico. En este caso, especificó todos los atributos que pertenecen a un básico ver excepto un atributo de dos ver. Si
no especifica el nombre de vista correcto, obtendrá un UnsupportedOperationException, y si te equivocas con el nombre del atributo, obtendrás un
Argumento de excepción ilegal.

Por ejemplo, si escribe tamaño en lugar de tamaño, obtendrá esta excepción:
Excepción en el hilo "principal" java.lang.IllegalArgumentException: 'tamaño' no reconocido [. . . seguimiento de pila

elidido. . . ]
Bueno, ahora sabes cómo leer metadatos asociados con archivos usando el getAttribute () método. Sin embargo, si desea leer muchos
atributos de una sola vez, llame al getAttribute () El método para cada atributo podría no ser una buena idea (desde el punto de vista del rendimiento).
En este caso, Java 7 ofrece una solución: una API: readAttributes () - para leer los atributos de una sola vez. La API viene en dos sabores:
Map <String, Object> readAttributes (ruta de acceso, atributos de cadena, opciones de enlace ... opciones)
<A extiende BasicFileAttributes> A readAttributes (ruta de acceso, tipo de clase <A>, opciones de enlace...)
El primer método devuelve un Mapa de pares de valores de atributos y toma parámetros de longitud variable. los atributos
El parámetro es el parámetro clave donde necesita especificar lo que desea recuperar. Este parámetro es similar a lo que usó en el getAttribute () método; sin
embargo, aquí puede especificar una lista de atributos que desee, y también puede usar '*' para especificar todos los atributos. Por ejemplo, usando "*" significa
todos los atributos del valor predeterminado FileAttributeView, como
BasicFileAttributes ( especificado como atributos de archivo básicos). Otro ejemplo es: dos: *, que se refiere a todos los atributos de los atributos del archivo DOS.
El segundo método utiliza la sintaxis genérica (Capítulo 6). El segundo parámetro aquí toma una clase del
BasicFileAttributes jerarquía. Hablaremos de la jerarquía en breve. El método devuelve una instancia del
BasicFileAttributes jerarquía.
La jerarquía de atributos del archivo se muestra en la Figura 9-1 . los BasicFileAttributes es la interfaz base desde la cual
DosFileAttributes y PosixFileAttributes son derivados. Tenga en cuenta que estas interfaces de atributos se proporcionan en
java.nio.file.attribute paquete.
262
BasicFileAttributes
DosFileAttributes PosixFileAttributes
Figura 9-1. La jerarquía de BasicFileAttributes
Como puedes observar, el BasicFileAttributes La interfaz define los atributos básicos compatibles con todas las plataformas comunes. Sin embargo,
plataformas específicas definen sus propios atributos de archivo, que son capturados por DosFileAttributes y
PosixFileAttributes. Puede especificar cualquiera de estas interfaces para recuperar los atributos de archivo asociados. El Listado 9-8 contiene un programa para
recuperar todos los atributos de un archivo usando BasicFileAttributes.
Listado 9-8. FileAttributes2.java

java.nio.file. *;
import java.nio.file.attribute. *;
class FileAttributes2 {
Path path = Paths.get (args [0]); tratar {
BasicFileAttributes fileAttributes = Files.readAttributes (ruta,

BasicFileAttributes.class);
System.out.println ("Tamaño del archivo:" + fileAttributes.size ()); System.out.println ("isDirectory:" +
fileAttributes.isDirectory ()); System.out.println ("isRegularFile:" + fileAttributes.isRegularFile ());
System.out.println ("isSymbolicLink:" + fileAttributes.isSymbolicLink ()); System.out.println ("Archivo
accedido por última vez:" +
fileAttributes.lastAccessTime ());
System.out.println ("Hora de última modificación del archivo:" +
fileAttributes.lastModifiedTime ());
System.out.println ("Tiempo de creación de archivo:" + fileAttributes.creationTime ()); } catch (IOException
e) {
}}}
La siguiente es una salida de muestra del programa:
D: \> java FileAttributes2 FileAttributes2.java Tamaño del

archivo: 904 isDirectory: false isRegularFile: true isSymbolicLink:
false
Hora de último acceso al archivo: 2012-10-06T10: 28: 29.0625Z Hora de última

modificación del archivo: 2012-10-06T10: 28: 22.4375Z Hora de creación del
archivo: 2012-10-06T10: 26: 39.1875Z
263
Usas el readAttribute () método junto con BasicFileAttributes para recuperar las propiedades básicas del archivo. Del mismo modo, puede recuperar
los atributos asociados con un archivo en un entorno DOS o UNIX utilizando DosFileAttributes
y PosixFileAttributes, respectivamente.
Copiar un archivo
Ahora intentemos copiar un archivo / directorio de una ubicación a otra. Esta tarea es fácil de realizar: solo llame
Files.copy () copiar el archivo de origen a destino. Aquí está la firma de este método:
Copia de ruta (origen de ruta, destino de ruta, opciones de copia...)
El Listado 9-9 usa este método para escribir un programa simple de copia de archivos.
Listado 9-9. FileCopy.java

java.nio.file. *;
clase pública FileCopy {

if (args.length! = 2) {
System.out.println ("uso: FileCopy <source-path> <destination-path>"); System.exit (1); }
Ruta pathSource = Paths.get (args [0]); Ruta pathDestination

= Paths.get (args [1]); tratar {
Files.copy (pathSource, pathDestination); System.out.println ("Archivo fuente

copiado con éxito"); } catch (IOException e) {
}}}
Ejecútelo y veamos si funciona.
D: \> java FileCopy FileCopy.java Backup.java Archivo fuente

copiado con éxito
Si, esta funcionando. Intentemos ejecutarlo nuevamente con los mismos argumentos.
D: \ OCPJP7 \ programas \ NIO2 \ src> java FileCopy FileCopy.java Backup.java

java.nio.file.FileAlreadyExistsException: Backup.java
en sun.nio.fs.WindowsFileCopy.copy (fuente desconocida) [. . .stack
rastro elidido. . .]
¡Uy! ¿Que pasó? Cuando intentaste copiar el archivo por segunda vez, recibiste un
FileAlreadyExistsException ya que el archivo de destino ya existe. Entonces, ¿qué pasa si desea sobrescribir el existente
264
¿archivo? La solución: necesitas decirle al Copiar() método que le gustaría sobrescribir un archivo existente. En el Listado 9-9, cambie el Copiar() método de la
siguiente manera:
Files.copy (pathSource, pathDestination, StandardCopyOption.REPLACE_EXISTING);
En este cambio, tú son especificando un argumento adicional (ya que el Copiar() el método admite argumentos variables) para indicarle al método que
desea sobrescribir un archivo si ya existe. Entonces, ejecutemos este programa y veamos si funciona.

copiado con éxito

copiado con éxito
Si, funciona. Ahora, intente copiar un archivo a un nuevo directorio.
D: \ OCPJP7 \ programas \ NIO2 \ src> java FileCopy FileCopy.java bak \ Backup.java

java.nio.file.NoSuchFileException: FileCopy.java -> bak \ Backup.java
[. . .stack rastro elidido. . .]
Bueno, aquí trataste de copiar un archivo al directorio anterior que no existe. Para esto, tienes el NoSuchFileException.
Tenga en cuenta que no solo el directorio dado sino todos los directorios intermedios en una ruta deben existir para Copiar() Método para tener éxito.
todos los directorios (excepto el último si está copiando un directorio) en la ruta especificada deben existir para evitar NoSuchFileException.
¿Qué pasa si intentas copiar un directorio? Funcionará, pero recuerde que solo copiará el directorio de nivel superior, no los archivos /
directorios contenidos en ese directorio.
si copia un directorio usando el Copiar() método, no copiará los archivos / directorios contenidos en el directorio fuente;
debe copiarlos explícitamente en la carpeta de destino.
Revisará este tema más adelante en este capítulo cuando implemente un programa de copia que pueda copiar un directorio en otro directorio junto
con los archivos / directorios contenidos.
Mover un archivo
Mover un archivo es bastante similar a copiar un archivo; para este propósito, puede usar el Files.move () método. La firma de este método es
Movimiento de ruta (origen de ruta, destino de ruta, opciones de copia...)
265
El Listado 9-10 contiene un pequeño programa que usa este método.
Listado 9-10. FileMove.java

java.nio.file. *;
clase pública FileMove {

System.out.println ("uso: FileMove <source-path> <destination-path>"); System.exit (−1); }

Files.move (pathSource, pathDestination, StandardCopyOption.REPLACE_EXISTING); System.out.println

("El archivo fuente se movió con éxito"); } catch (IOException e) {
}}}
Esta implementación básica funciona bien. Sin embargo, aquí hay algunas observaciones peculiares de moverse() método:
• Como es el caso con el Copiar() método, el moverse() el método tampoco sobrescribe el archivo de destino existente a menos que lo
especifique para hacerlo utilizando REMPLAZA EL EXISTENTE.
• Si mueve un enlace simbólico, el enlace en sí se moverá, no el archivo de destino del enlace. Es importante tener en
cuenta que en el caso de la Copiar() método, si especifica un enlace simbólico, se copia el destino del enlace, no el
enlace en sí.
• Se puede mover un directorio no vacío si mover el directorio no requiere mover los archivos / directorios que
lo contienen. Por ejemplo, mover un directorio de una unidad física a otra podría no tener éxito (un IOException
será arrojado). Si mover una operación de directorio es exitoso, también se moverán todos los archivos /
directorios contenidos.
• Puedes especificar un moverse() operación como una operación atómica utilizando el ATOMIC_MOVE Opción de copia. Si moverse()
se realiza como una operación no atómica y falla en el medio, el estado de ambos archivos es desconocido e indefinido.
Eliminar un archivo
los Archivos la clase proporciona un Eliminar() Método para eliminar un archivo / directorio / enlace simbólico. El Listado 9-11 contiene un programa simple para eliminar un archivo
especificado.
Listado 9-11. FileDelete.java

java.nio.file. *;
Clase pública FileDelete {

266
System.out.println ("uso: FileDelete <source-path>");
System.exit (1); }
Ruta pathSource = Paths.get (args [0]); tratar {
Files.delete (pathSource);
System.out.println ("Archivo eliminado con éxito"); } catch
(IOException e) {
}}}
Imprime lo siguiente cuando se ejecuta:
D: \> java FileDelete log.txt Archivo

eliminado correctamente
Hay algunos puntos para recordar al usar el Files.delete () método. En el caso de un directorio, el
Eliminar() el método debe invocarse en un directorio vacío; de lo contrario, el método fallará. En el caso de un enlace simbólico, el enlace se
eliminará, no el archivo de destino del enlace. El archivo que desea eliminar debe existir; de lo contrario obtendrá un NoSuchFileException. Si elimina
silenciosamente un archivo y no desea que le moleste esta excepción, puede usar el deleteIfExists () método, que no se quejará si el archivo no
existe y lo eliminará si el archivo existe.
Caminando un árbol de archivos

En diversas situaciones, debe recorrer el árbol de archivos. Por ejemplo, cuando desea buscar un archivo / directorio específico, debe recorrer el árbol
de archivos. Otro ejemplo de cuándo necesita recorrer un árbol de archivos es cuando desea copiar todo el directorio que contiene archivos /
subdirectorios.
los Archivos La clase proporciona dos métodos que le permiten recorrer un árbol de archivos; Aquí se dan las firmas de estos métodos:
Path walkFileTree (inicio de ruta, visitante de FileVisitor <? Super Path>)
Path walkFileTree (inicio de ruta, opciones Establecer <FileVisitOption>, int maxDepth, FileVisitor <? Super Path> visitante)
Ambos métodos toman una ruta desde la cual comenzará el recorrido del árbol de archivos y una instancia de FileVisitor eso gobernará lo que debe hacer mientras
camina por un árbol de archivos. (Hablaremos de FileVisitor en detalle en breve.) Además, el segundo método toma dos parámetros más: opciones de visita de archivos y
profundidad máxima. El parámetro de profundidad máxima especifica la profundidad del árbol de archivos que desea visitar; un valor 0 indica solo el archivo especificado y
un VALOR MÁXIMO indica que todos los niveles de directorios deben ser visitados.
Tenga en cuenta que debe proporcionar un FileVisitor instancia a la walkFileTree () métodos. los FileVisitor
La interfaz le permite realizar ciertas operaciones en ciertas coyunturas clave. Por ejemplo, la interfaz proporciona un visitFile () método que
puede implementar para especificar exactamente lo que debe hacerse cuando el FileVisitor
la instancia visita un archivo. Del mismo modo, también proporciona tres métodos más útiles, que se pueden personalizar según sus necesidades: preVisitDirectory
(), postVisitDirectory (), y visitFileFailed (). Mesa 9-3 proporciona un breve resumen de estos métodos.
267
Tabla 9-3. Métodos admitidos por la interfaz FileVisitor
FileVisitResult preVisitDirectory (T dir, BasicFileAttributes attrs) Se invoca justo antes de acceder a los
elementos del directorio.
FileVisitResult visitFile (archivo T, BasicFileAttributes attrs) Se invoca cuando se visita un archivo.
FileVisitResult postVisitDirectory (T dir, IOException exc) Se invoca cuando se accede a todos los
elementos del directorio.
FileVisitResult visitFileFailed (archivo T, IOException exc) Se invoca cuando no se puede acceder al

archivo.
Necesita implementar el FileVisitor interfaz para que pueda crear una instancia de su implementación y pasarla al walkFileTree () métodos.
Sin embargo, si no desea implementar los cuatro métodos en el
FileVisitor interfaz, simplemente puede extender su implementación desde el SimpleFileVisitor clase. De esta manera, simplemente puede
anular los métodos que desea personalizar.
El Listado 9-12 contiene un ejemplo para que pueda entender esto más claramente. Suponga que desea imprimir el árbol de archivos desde un punto
específico.
Listado 9-12. FileTreeWalk.java

java.nio.file. *;
import java.nio.file.attribute.BasicFileAttributes;
clase MyFileVisitor extiende SimpleFileVisitor <Path> {

public FileVisitResult visitFile (Ruta de acceso, BasicFileAttributes fileAttributes) {
System.out.println ("nombre de archivo:" + path.getFileName ()); return
FileVisitResult.CONTINUE; }
public FileVisitResult preVisitDirectory (ruta de acceso, BasicFileAttributes fileAttributes) {

System.out.println ("---------- Nombre del directorio:" + ruta + "---------"); return
FileVisitResult.CONTINUE; }}
clase pública FileTreeWalk {

System.out.println ("uso: FileWalkTree <source-path>"); System.exit (−1); }
Ruta pathSource = Paths.get (args [0]); tratar {
Files.walkFileTree (pathSource, nuevo MyFileVisitor ()); } catch

(IOException e) {
}}}
268
Primero ejecutemos este programa y luego entendamos cómo funciona.
D: \> java FileTreeWalk ch9-13

- - - - - - - - - - Nombre del directorio: ch9-13 --------- nombre del
archivo: .classpath nombre del archivo: .project
- - - - - - - - - - Nombre del directorio: ch9-13 \ .settings --------- nombre del

archivo: org.eclipse.jdt.core.prefs
- - - - - - - - - - Nombre del directorio: ch9-13 \ bin --------- nombre del
archivo: FileTreeWalk.class nombre del archivo: MyFileVisitor.class
- - - - - - - - - - Nombre del directorio: ch9-13 \ bin \ Test --------- nombre del

archivo: log.txt
- - - - - - - - - - Nombre del directorio: ch9-13 \ src --------- nombre del
archivo: FileTreeWalk.class nombre del archivo: FileTreeWalk.java nombre
del archivo: MyFileVisitor.class
- - - - - - - - - - Nombre del directorio: ch9-13 \ src \ Test --------- nombre del

archivo: log.txt
Hemos ejecutado este programa con un directorio. Imprimió todos los archivos y directorios contenidos en el directorio de entrada dado. Ahora,
así es como funciona:
• Usted define un FileVisitor, MyFileVisitor, en el que anulas dos métodos,

visitFile () y preVisitDirectory (), del SimpleFileVisitor clase. En estos métodos, acaba de imprimir el nombre
(junto con la ruta en el caso del directorio) del archivo / directorio.
• Entonces invocaste walkFileTree () con una instancia de MyFileVisitor.
• los walkFileTree () El método comienza desde la ruta de entrada especificada. Invoca el visitFile ()
método cuando visita un archivo, preVisitDirectory () justo antes de que comience a visitar los elementos de un directorio, postVisitDirectory
() inmediatamente después de que termine de visitar todos los elementos del directorio, y visitFileFailed () en caso de que no se pueda
acceder a ningún archivo / directorio.
• Aquí, dado que ha anulado dos métodos, puede imprimir los nombres de los archivos y la ruta de los directorios
visitados.
• Una cosa más que requiere atención aquí es la FileVisitReturn valor. Puedes controlar el flujo de la caminata usando FileVisitReturn
valores. Hay cuatro tipos de valores de retorno diferentes:
• SEGUIR: Indica que el recorrido por el árbol de archivos debe continuar.
• TERMINAR: Indica que el recorrido por el árbol de archivos debe finalizar inmediatamente.
• SKIP_SUBTREE: Indica que se debe omitir el resto del subárbol para el árbol de archivos ambulantes.
• SKIP_SIBLINGS: Indica que el árbol de archivos caminando debe detenerse para el directorio actual y sus directorios
hermanos. Si se devuelve desde el preVisitDirectory (), entonces los archivos / directorios que contienen no se visitan y
el postVisitDirectory () Tampoco es visitado. Si se devuelve desde visitFile (), entonces no se visita ningún archivo
adicional en el directorio. Si se devuelve desde el postVisitDirectory (), entonces los hermanos del directorio no son
visitados.
269
Revisitando Copia de Archivo
Viste cómo copiar un archivo de una ubicación a otra. Sin embargo, no pudo realizar una copia en un directorio completo (y sus archivos / subdirectorios). Ahora
puede recorrer el árbol de archivos, lo que facilita la implementación de un programa de copia que puede copiar todo el directorio junto con elementos que lo
contienen. El listado 9-13 muestra el programa para hacerlo.
Listado 9-13. FileTreeWalkCopy.java

java.nio.file. *;
// Nuestra implementación de visitante de archivos que realiza la clase de copia

MyFileCopyVisitor extiende SimpleFileVisitor <Path> {
Ruta privada de origen, destino;
public MyFileCopyVisitor (Ruta s, Ruta d) {

fuente = s; destino = d; }

Ruta newd = destination.resolve (source.relativize (ruta)); tratar {
Files.copy (ruta, newd, StandardCopyOption.REPLACE_EXISTING); } catch

(IOException e) {
}
return FileVisitResult.CONTINUE; }

Ruta newd = destination.resolve (source.relativize (ruta)); tratar {
Files.copy (ruta, newd, StandardCopyOption.REPLACE_EXISTING); } catch

(IOException e) {
}
return FileVisitResult.CONTINUE; }}
clase pública FileTreeWalkCopy {

System.out.println ("uso: FileTreeWalkCopy <source-path> <destination-path>"); System.exit (1); }

Files.walkFileTree (pathSource, nuevo MyFileCopyVisitor (pathSource, pathDestination));

System.out.println ("¡Archivos copiados con éxito!");
270
} catch (IOException e) {
}}}
Ejecutemos este programa y veamos si funciona:
D: \> java FileTreeWalkCopy Test Test2 ¡Los archivos se

copiaron correctamente!
Bueno, el programa copió el Prueba directorio junto con los archivos contenidos en el Prueba directorio a la Test2
directorio. Esencialmente, lo que está haciendo es bastante simple: en el preVisitDirectory () método, está copiando el directorio (que se está visitando).
Para recuperar la nueva ruta de destino, está utilizando el relativizar () método de la Camino clase. Del mismo modo, obtiene una nueva ruta de destino
cada vez que visita un archivo, que se utiliza para copiar el archivo en el directorio de destino. Eso es. Ya terminaste
Encontrar un archivo
Una vez que comprenda cómo recorrer el árbol de archivos, es muy sencillo y fácil encontrar el archivo deseado. Por ejemplo, si está buscando un archivo /
directorio en particular, puede intentar hacer coincidir el nombre del archivo / directorio que está buscando con el visitFile () o preVisitDirectory () método. Sin
embargo, si está buscando todos los archivos que coinciden con un patrón particular (por ejemplo, todos los archivos fuente Java o archivos xml) en un árbol de
archivos, puede usar glob o regex para que coincida con los nombres de los archivos. los PathMatcher La interfaz es útil en este contexto, ya que coincidirá con una
ruta una vez que haya especificado el patrón deseado. los PathMatcher la interfaz se implementa para cada sistema de archivos, y puede obtener una instancia
desde FileSystem clase usando el getPathMatcher () método.
Antes de ver un ejemplo detallado, primero comprendamos Glob patrones. Glob es un mecanismo de especificación de patrones en el que puede especificar patrones
de coincidencia de archivos como cadenas. Mesa 9-4 resume los patrones admitidos por la sintaxis global.
Tabla 9-4. Patrones compatibles con la sintaxis de Glob
Modelo Descripción
** Coincide con cualquier cadena de cualquier longitud, incluso longitud cero.
* ** * Similar a "*", pero cruza los límites del directorio.
? Coincide con cualquier personaje individual,
[xyz] Coincide con x, y o z.
[0–5] Coincide con cualquier personaje en el rango de 0 a 5.
[Arizona] Coincide con cualquier letra minúscula.
{xyz, abc} Coincide con xyz o abc.
271
Por lo tanto, puede especificar una sintaxis como Archivo * .java para que coincida con todos los archivos fuente de Java que comienzan con las letras
"Expediente" o puedes tener una sintaxis como programa [0–9] .class, que coincidirá con archivos como program0.class, program1.class, y
así.
Probemos un ejemplo que toma una ruta (una ruta de inicio) y un patrón (para encontrar archivos coincidentes) y luego imprime la lista de archivos que
coinciden con el patrón especificado. El programa se da en el Listado 9-14.
Listado 9-14. FileTreeWalkFind.java

java.nio.file. *;
clase MyFileFindVisitor extiende SimpleFileVisitor <Path> {

Matcher privado PathMatcher;
public MyFileFindVisitor (patrón de cadena) {

tratar {
matcher = FileSystems.getDefault (). getPathMatcher (patrón); } catch
(IllegalArgumentException iae) {
System.err.println ("Patrón no válido; ¿olvidó prefijar \" glob: \ "?
(como en glob: *. java) ");
System.exit (−1);
}
}
encontrar (camino);
return FileVisitResult.CONTINUE; }
búsqueda privada vacía (ruta de acceso) {

Nombre de ruta = path.getFileName (); if
(matcher.matches (nombre))
System.out.println ("Archivo coincidente:" + path.getFileName ());
}
encontrar (camino);
return FileVisitResult.CONTINUE; }}
clase pública FileTreeWalkFind {

System.out.println ("uso: FileTreeWalkFind <start-path> <patrón para buscar>");
System.exit (−1); }
Ruta startPath = Paths.get (args [0]); Patrón de

cadena = args [1];
272
tratar {
Files.walkFileTree (startPath, nuevo MyFileFindVisitor (patrón)); System.out.println
("¡Búsqueda de archivo completada!"); } catch (IOException e) {
}}}
Ejecutemos primero y luego comprendamos cómo funciona.
d: \> java FileTreeWalkFind ch9-15 glob: File * .java Archivo coincidente:

FileTreeWalkFind.java ¡Búsqueda de archivo completada!
d: \> java FileTreeWalkFind ch9-15 glob: File * Archivo coincidente:

FileTreeWalkFind.class Archivo coincidente: FileTreeWalkFind.class
Archivo coincidente: FileTreeWalkFind.java ¡Búsqueda de archivo
completada!
Así es como funciona:
• Tu defines tu FileVisitor, MyFileFindVisitor, que anula dos métodos,

visitFile () y preVisitDirectory ().
• En el constructor de su clase de visitante, recupera un PathMatcher instancia utilizando un

FileSystem ejemplo.
• Los métodos anulados llaman a un método de encontrar(); este método crea un Camino objeto del nombre del archivo del pasado Camino
objeto. Esto es necesario ya que desea que el emparejador coincida solo con el nombre del archivo, no con la ruta completa.
• Empiezas caminando por el árbol de archivos usando el método walkFileTree (); tú especificar una instancia de MyFileFindVisitor
como el FileVisitor.
• Si el archivo / directorio de visita actual coincide con el patrón, imprime el nombre del archivo. El proceso de hacer coincidir el
patrón especificado se lleva a cabo mediante un PathMatcher ejemplo.
Viendo un directorio para cambios

Supongamos que ha implementado un IDE simple para trabajar en programas Java. Has cargado un archivo fuente Java en él y estás trabajando en ello. ¿Qué
sucede si algún otro programa cambia el archivo fuente en el que está trabajando? Es posible que desee preguntarle al usuario si desea volver a cargar el
archivo fuente. De hecho, muchos IDEs y otros programas muestran un mensaje al usuario y solicitan permiso del usuario para volver a cargar los archivos (ver
Figura 9-2 ) Sin embargo, el punto clave es: ¿cómo se le notifica que el archivo en el que está trabajando fue modificado por algún otro programa?
273
Figura 9-2. Notificación de cambio de archivo que se muestra en Eclipse IDE
Java 7 ofrece un servicio de observación de directorio que puede lograr exactamente el mismo resultado. Puede registrar un directorio utilizando este servicio para cambiar la
notificación de eventos, y cada vez que ocurra cualquier cambio en el directorio (como la creación de nuevos archivos, la eliminación de archivos y la modificación de archivos)
recibirá una notificación de evento sobre el cambio. El servicio de vigilancia es una manera conveniente, escalable y fácil de realizar un seguimiento de los cambios en un directorio.
Veamos primero un programa en el Listado 9-15 y luego veamos cómo funciona la API del servicio de vigilancia. Suponga que desea monitorear src directorio
de su proyecto actual. Está interesado en eventos de modificación de archivos, de modo que cualquier cambio en cualquier archivo del directorio resulte en una
notificación de evento a su programa.
Listado 9-15. KeepAnEye.java

java.nio.file. *;
clase pública KeepAnEye {

Path path = Paths.get (".. \\ src"); WatchService
watchService = nulo; tratar {
watchService = path.getFileSystem (). newWatchService (); path.register (watchService,

StandardWatchEventKinds.ENTRY_MODIFY); } catch (IOException e1) {
e1.printStackTrace (); }
// bucle infinito para (;;)

{
WatchKey key = null; tratar {
clave = watchService.take (); } catch

(InterruptedException e) {
}
// iterar para cada evento
para (evento WatchEvent <?>: key.pollEvents ()) {
switch (event.kind (). name ()) {case
"OVERFLOW":
System.out.println ("Perdimos algunos eventos"); rotura; caso
"ENTRY_MODIFY":
274
System.out.println ("Archivo" + event.context () + "ha cambiado!"); rotura; }}
// restablecer la clave es importante para recibir notificaciones posteriores key.reset (); }}}
Ejecute este programa y, mientras tanto, intente cambiar el archivo fuente y el archivo de clase en src directorio. Puede obtener resultados como
este:
d: \ workspace \ ch9-16 \ src> java KeepAnEye File

¡KeepAnEye.java ha cambiado! ¡El archivo KeepAnEye.java
ha cambiado! ¡El archivo KeepAnEye.java ha cambiado! ¡El
archivo KeepAnEye.class ha cambiado! ¡El archivo
KeepAnEye.class ha cambiado!
Bueno, eso es genial, está funcionando según lo previsto. Ahora, comprendamos el programa paso a paso:
• Lo primero que debe hacer es obtener una instancia de Servicio de vigilancia. Puede obtener una instancia de servicio de
observación utilizando el FileSystem clase. Aquí estás obteniendo un FileSystem instancia utilizando una instancia de ruta, y
luego solicita una instancia de servicio de vigilancia del
FileSystem. También puede obtener una instancia de la FileSystem desde FileSystems
( FileSystems.getDefault ()).
• Una vez que tenga una instancia del servicio de vigilancia, el siguiente paso es registrar el directorio en el servicio de vigilancia. los Camino
El objeto proporciona dos métodos de registro: el primero Registrarse()
El método toma argumentos variables (primero, una instancia del servicio de observación y, posteriormente, el tipo de evento de
observación en el que está interesado). El segundo Registrarse() El método toma un parámetro adicional: el modificador de evento de
observación. Aquí, estás usando la primera Registrarse()
método.
• Desea recibir una notificación de evento solo cuando se modifica un archivo; así especificas
ENTRY_MODIFY ( perteneciendo a StandardWatchEventKinds). Otros tipos de eventos de observación incluyen
ENTRY_CREATE, ENTRY_DELETE, y DESBORDAMIENTO. Los primeros tres tipos se explican por sí mismos;
DESBORDAMIENTO especifica que algunas notificaciones de eventos se descartan o se pierden. Estos tipos de eventos se pueden
especificar en función de los requisitos.
• Una vez que se realiza el registro, está listo para recibir notificaciones de eventos. Puede implementar un bucle infinito
en el que espera a que ocurra el evento adecuado.
• En el bucle, debe esperar a que ocurra el evento. Aquí, puede solicitar al servicio de vigilancia que notifique a este
programa cuando ocurra un evento. Puedes hacer esto usando tres métodos:
• los encuesta() el método devuelve una clave en cola si está disponible; de lo contrario, vuelve de inmediato.
• los encuesta (larga, TimeUnit) el método devuelve una clave en cola si está disponible; de lo contrario, espera el tiempo
especificado (el valor largo) y la unidad de tiempo especificada. El método vuelve una vez transcurrido el límite de tiempo
especificado.
275
• los tomar() el método devuelve una clave en cola si está disponible; de lo contrario, espera hasta que haya una clave disponible.
• La diferencia clave entre el encuesta() y tomar() métodos es que encuesta() es una llamada sin bloqueo
y tomar() Es una llamada de bloqueo.
• Cuando se devuelve una clave, uno o más eventos pueden estar en cola; por eso pones otro
para bucle para iterar a través de todos los eventos disponibles.
• Puede obtener el tipo de evento utilizando el tipo() método y el nombre del archivo para el que se ha producido el
evento utilizando el contexto() método.
• Una vez que haya terminado con el procesamiento de eventos, debe restablecer la clave utilizando Reiniciar() método en la clave.
Puntos para recordar

Estos son los conceptos que debe comprender para aprobar esta sección del examen OCPJP.
• No confundir Expediente con Archivos, ruta con Rutas, y FileSystem con FileSystems: ellos son diferentes. Expediente es una clase antigua
(Java 4) que representa los nombres de ruta de archivo / directorio, mientras que Archivos
se introdujo en Java 7 como una clase de utilidad con soporte integral para API de E / S. los Camino
La interfaz representa una ruta de archivo / directorio y define una lista útil de métodos. sin embargo, el
Rutas La clase es una clase de utilidad que ofrece solo dos métodos (ambos para obtener Camino objeto).
FileSystems Ofrecer una lista de métodos de fábrica para la clase FileSystem, mientras FileSystem
proporciona un conjunto útil de métodos para obtener información sobre un sistema de archivos.
• El archivo o directorio representado por un Camino El objeto puede no existir.
• Aprendiste a realizar una copia para archivos / directorios. Sin embargo, no es necesario que realice la copia solo en
dos archivos / directorios. Puede tomar la entrada de un Flujo de entrada
y escribir en un archivo, o puede tomar la entrada de un archivo y copiarlo en un Flujo de salida.
Métodos copy (InputStream, Path, CopyOptions...) y copy (Path, OutputStream, CopyOptions...) podría ser
usado aquí.
• Debe tener cuidado al realizar una operación al recorrer un árbol de archivos. Por ejemplo, si está realizando una
eliminación recursiva, primero debe eliminar todos los archivos que contienen antes de eliminar el directorio que
contiene estos archivos.
• los Visitante El patrón de diseño se utiliza para permitir caminar por un árbol de archivos.
• En el contexto de un servicio de vigilancia, un estado está asociado con una tecla de vigilancia. Una llave de reloj podría estar en Listo estado
(listo para aceptar eventos), en firmado estado (cuando uno o más eventos están en cola), o en inválido estado (cuando la tecla de
vigilancia no es válida). Si la clave está en el firmado estado, se requiere llamar al Reiniciar() método; de lo contrario, el estado de la
clave no cambiará a Listo
estado y no recibirá más notificaciones de eventos.
• Su programa puede recibir un DESBORDAMIENTO evento incluso si el programa no está registrado para este evento.
• Si está viendo un directorio utilizando el servicio de vigilancia ofrecido por Java 7, solo se verán los archivos contenidos
en ese directorio, y no los archivos contenidos en los subdirectorios de ese directorio. Si tiene la intención de ver todo el
subárbol del sistema de archivos, debe registrar recursivamente cada directorio en el subárbol.
276
¡Hora de preguntar!
1) considere el siguiente programa:
clase pública PathInfo {

Ruta aFilePath = Paths.get ("D: \\ dir \\ file.txt"); // RUTA DE ARCHIVO
while (aFilePath.iterator (). hasNext ()) {

System.out.println ("elemento de ruta:" + aFilePath.iterator (). Next ()); }}}
supongamos que el archivo D: \ dir \ file.txt existe en el sistema de archivos subyacente. ¿Cuál de las siguientes opciones
describe correctamente el comportamiento de este programa?
a) el programa da un error de compilación en la línea marcada con el comentario RUTA DE ARCHIVO porque el
excepción marcada FileNotFoundException No se maneja.
B) el programa da un error de compilación en la línea marcada con el comentario RUTA DE ARCHIVO porque el
excepción marcada InvalidPathException No se maneja.
c) el programa entra en un bucle infinito imprimiendo "path element: dir" para siempre.
D) el programa imprime lo siguiente:
elemento de ruta: dir
elemento de ruta: file.txt
Responder: c) el programa entra en un bucle infinito imprimiendo "path element: dir" para siempre.
(en el mientras bucle, usas iterador () para obtener un objeto iterador temporal. Entonces, la llamada a siguiente()
en la variable temporal se pierde, por lo que el mientras el bucle entra en un bucle infinito. en otras palabras, el siguiente ciclo
finalizará después de imprimir las partes "dir" y "file.txt" de la ruta:
Iterador <Path> caminos = aFilePath.iterator (); while

(paths.hasNext ()) {
System.out.println ("elemento de ruta:" + paths.next ()); }
La opción a) está mal porque el Paths.get el método no arroja FileNotFoundException.
La opción B) está mal porque InvalidPathException es un Excepción en tiempo de ejecución. Además, dado que la ruta del archivo existe
en el sistema de archivos subyacente, esta excepción no se lanzará cuando se ejecute el programa.
La opción D) está mal porque el programa entrará en un bucle infinito).
2. Cual dos de las siguientes afirmaciones son correctas con respecto a SimpleFileVisitor ¿interfaz?
a) el postVisitDirectory método, declarado en SimpleFileVisitor, será invocado después de todo el

Se han visitado entradas (es decir, archivos y subdirectorios) del directorio.
277
B) el visitFile método, declarado en SimpleFileVisitor, se invocará cuando se visite un archivo.
c) el visitFileOrDirectory método, declarado en SimpleFileVisitor, será invocado cuando un archivo

o se visita el subdirectorio.
D) el walkFileTree método, declarado en SimpleFileVisitor, caminará el árbol de archivos.
Responder: a) y B) son declaraciones correctas.
(con respecto a la opción c), no existe un método como visitFileOrDirectory en SimpleFileVisitor

interfaz. con respecto a la opción D), la walkFileTree El método es un método estático definido en el Archivos
clase que recorrerá el árbol de archivos. la walkFileTree el método no se declara en SimpleFileVisitor.
de hecho, FileVisitor es uno de los argumentos que toma este método por el cual puedes pasar un
SimpleFileVisitor objeto como argumento.)
clase Relativize {
Ruta javaPath =
Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\ src \\ Relativize.java"). Normalize ();
Path classPath =
Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\ src \\ Relativize.class"). Normalize ();
Resultado de ruta = javaPath.relativize (classPath); if (resultado
== nulo) {
System.out.println ("falló la relativización"); } else if
(result.equals (Paths.get (""))) {
System.out.println ("las rutas relativas son las mismas, así que relativice
camino vacío devuelto ");
} más {
System.out.println (resultado); }}}
¿Cuál de las siguientes opciones muestra correctamente la salida de este programa?
a) el programa imprime lo siguiente: relativize falló.
B) el programa imprime lo siguiente: las rutas relativas son las mismas, por lo que se relativiza la ruta vacía devuelta.
c) el programa imprime lo siguiente: .. \ relativize.class.
D) el programa imprime lo siguiente: .. \ relativize.java.
Responder: c) el programa imprime lo siguiente: .. \ relativize.class.
(la relativizar () El método construye una ruta relativa entre esta ruta y una ruta dada. en este caso, las rutas para ambos
archivos son las mismas y solo difieren en los nombres de archivo ( Relativizar Java y Relativizar.clase). la comparación
relativa de las rutas se realiza desde la ruta dada a la ruta pasada al método relativize, por lo que imprime .. \
relativize.class.
Nota: la normalizar() El método elimina cualquier elemento de nombre redundante en una ruta. en este programa, no hay elementos de
nombre redundantes, por lo que no tiene impacto en la salida de este programa).
278
clase SubPath {
Path aPath = Paths.get ("D: \\ OCPJP7 \\ programas \\ .. \\ NIO2 \\ src \\. \\ SubPath.java");
aPath = aPath.normalize (); System.out.println
(aPath.subpath (2, 3)); }}
Este programa imprime lo siguiente:
una) ..
B) src
c) NiO2
D) NiO2 \ src
e) .. \ NiO2
Responder: B) src
(la normalizar() El método elimina elementos de nombre redundantes en la ruta dada, por lo que después de la llamada al normalizar() método,
el un sendero el valor es D: \ OCPJP7 \ NIO2 \ src \ SubPath.java.
la subpath (int beginIndex, int endIndex) El método devuelve una ruta basada en los valores de
beginIndex y endIndex. el nombre más cercano a la raíz tiene índice 0; tenga en cuenta que la raíz en sí (en este caso RE:\) no se
considera como un elemento en la ruta. por lo tanto, los elementos de nombre "OcpJp7", "NiO2", "src", "Subpath.java" están en las
posiciones de índice 0, 1, 2 y 3, respectivamente.
Tenga en cuenta que beginIndex es el índice del primer elemento, incluido ese elemento; endIndex es el índice del último elemento,
exclusivo de ese elemento. por lo tanto, el subpath es "sub", que está en la posición de índice 2 en este camino).
5) suponiendo que la variable camino apunta a un válido Camino objeto, cuál de las siguientes afirmaciones es la
forma correcta de crear un WatchService?
una) WatchService watchService = WatchService.getInstance (ruta);
SI) WatchService watchService = FileSystem.newWatchService ();
C) WatchService watchService = path.getFileSystem (). NewWatchService ();
RE) WatchService watchService = FileSystem ("predeterminado"). GetWatchService (ruta);
Responder: C) WatchService watchService = path.getFileSystem (). NewWatchService ();
(la newWatchService () El método es un método abstracto definido en el FileSystem clase. conseguir un

WatchService instancia asociada con un determinado camino objeto, primero debe obtener el asociado
FileSystem objetar y llamar al newWatchService () método sobre eso FileSystem objeto. por lo tanto, la opción c) es la
respuesta correcta).
279
Resumen
Trabajando con la clase de ruta
• UNA Camino objeto es una abstracción de programación para representar una ruta de un archivo / directorio.
• Puedes obtener una instancia de Camino utilizando el obtener() método de la Rutas clase.
• Camino proporciona dos métodos para usar para comparar Camino objetos: es igual a () y comparar con(). Incluso si dos Camino los
objetos apuntan al mismo archivo / directorio, no está garantizado que obtendrá la verdad del es igual a () método.
Realización de operaciones en archivos / directorios
• Puede verificar la existencia de un archivo utilizando el existe () método de la Archivos clase.
• los Archivos clase proporciona los métodos isReadable (), isWriteable (), y isExecutable ()
para verificar la capacidad del programa para leer, escribir o ejecutar mediante programación.
• Puede recuperar los atributos de un archivo utilizando el getAttributes () método.
• Puedes usar el readAttributes () método de la Archivos clase para leer los atributos de un archivo en masa.
• El método Copiar() se puede usar para copiar un archivo de una ubicación a otra. Del mismo modo, el método moverse() se
puede usar para mover un archivo de una ubicación a otra.
• Durante la copia, todos los directorios (excepto el último si está copiando un directorio) en la ruta especificada deben
existir para evitar NoSuchFileException.
• Utilizar el Eliminar() método para eliminar un archivo; utilizar el deleteIfExists () método para eliminar un archivo solo si existe.
Caminando un árbol de archivos
• los Archivos clase proporciona dos sabores de walkFileTree () para permitirle recorrer un sistema de archivos.
• los FileVisitor La interfaz le permite realizar ciertas operaciones en ciertas coyunturas clave.
• Si no desea implementar los cuatro métodos en el FileVisitor interfaz, simplemente puede extender su
implementación desde el SimpleFileVisitor clase.
Encontrar un archivo
• los PathMatcher La interfaz es útil cuando desea encontrar un archivo que satisfaga un determinado patrón. Puede
especificar el patrón usando glob o regex.
Viendo un directorio para cambios
• Java 7 ofrece un servicio de observación de directorio que puede notificarle cuando algún otro programa cambia el archivo en el que
está trabajando.
• Puedes registrar un Camino objeto utilizando un servicio de vigilancia junto con ciertos tipos de eventos. Cada vez que cambia cualquier
archivo en el directorio especificado, se envía un evento al programa registrado.
280

NIO.2 OCP - En.es PDF

Cargado por

Copyright:

Formatos disponibles

NIO.2 OCP - En.es PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

NIO.2 OCP - En.es PDF

Cargado por

Copyright:

Formatos disponibles

E / S de archivos Java (NIO.

Un historial rápido de las API de E / S

Usando la interfaz de ruta

Tabla 9-1. Métodos importantes en la interfaz de ruta

nombre del archivo / directorio es el último elemento o nombre en la ruta dada.

int getNameCount () Devuelve el número de nombres de archivo / directorio en la ruta dada;

Camino a AbsolutePath () Devuelve la ruta absoluta.

Obteniendo información de ruta

Listado 9-1. PathInfo1.java

public static void main (String [] args) {

// imprimir elementos de ruta

El programa imprime lo siguiente:

Imprimir información del archivo:

elemento de ruta: prueba elemento de

La salida se explica por sí misma. Vamos a entender el programa.

Listado 9-2. PathInfo2.java

import java.io.IOException; import

public static void main (String [] args) lanza IOException {

En nuestra máquina imprimió lo siguiente:

El nombre del archivo es: Prueba

Su URI es: archivo: /// D: /OCPJP7/programs/NIO2/./Test Su ruta absoluta

Su ruta absoluta normalizada es: D: \ OCPJP7 \ programs \ NIO2 \ Test

El nombre del archivo es: Prueba

Su URI es: archivo: /// D: /OCPJP7/programs/NIO2/./Test/ Su ruta absoluta

Ruta dirName = Paths.get ("D: \\ OCPJP7 \\ programas \\ NIO2 \\"); Ruta

Este segmento de código imprime lo siguiente:

D: \ OCPJP7 \ programas \ NIO2 \ Test

usar el archivar() método en el Camino interfaz para obtener un Expediente objeto.

Comparar dos caminos

El Listado 9-3 contiene un pequeño programa para comprender estos métodos.

Listado 9-3. PathCompare1.java

public static void main (String [] args) {

// comparando dos caminos usando el método equals ()

(path1.compareTo (path2) == 0) es: false path1.equals

Comprendamos el programa paso a paso.

Usando la clase de archivos

Ruta createDirectories (ruta dir, FileAttribute

La diferencia entre crear directorio y

Tabla 9-2. ( continuado)

(ruta de acceso, propietario de UserPrincipal) FileTime

LinkOption...), Ruta setAttribute (ruta de acceso, atributo de cadena,

Comprobación de propiedades de archivo y metadatos

Listado 9-4. PathCompare2.java

import java.io.IOException; import

public static void main (String [] args) lanza IOException {

System.out.println ("Files.isSameFile (path1, path2) es:"

El programa imprime lo siguiente:

Files.isSameFile (ruta1, ruta2) es: verdadero

Listado 9-5. PathExists.java

if (Files.exists (ruta, LinkOption.NOFOLLOW_LINKS)) {

System.out.println (path.getFileName () + "es un directorio");

System.out.println (path.getFileName () + "es un archivo");

System.out.println ("El archivo / directorio" + ruta.getFileName () + "no existe"); }}}

D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists PathExists.java El archivo /

D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists D: \ OCPJP7 \ El archivo /

D: \ OCPJP7 \ programas \ NIO2 \ src> java PathExists D: \ El

Listado 9-6. FilePermissions.java

D: \ OCPJP7 \ programas \ NIO2 \ src> java FilePermissions readonly.txt Legible: verdadero,