Un directorio/carpeta es un sistema de archivos utilizado en informática que actúa como una ubicación de memoria con nombre para almacenar archivos relacionados o incluso subcarpetas. Esto permite una mejor gestión de archivos y carpetas y se basa en el concepto de carpetas del mundo real utilizadas para almacenar archivos. Este sistema es la implementación de la compartimentación de la memoria y hace que el espacio de trabajo sea más organizado. El sistema de archivos de directorio permite la organización jerárquica, así como el anidamiento de directorios dentro de otros directorios.
La recursividad es el proceso a través del cual una función se llama a sí misma. Es un enfoque muy útil para dividir problemas complejos en subpartes más pequeñas.
Enfoques:
- Usando el método thekdir ()
- Uso del método createDirectory() del paquete java.nio
1. Usando el método mkdir()
El primer enfoque es importar la clase java.io.File y definir un método llamado file() que internamente hace uso de la función mkdir() para crear directorios recursivamente. El algoritmo utilizado dentro del método file() se describe a continuación.
Algoritmo:
- Cree el método file() con el tipo de devolución como void.
- Este método toma tres parámetros:
- String md que significa Directorio principal.
- Ruta de string que representa la estructura del directorio que se realizará donde cada carácter significa un nuevo directorio
- Int depth representa el número de directorios a realizar.
- Declare la condición de terminación como si (profundidad == 0) regresara.
- Disminuya la profundidad para cada llamada recursiva.
- Compruebe si la string de ruta tiene una longitud de 0 y muestra el mensaje correspondiente.
- Agregue el md con el primer carácter de la string de ruta y elimine el primer carácter de la string de ruta para cada llamada recursiva.
- Crea un objeto de la clase File con md como parámetro.
- Verifique si el directorio ya existe usando el método exist() y muestre el mensaje.
- De lo contrario, cree el directorio utilizando el método mkdir().
- Haz la llamada recursiva.
Implementación: A continuación se muestra la implementación del programa anterior.
Java
// Java Program to Create Directories Recursively
// Importing required classes
import java.io.File;
// Main class
class GFG {
// Method
// To create directories
static void file(String md, String path, int depth)
{
// md stores the starting path each character in
// path represents new directory depth stores
// the number of directories to be created
// terminating condition
if (depth == 0)
return;
// Decrementing the depth by 1
depth -= 1;
// Checking if the path exists
if (path.length() == 0)
System.out.println("Path does not exist");
// execute if the path has more directories
else {
// appending the next directory
// would be md = md + "\\" +
// path.charAt(0) for windows
md = md + "/" + path.charAt(0);
// removing the first character
// from path string
path = path.substring(1);
// creating File object
File f = new File(md);
// if the directory already exists
if (f.exists()) {
System.out.println("The Directory "
+ "already exists");
}
else {
// creating the directory
boolean val = f.mkdir();
if (val)
System.out.println(md + " created"
+ " successfully");
else
System.out.println(
"Unable to "
+ "create Directory");
}
}
// recursive call
file(md, path, depth);
}
// Driver method
public static void main(String[] args)
{
// creating class object
GFG ob = new GFG();
// path for windows -> "C:\\Users\\
// harshit\\Desktop"
ob.file("/home/mayur/Desktop", "abcd", 4);
}
}
Producción:
2. Usando el método createDirectory() del paquete java.nio
Este enfoque utiliza el paquete java.nio para implementar el código. Desplegamos el método createDirectories() aquí para crear nuevos directorios. También hacemos uso del bloque try-catch para detectar errores de E/S. El algoritmo se puede encontrar a continuación.
Algoritmo:
- Repita los pasos del 1 al 6 como se menciona en el algoritmo del enfoque 1.
- Ahora, convierta la string md a Path Instance usando el método Path.gets().
- Nuevamente, verifique si el Directorio ya existe usando el método exist().
- Si el Directorio no está presente, abra un bloque try-catch y cree un nuevo directorio usando el método createDirectories().
- De lo contrario, muestra que el Directorio ya existe.
- Hacer la llamada recursiva
A continuación se muestra la implementación del programa anterior.
Java
// Java code to create directories recursively
// importing the packages
import java.nio.file.Paths;
import java.nio.file.Path;
import java.nio.file.Files;
import java.io.IOException;
class GFG {
// defining the recursive method
static void file(String md, String path, int depth)
{
// base case
if (depth == 0)
return;
// decrement the depth
depth -= 1;
// check if the path is empty
if (path.length() == 0)
System.out.println("Path does not exist");
else {
// appending the first character from
// path string
md = md + "/" + path.charAt(0);
// removing the first character from
// path string
path = path.substring(1);
// creating the path instance from
// path string
Path p = Paths.get(md);
// if the directory already exists
if (!Files.exists(p)) {
try {
// creating directory
Files.createDirectories(p);
System.out.println(md + " created"
+ " successfully");
}
catch (IOException err) {
err.printStackTrace();
}
}
else
System.out.println("The directory "
+ "already exists");
}
// recursive call
file(md, path, depth);
}
// Driver Code
public static void main(String[] args)
{
// creating the object of the class
GFG ob = new GFG();
// md would be -> "C:\\Users\\harshit\\
// Desktop for windows
ob.file("/home/mayur/Desktop", "klm", 5);
}
}
Producción:
Publicación traducida automáticamente
Artículo escrito por ag01harshit y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA