Ruta del archivo en Java

1. Lectura de un archivo Java
2. Cómo especificar la ruta del archivo en Java
3. Cómo obtener la ruta del archivo en Java
4. Conclusión

Al trabajar con archivos en Java, es importante especificar el nombre de archivo correcto y la ruta y extensión correctas.

Los archivos con los que estamos trabajando pueden estar presentes en el mismo u otro directorio. Dependiendo de la ubicación del archivo, el nombre de la ruta cambia.

Este artículo discutirá cómo acceder y especificar rutas de archivos en Java.

Lectura de un archivo Java

Leer un archivo significa obtener el contenido de un archivo. Usamos la clase Java Scanner para leer un archivo. Entendamos esto a través de un ejemplo.

Primero escribiremos un programa Java para crear un nuevo archivo. Luego, escribiremos otro programa Java para agregar algo de contenido a este archivo recién creado.

Finalmente, leeremos el contenido de este archivo. Tenga en cuenta que ninguno de los programas de este artículo se ejecutará en un compilador en línea (utilice un compilador fuera de línea con la ruta configurada correctamente).

Crear un archivo

import java.io.File;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    // Try catch block
    try {
      // Creating a file with the name demofile.txt
      File myFile = new File("demofile.txt");

      if (myFile.createNewFile()) {
        System.out.println("The file is created with the name: " + myFile.getName());
      } else {
        System.out.println("The file already exists.");
      }
    } catch (IOException x) {
      System.out.println("An error is encountered.");
      x.printStackTrace();
    }
  }
}

Producción :

The file is created with the name: demofile.txt

Este archivo se crea en el mismo directorio donde están presentes los archivos Java. Todos los archivos de programa de Java están en el directorio C.

Agregar algo de contenido al archivo

import java.io.FileWriter;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    try {
      // create an object
      FileWriter writeInFile = new FileWriter("demofile.txt");

      // Adding content to this file
      writeInFile.write("We are learning about paths in Java.");

      writeInFile.close();
      System.out.println("Successfully done!");
    } catch (IOException x) {
      System.out.println("An error is encountered.");
      x.printStackTrace();
    }
  }
}

Producción :

Successfully done!

Leer el archivo

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner; //scanner class for reading the file

public class Main {
  public static void main(String[] args) {
    try {
      File myFile = new File("demofile.txt");

      // create the scanner object
      Scanner readFile = new Scanner(myFile);

      while (readFile.hasNextLine()) {
        String data = readFile.nextLine();
        System.out.println(data);
      }
      readFile.close();
    } catch (FileNotFoundException x) {
      System.out.println("An error occurred.");
      x.printStackTrace();
    }
  }
}

Producción :

We are learning about paths in Java.

Tenga en cuenta que aquí, dentro del método File(), solo pasamos el nombre del archivo con su extensión.

No estamos especificando la ruta completa del demofile.txt. El demofile.txt está presente en el mismo directorio y carpeta donde guardamos todos estos archivos de programa Java.

Sin embargo, si el demofile.txt está presente en otro directorio o carpeta, leer este archivo no es tan sencillo. En tales casos, especificamos la ruta completa del archivo.

Para obtener más detalles sobre el sistema de archivos en Java, consulte esta documentación.

Cómo especificar la ruta del archivo en Java

Para especificar la ruta de un archivo, pasamos el nombre del archivo con su extensión dentro del método File(). Lo hacemos así.

new File("demofile.txt")

Tenga en cuenta que el nombre del archivo es suficiente solo cuando el archivo está en la misma carpeta que el directorio del proyecto de trabajo. De lo contrario, tenemos que especificar la ruta completa del archivo.

Si no conoce el nombre del archivo, utilice el método list(). Este método devuelve la lista de todos los archivos en el directorio actual.

Presente en la clase File de la biblioteca java.io, el método list() devuelve la lista de todos los archivos y directorios en forma de matriz. La salida que devuelve se basa en el directorio actual definido por un nombre de ruta abstracto.

Si la ruta de acceso abstracta no indica un directorio, el método list() devuelve null. A veces, no sabemos dónde se encuentra el archivo.

Además, se producen errores cuando el archivo que tenemos que leer no está presente en el directorio de trabajo actual. Usar la ruta completa del archivo es mejor para evitar estos problemas.

Para obtener la ruta exacta de un archivo, utilice los métodos que se indican a continuación.

Cómo obtener la ruta del archivo en Java

