A clase File

A clase File

Utilizaremos a versión de Java JDK 17, unha versión LTS (long term support, con soporte a largo prazo).

Podes consultar a documentación dea biblioteca estándar de clases.

En concreto as clases que permiten traballar con ficheiros están no paquete java.io, onde na documentación atoparás a lista de interfaces e clases que contén o paquete.

O máis relevante pódes atopalo a continuación.

Os constructores:

• File(String ruta)
• File(String ruta, String nombre)
• File(File directorio, String nombre)

Os métodos:

• canRead() e canWrite() : comproba se o ficheiro se pode ler/escribir
• delete(): borra o ficheiro
• getPath(): devuelve a ruta do ficheiro
• mkdir(): crea un directorio coa ruta do obxecto que o recibe
• isDirectory() comproba se o ficheiro é un directorio

Podes atopar na coñecida web de referencia w3schools exemplos explicativos con código de manexo de ficheiros con estes métodos.

Con todo, dende Java SE 7, existe un xeito mellor de xestionar os ficheiros: java.nio.

Entón, se existe unha forma máis axeitada de xestionar os ficheiros en Java... por qué aprendemos a utilizar esta? Porque debido o enorme número de aplicacións que usan a antigua API (o que se chama legacy), Oracle non ten plan de eliminar ou desaconsellar o seu uso nas vindeiras versións de Java. E por iso, porque podes atopar un montón de código en funcionamento o que lle tes que dar mantemento (ou facer migración), e que non vai desaparecer de xeito inminente, e bo coñecer esta API

Exercicio: adaptar copia de ficheiros para uso de excepcións

Exercicio de ampliación: serialización de obxectos java.nio para xestión de ficheiros e directorios Agora que xa coñecemos esta nova posibilidade de traballar con ficheiros, que permite contar con toda a funcionalidade que se acadaba antes, indagaremos sobre qué melloras trae e como traballar coa nova API..

Melloras de java.nio

Cales son esas melloras na xestión? Por unha banda, permite facer unha mellor xestión de erros.

Poñamos este código de exemplo

File file = new File("probas/titorial.txt");
boolean result = file.delete();

Compila e pode funcionar mais no caso de fallar... cómo saberemos se é porque o ficheiro non existe, ou é porque non temos permisos para borrar?

Rescribindo o código coa nova NIO2 API:

Path path = Paths.get("probas/titorial.txt");
Files.delete(path);

Agora será preciso xestionar unha IOException, que dará os detalles de que foi o que aconteceu (por exemplo, non ter permisos de borrado).

A nova versión tamén mellora o soporte ós metadatos e trae melloras de rendemento evitando problemas de insuficiencia de memoria.

Diferencias con file e como facer uso de java.nio A primeira diferencia que salta rápido a vista dun programador é o cambio no nome do paquete e da clase (observables en letra grosa os cambios):

java.io.File file = new java.io.File("probas/titorial.txt");
java.nio.file.Path path = java.nio.file.Paths.get("probas/titorial.txt");

Antes construíamos un obxecto file via o construtor; agora obteremos un Path usando un método static (get).

Podemos obter o mesmo resultado encadeando o método resolve: Path outroXeitoPath = Paths.get("probas").resolve("titorial.txt");

Finalmente, é posibel convertir obxectos entre APIs:

Path pathFromFile = file.toPath();
File fileFromPath = path.toFile();

Both APIs deliver methods to manage files and directories. We'll demonstrate this using the previously created instance objects.

Para crear files usaremos os métodos createNewFile() e Files.createFile():

boolean result = file.createNewFile();
Path newPath = Files.createFile(path);

Para crear un directorio, mkdir() ou Files.createDirectory():

boolean result = file.mkdir();
File newPath = Files.createDirectory(path);

Hai variantes para incluir subdirectorios que non existan con mkdirs() e Files.createDirectories():

boolean result = file.mkdirs();
File newPath = Files.createDirectories(path);

Para renomear ou mover un ficheiro, precisamos crear outra instancia do obxecto e usar renameTo() ou Files.move():

boolean result = file.renameTo(new File("baeldung/tutorial2.txt"));
Path newPath = Files.move(path, Paths.get("baeldung/tutorial2.txt"));

Finalmente para borrar, usaremos delete() ou Files.delete():

boolean result = file.delete();
Files.delete(Paths.get(path));

Lembra que os métodos legacy devolven un flag cun result set a falso en caso de erro; e os métodos NIO2 devolve unha instancia de Path instance (agás a operación de borrado que lanza unha IOException en caso de erro).

Exercicio para indagar sobre metadatos Sabemos cómo consultar se un file existe con java.io e java.nio API // java.io API boolean fileExists = file.exists();

// java.nio API boolean pathExists = Files.exists(path);

Cal sería o código para saber se o indicado no path é u ficheiro? E se é posible escribir no mesmo? Amosa o código para as dúas apis:

Solución // java.io API boolean fileIsFile = file.isFile(); boolean fileWritable = file.canWrite();

// java.nio API boolean pathIsFile = Files.isRegularFile(path); boolean pathWritable = Files.isWritable(path); https://www.baeldung.com/java-path-vs-file

Exercicio para indagar sobre rutas (absoluta e canónica) Consulta a ruta canónica é absoluta dun ficheiro (o que ti escollas). Amosa o código para as dúas APIs.:

Solución // java.io API

String absolutePathStr = file.getAbsolutePath();
String canonicalPathStr = file.getCanonicalPath();

// java.nio API

Path absolutePath = path.toAbsolutePath();
Path canonicalPath = path.toRealPath().normalize();

Exercicio para indagar sobre rutas (absoluta e canónica) Consulta a ruta canónica é absoluta dun ficheiro (o que ti escollas). Amosa o código para as dúas APIs.:

Solución // java.io API

String absolutePathStr = file.getAbsolutePath();
String canonicalPathStr = file.getCanonicalPath();

// java.nio API

Path absolutePath = path.toAbsolutePath();
Path canonicalPath = path.toRealPath().normalize();

Explicación. O obxecto Path e inmutable, e devolve unha nova instancia. A API NIO2 ten os métodos toRealPath() e normalize() que podemos usar para eliminar redundancias.

Exercicio para amosar os contidos dun directorio Amosa o contido do directorio da túa elección

Solución

// java.io API
String[] list = file.list();
File[] files = file.listFiles();

// java.nio API
DirectoryStream<Path> paths = Files.newDirectoryStream(path);

A API NIO2 devolve o seu propio obxecto DirectoryStream object, que implementa a interface iterable.

Exercicio 10_1 e pedir recursividade