En en esta entrada vamos a profundizar sobre la clase «File» de Java. Se trata de la piedra angular de Java para trabajar con Ficheros. Con esta clase se pueden hacer una gran cantidad de cosas y las vamos a ver todas en esta estrada.
¿ Qué se puede hacer con la clase File ?
Con la clase File se puede:
- Crear un fichero.
- Comprobar si existe un determinado fichero.
- Comprobar si un item es un archivo o un directorio.
- Comprobar los permisos de un fichero.
- Borrar un fichero.
- Obtener la ruta completa de un fichero.
- Obtener el nombre de un fichero.
- Obtener la ruta del directorio que contiene un fichero. Es decir, obtener su ruta padre.
- Obtener el tamaño de un fichero.
- Comprobar si un fichero o directorio está oculto.
- Listar todos los archivos y directorios de un determinado directorio.
- Crear un directorio.
- Cambiar los permisos de un fichero.
- Un pequeño ejemplo donde realizaremos un explorador de ficheros.
Vamos al lio!
Crear un fichero
Para crear un fichero basta con crear una instancia de la clase «File» con un ruta determinada y luego ejecutar el método «createNewFile». Veámoslo con código:
//Instanciamos la clase file con la ruta del fichero
File nuevoFichero = new File("pruebaFichero.txt");
try {
//Creamos el fichero
if (nuevoFichero.createNewFile()) {
System.out.println("Fichero creado correctamente!");
}else {
System.out.println("No se ha podido crear el fichero!");
}
} catch (IOException e) {
e.printStackTrace();
}
Lo primero que hacemos es instanciar nuestra clase File y en el parámetro del constructor le pasamos la ruta del fichero que queremos crear, en este caso, se creará en la ruta actual de nuestro proyecto de eclipse. Podríamos haber seleccionado cualquier ruta de nuestro sistema de ficheros.
Posterior a esto, ejecutamos el método «createNewFile», fijaos que lo ejecutamos dentro de un «if», lo hacemos de esta manera porque este método devuelve un boolean.
La salida de nuestro programa
Fichero creado correctamente!
¿ Será verdad ?
Vamos a comprobarlo…
Comprobar si existe un determinado fichero
En este caso creamos una instancia de la clase File en cuyo parámetro de entrada pasamos la ruta del fichero que queremos comprobar si existe, después comprobamos si existe con el método «exists»:
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Comprobamos si existe
if (miFichero.exists()) {
System.out.println("El fichero existe!");
}else {
System.out.println("El fichero no existe!");
}
La salida de nuestro programa
El fichero existe!
Como era de esperar, el fichero existe, ya que lo hemos creado en el paso anterior.
Comprobar si un item es un archivo o un directorio
Para comprobar si un item es un fichero o un directorio tenemos los métodos «isFile» e «isDirectory» que nos devuelven true en caso de que sea un fichero o un directorio respectivamente. Para este ejemplo vamos a crear 2 instancias de la clase File, una apuntará a un fichero y la otra apuntará a un directorio.
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
File miDirectorio = new File(".");
//Comprobamos si miFichero es un fichero
if (miFichero.isFile()) {
System.out.println(miFichero.getName() + " es un fichero");
}
//Comprobamos si miDirectorio es un directorio
if (miDirectorio.isDirectory()) {
System.out.println(miDirectorio.getName() + " es un directorio");
}
La salida de nuestro programa
pruebaFichero.txt es un fichero
. es un directorio
Comprobar los permisos de un fichero
Para comprobar los permisos de un fichero podemos utilizar los métodos:
- canRead(): Nos devuelve «true» en caso de tener permisos de lectura y «false» en caso contrario.
- canWrite(): Nos devuelve «true» en caso de tener permisos de escritura y «false» en caso contrario.
- canExecute(): Nos devuelve «true» en caso de tener permisos de ejecución y «false» en caso contrario.
Vamos a ver el código
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Comprobamos los permisos de lectura
if (miFichero.canRead()) {
System.out.println(miFichero.getName() + " tiene permisos de lectura");
}else {
System.out.println(miFichero.getName() + " NO tiene permisos de lectura");
}
//Comprobamos los permisos de escritura
if (miFichero.canWrite()) {
System.out.println(miFichero.getName() + " tiene permisos de escritura");
}else {
System.out.println(miFichero.getName() + " NO tiene permisos de escritura");
}
//Comprobamos los permisos de ejecución
if (miFichero.canExecute()) {
System.out.println(miFichero.getName() + " tiene permisos de ejecución");
}else {
System.out.println(miFichero.getName() + " NO tiene permisos de ejecución");
}
La salida de nuestro programa
pruebaFichero.txt tiene permisos de lectura
pruebaFichero.txt tiene permisos de escritura
pruebaFichero.txt tiene permisos de ejecución
Borrar un fichero
Para borrar un fichero en Java lo podemos hacer con la clase File, instanciando la clase con la ruta del fichero que queremos borrar y llamando al metodo «delete»
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Borramos el fichero
miFichero.delete();
//Comprobamos si existe el fichero
if (miFichero.exists()) {
System.out.println(miFichero.getName() + " existe");
}else {
System.out.println(miFichero.getName() + " NO existe");
}
Primero instanciamos la clase File, después borramos el fichero y finalmente comprobamos si existe el fichero.
La salida de nuestro programa
pruebaFichero.txt NO existe
Obtener la ruta completa de un fichero
Para obtener la ruta completa de un fichero podemos utilizar el método «getAbsolutePath»
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Mostramos la ruta completa del fichero
System.out.println(miFichero.getAbsolutePath());
La salida de nuestro programa
C:\Users\somoshackersdelaprogramacion\eclipse-workspace\LaClaseFile\pruebaFichero.txt
Obtener el nombre de un fichero
Para obtener el nombre de un fichero instanciamos la clase File con la ruta de un determinado fichero y llamamos al método «getName»:
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("C:\\Users\\somoshackersdelaprogramacion\\eclipse-workspace\\LaClaseFile\\pruebaFichero.txt");
//Mostramos el nombre del fichero
System.out.println(miFichero.getName());
La salida de nuestro programa
pruebaFichero.txt
Obtener la ruta del directorio que contiene un fichero. Es decir, obtener su ruta padre
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("C:\\Users\\somoshackersdelaprogramacion\\eclipse-workspace\\LaClaseFile\\pruebaFichero.txt");
//Mostramos la ruta completa del fichero sin incluir el fichero
System.out.println(miFichero.getParent());
La salida de nuestro programa
C:\Users\somoshackersdelaprogramacion\eclipse-workspace\LaClaseFile
Obtener el tamaño de un fichero
Para obtener el tamaño de un fichero podemos utilizar el método «length»
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Mostramos el tamaño del fichero
System.out.println(miFichero.getName() + " ocupa: " + miFichero.length() + " bytes");
La salida de nuestro programa
pruebaFichero.txt ocupa: 33 bytes
Comprobar si un fichero o directorio está oculto
Para comprobar si un fichero o directorio está oculto podemos utilizar el método «isHidden», este método devuelve «true» en caso de que esté oculto o «false» en caso contrario.
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Comprobamos si el fichero está oculto
if (miFichero.isHidden()) {
System.out.println(miFichero.getName() + " está oculto");
}else {
System.out.println(miFichero.getName() + " NO está oculto");
}
La salida de nuestro programa
pruebaFichero.txt NO está oculto
Listar todos los archivos y directorios de un determinado directorio
Para listar todos los ficheros y directorios de un determinado directorio tenemos que utilizar el método «listFiles», este método devuelve un Array de objetos de tipo File, y podemos recorrer dicho Array con un sencillo bucle «for». Para el ejemplo, vamos a crear un directorio que contendrá 2 ficheros y 2 directorios:
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File(".\\mi directorio");
//Obtenemos el Array de files
File [] ficheros = miFichero.listFiles();
//Iteramos sobre el Array
for (File f: ficheros) {
if (f.isFile()) {
System.out.println(f.getName() + " es un fichero");
}
if (f.isDirectory()) {
System.out.println(f.getName() + " es un directorio");
}
}
La salida de nuestro programa
directorio1 es un directorio
directorio2 es un directorio
fichero1.txt es un fichero
fichero2.odt es un fichero
Crear un directorio
Para crear un directorio lo podemos hacer instanciando la clase File y llamando al metodo «mkdir»
//Instanciamos la clase file con la ruta del fichero
File miDirectorio = new File(".\\mi directorio\\directorio nuevo");
//Creamos el directorio
miDirectorio.mkdir();
¿ Se creará el directorio ?
Cambiar los permisos de un fichero
Para cambiar los permisos de un fichero lo podemos hacer instanciando la clase File con la ruta de nuestro fichero y llamando a los métodos:
- «setExecutable»: Permite cambiar los permisos de ejecución del fichero.
- «setReadable»: Permite cambiar los permisos de lectura del fichero.
- «setWritable»: Permite cambiar los permisos de escritura del fichero.
//Instanciamos la clase file con la ruta del fichero
File miFichero = new File("pruebaFichero.txt");
//Modificamos los permisos
miFichero.setExecutable(false);
miFichero.setReadable(false);
miFichero.setWritable(false);
//Mostramos los permisos
if (!miFichero.canExecute()) {
System.out.println(miFichero.getName() + " no tiene permisos de ejecución");
}
if (!miFichero.canRead()) {
System.out.println(miFichero.getName() + " no tiene permisos de lectura");
}
if (!miFichero.canWrite()) {
System.out.println(miFichero.getName() + " no tiene permisos de escritura");
}
La salida de nuestro programa
pruebaFichero.txt no tiene permisos de escritura
Fijaos que solo ha funcionado el cambio de permisos de escritura, esto tendríamos que investigarlo a fondo, pero no es el objetivo de esta entrada.
Realizamos un explorador de ficheros
En el siguiente ejemplo vamos a realizar un explorador de ficheros por consola, veremos el código, explicaremos el código y posterior a esto, realizaremos algunas pruebas sobre nuestro flamante explorador de ficheros, vamos con el código:
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int opcionMenu = -1;
System.out.println("Introduce la ruta inicial del explorador de ficheros: ");
String ruta = sc.nextLine();
System.out.println("Has seleccionado la ruta: " + ruta);
File fRuta = new File(ruta);
while ((opcionMenu = mostrarMenu()) != 4 ) {
if (opcionMenu == 1) {
mostrarFicheros(fRuta);
}else if (opcionMenu == 2) {
String nuevoDirectorio = anyadirDirectorio();
ruta = ruta + "\\" + nuevoDirectorio;
System.out.println("La nueva ruta es: " + ruta);
fRuta = new File(ruta);
}else if (opcionMenu == 3) {
ruta = ruta.substring(0, ruta.lastIndexOf("\\"));
System.out.println("La nueva ruta es: " + ruta);
fRuta = new File(ruta);
}
}
}
public static int mostrarMenu() {
System.out.println("----------------------------------------------------");
System.out.println(" MENU ");
System.out.println("----------------------------------------------------");
System.out.println("1. Mostrar ficheros del directorio actual");
System.out.println("2. Modificar el directorio actual (añade al path actual el directorio introducido)");
System.out.println("3. Volver atrás");
System.out.println("4. Salir del programa");
System.out.println();
System.out.println("¿ Qué opción quieres realizar ?");
return sc.nextInt();
}
public static void mostrarFicheros(File f) {
File [] ficheros = f.listFiles();
System.out.println("----------------------------------------------------");
System.out.println(" FICHEROS ");
System.out.println("----------------------------------------------------");
for (File fichero: ficheros) {
System.out.println(fichero.getName());
}
}
public static String anyadirDirectorio() {
System.out.println("¿ Qué directorio quieres añadir ?");
sc.nextLine();
return sc.nextLine();
}
}
¿ Cómo funciona nuestro explorador de ficheros ?
- Al empezar se pide al usuario que introduzca el directorio desde donde quiere empezar a explorar su sistema de archivos, utilizando para ello la clase «Scanner».
- Después se muestra al usuario la ruta que ha seleccionado.
- Se muestra un menú que tiene 4 opciones.
- Mostrar los ficheros y directorios del directorio actual
- Añadir un nuevo directorio a la ruta actual
- Volver atrás, es decir, eliminar el último directorio
- Salir del programa
- El usuario selecciona una opción del menú.
- Se realiza la acción seleccionada por el usuario
- Se vuelve a mostrar el menú hasta que el usuario seleccione la opción 4.
Pruebas de nuestro flamante explorador de ficheros
Introduce la ruta inicial del explorador de ficheros:
C:\\Users\\usuario\\Desktop\\mi directorio
Has seleccionado la ruta: C:\\Users\\usuario\\Desktop\\mi directorio
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
1
----------------------------------------------------
FICHEROS
----------------------------------------------------
directorio nuevo
directorio1
directorio2
fichero1.txt
fichero2.odt
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
2
¿ Qué directorio quieres añadir ?
directorio nuevo
La nueva ruta es: C:\\Users\\usuario\\Desktop\\mi directorio\directorio nuevo
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
1
----------------------------------------------------
FICHEROS
----------------------------------------------------
fichero3.txt
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
3
La nueva ruta es: C:\\Users\\usuario\\Desktop\\mi directorio
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
1
----------------------------------------------------
FICHEROS
----------------------------------------------------
directorio nuevo
directorio1
directorio2
fichero1.txt
fichero2.odt
----------------------------------------------------
MENU
----------------------------------------------------
1. Mostrar ficheros del directorio actual
2. Modificar el directorio actual (añade al path actual el directorio introducido)
3. Volver atrás
4. Salir del programa
¿ Qué opción quieres realizar ?
4
Os dejo el código fuente del flamante explorador de ficheros aquí, jaja.
Si os ha gustado la entrada de «La clase File de Java» dejad un comentario para apoyar el blog. Un saludo programadores.