Cuando no sabemos la ruta de un archivo, podemos usar algunos métodos de Java para encontrar la ruta de un archivo. Luego, podemos especificar este nombre de ruta como argumento.

Java proporciona tres tipos de rutas de archivo: absoluta, canónica y abstracta. La clase java.io.file tiene tres métodos para encontrar la ruta de un archivo.

Obtenga la ruta del archivo usando el método getPath() en Java

El método getPath() pertenece a la clase File de Java. Devuelve la ruta del archivo abstracto como una cadena.

Un nombre de ruta abstracto es un objeto de java.io.file, que hace referencia a un archivo en el disco.

Sintaxis:

file.getPath()

Ejemplo:

import java.io.*;
public class Main {
  public static void main(String args[]) {
    try {
      // create an object
      File myFile = new File("demo.txt");

      // call the getPath() method
      String path = myFile.getPath();
      System.out.println("The path of this file is: " + path);
    } catch (Exception e) {
      System.err.println(e.getMessage());
    }
  }
}

Producción :

The path of this file is: demo.txt

Como puede ver en el resultado anterior, solo el nombre del archivo con la extensión es el resultado. Esto muestra que el archivo está presente en la misma carpeta donde está el archivo del programa Java.

Obtenga la ruta del archivo usando el método getAbsolutePath() en Java

El método getAbsolutePath() devuelve una cadena como ruta absoluta del archivo. Si creamos el archivo con una ruta absoluta, entonces el método getAbsolutePath() devuelve la ruta.

Sin embargo, si creamos el objeto usando una ruta relativa, el método getAbsolutePath() resuelve la ruta dependiendo del sistema. Está presente en la clase File de Java.

Sintaxis:

file.getAbsolutePath()

Tenga en cuenta que la ruta absoluta es la ruta que brinda la URL completa del archivo presente en el sistema, independientemente del directorio en el que se encuentre. Por otro lado, la ruta relativa brinda la ruta del archivo al directorio actual.

Ejemplo:

// import the java.io library
import java.io.*;

public class Main {
  public static void main(String args[]) {
    // try catch block
    try {
      // create the file object
      File myFile = new File("pathdemo.txt");

      // call the getAbsolutePath() method
      String absolutePath = myFile.getAbsolutePath();

      System.out.println("The Absolute path of the file is: " + absolutePath);
    } catch (Exception e) {
      System.err.println(e.getMessage());
    }
  }
}

Producción :

The Absolute path of the file is: C:\Users\PC\pathdemo.txt

Tenga en cuenta que esta vez obtenemos la ruta de trabajo completa, comenzando desde el directorio de trabajo actual hasta la carpeta actual en la que está presente el archivo.

Por lo tanto, siempre que no conozca la ubicación de ningún archivo, use el método de ruta absoluta para encontrar dónde está presente el archivo. Luego, puede especificar esa ruta cada vez que tenga que leer ese archivo.

De esta manera, el archivo a leer se encontraría fácilmente.

Obtenga la ruta del archivo usando el método getCanonicalPath() en Java

Presente en la clase Path devuelve la ruta canónica de un archivo. Si el nombre de la ruta es canónico, entonces el método getCanonicalPath() devuelve la ruta del archivo.

El camino canónico es siempre único y absoluto. Además, este método elimina cualquier . o .. del camino.

Sintaxis:

file.getCanonicalPath()

Ejemplo:

// import the java.io library
import java.io.*;

public class Main {
  public static void main(String args[]) {
    // try catch block
    try {
      // create the file object
      File myFile = new File("C:\\Users");

      // call the getCanonicalPath() method
      String canonical = myFile.getCanonicalPath();

      System.out.println("The Canonical path is : " + canonical);
    } catch (Exception x) {
      System.err.println(x.getMessage());
    }
  }
}

Producción :

The Canonical path is:C:\Users

Para obtener más información sobre rutas en Java, consulte esta documentación.

Conclusión

En este artículo vimos cómo podíamos especificar la ruta de un archivo si tenemos que leerlo. También estudiamos los diversos métodos como getPath(), getAbsolutePath() y getCanonical() que proporciona Java para obtener la ruta de un archivo.

Además, vimos cómo cambia la ruta según el directorio y la carpeta del archivo y el proyecto actual. También creamos y leímos algunos archivos como demostración.

Sin embargo, estos programas no se ejecutarán en compiladores en línea.