Hay múltiples formas de escribir y leer un archivo de texto. Esto es necesario al tratar con muchas aplicaciones. Hay varias formas de leer un archivo de texto sin formato en Java, por ejemplo, puede usar FileReader , BufferedReader o Scanner para leer un archivo de texto.
Dado un archivo de texto, la tarea es leer el contenido de un archivo presente en un directorio local y almacenarlo en una string. Considere un archivo presente en el sistema, digamos que sea ‘gfg.txt’. Deje que el contenido aleatorio en el archivo sea como se inserta a continuación en el bloque de etiquetas previas. Ahora discutiremos varias formas de lograr lo mismo. El contenido dentro del archivo ‘gfg.txt’ es como se muestra en el bloque de ilustración.
Ilustración: Líneas dentro del archivo
Geeks-for-Geeks A computer science portal World's largest technical hub
Nota: Guarde el archivo de texto anterior en su computadora local con la extensión .txt y use esa ruta en los programas.
Métodos:
Hay varias formas de lograr el objetivo y con el avance de la versión en Java, se presentan métodos específicos que se discuten secuencialmente.
Métodos:
- Usando el método File.readString()
- Usando el método readLine() de la clase BufferReader
- Usando el método File.readAllBytes()
- Usando el método File.lines()
- Usando la clase de escáner
Discutamos cada uno de ellos implementando programas java limpios para comprenderlos.
Método 1: Usar el método File.readString()
El método readString() de File Class en Java se usa para leer el contenido del archivo especificado.
Sintaxis:
Files.readString(filePath) ;
Parámetros: ruta de archivo con tipo de datos como ruta
Valor devuelto: este método devuelve el contenido del archivo en formato de string.
Nota: El método File.readString() se introdujo en Java 11 y este método se usa para leer el contenido de un archivo en String.
Ejemplo
Java
// Java Program Illustrating Reading a File to a String
// Using File.readString() method
// Importing required classes
import java.io.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
throws IOException
{
// Creating a path choosing file from local
// directory by creating an object of Path class
Path fileName
= Path.of("C:\\Users\\HP\\Desktop\\gfg.txt");
// Now calling Files.readString() method to
// read the file
String str = Files.readString(fileName);
// Printing the string
System.out.println(str);
}
}
Producción:
Geeks-for-Geeks A computer science portal World's largest technical hub
Método 2: Usando el método readLine() de la clase BufferReader
BufferedReader es un objeto que se utiliza para leer texto de un flujo de entrada de caracteres. El método readLine() presente en el método BufferReader se usa para leer el archivo una línea a la vez y devolver el contenido.
Sintaxis:
public String readLine() throws IOException
Parámetros: Este método no acepta ningún parámetro.
Valor devuelto: este método devuelve la string que lee este método y excluye cualquier símbolo de terminación disponible. Si la secuencia almacenada en búfer ha finalizado y no hay ninguna línea para leer, este método devuelve NULL.
Excepciones: este método lanza IOException si ocurre un error de E/S.
Ejemplo
Java
// Java Program Illustrating Reading a File to a String
// Using readLine() method of BufferReader class
// Importing required classes
import java.io.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
// MAin class
public class GFG {
// Method 1
// To read file content into the string
// using BufferedReader and FileReader
private static String method(String filePath)
{
// Declaring object of StringBuilder class
StringBuilder builder = new StringBuilder();
// try block to check for exceptions where
// object of BufferedReader class us created
// to read filepath
try (BufferedReader buffer = new BufferedReader(
new FileReader(filePath))) {
String str;
// Condition check via buffer.readLine() method
// holding true upto that the while loop runs
while ((str = buffer.readLine()) != null) {
builder.append(str).append("\n");
}
}
// Catch block to handle the exceptions
catch (IOException e) {
// Print the line number here exception occurred
// using printStackTrace() method
e.printStackTrace();
}
// Returning a string
return builder.toString();
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Custom input file path stored in string type
String filePath = "C:\\Users\\HP\\Desktop\\gfg.txt";
// Calling the Method 1 to
// read file to a string
System.out.println(method(filePath));
}
}
Producción:
Geeks-for-Geeks A computer science portal World's largest technical hub
Método 3: Usar el método File.readAllBytes()
El método File.readAllBytes() se usa para leer todos los bytes de un archivo. El método garantiza que el archivo se cierre cuando se hayan leído todos los bytes o se produzca un error de E/S u otra excepción de tiempo de ejecución. Después de leer todos los bytes, pasamos esos bytes al constructor de la clase de string para crear una string.
Sintaxis:
public static byte[] ReadAllBytes (string path);
Parámetro: Ruta que es el archivo especificado para abrir para lectura.
Acercarse:
- Declarar una string vacía
- El método get() de la clase Path ayuda a recuperar el archivo pasándolo como argumento.
- Ahora se usa el método readAllBytes() de la clase File para leer el archivo anterior pasándolo.
- Por último, imprima la string.
Excepciones:
- ArgumentException: la ruta es una string de longitud cero, contiene solo espacios en blanco o uno o más caracteres no válidos según lo definido por InvalidPathChars.
- ArgumentNullException: la ruta es nula.
- PathTooLongException: la ruta especificada , el nombre de archivo o ambos superan la longitud máxima definida por el sistema.
- DirectoryNotFoundException: la ruta especificada no es válida.
- IOException: se produjo un error de E/S al abrir el archivo.
- UnauthorizedAccessException: esta operación no se admite en la plataforma actual. O la ruta especifica un directorio. O la persona que llama no tiene el permiso requerido.
- FileNotFoundException: no se encontró el archivo especificado en la ruta .
- NotSupportedException: la ruta tiene un formato no válido.
- SecurityException: la persona que llama no tiene el permiso necesario.
Ejemplo
Java
// Java Program Illustrating Reading a File to a String
// Using File.readAllBytes() method
// Importing required classes
import java.io.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
// Main class
public class GFG {
// Method 1
// To read the file content into string with
// Files.readAllBytes(Path path)
private static String method(String file_path)
{
// Declaring an empty string
String str = "";
// Try block to check for exceptions
try {
// Reading all bytes form file and
// storing that in the string
str = new String(
Files.readAllBytes(Paths.get(file_path)));
}
// Catch block to handle the exceptions
catch (IOException e) {
// Print the exception along with line number
// using printStackTrace() method
e.printStackTrace();
}
return str;
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Path is passed from local directory of machine
// and stored in a string
String filePath = "C:\\Users\\HP\\Desktop\\gfg.txt";
// Now call Method1 to
// read the content in above directory
System.out.println(method(filePath));
}
}
Producción:
Geeks-for-Geeks A computer science portal World's largest technical hub
Método 4: Usar el método File.lines()
El método File.lines() se usa para leer todas las líneas de un archivo para transmitir. Luego, los bytes del archivo se decodifican en caracteres usando el conjunto de caracteres especificado como UTF_8.
Sintaxis:
public static Stream<String> lines(Path path, Charset cs) throws IOException
Parámetros: Generalmente toma dos parámetros:
- Juego de caracteres que se usará para decodificar.
- Ruta del archivo.
Tipo de devolución: las líneas del archivo como una string.
Ejemplo
Java
// Java Program Illustrating Reading a File to a String
// Using File.lines() method
// Importing required classes
import java.io.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;
// Main class
public class GFG {
// Method 1
// To read the file content into the string with -
// Files.lines()
private static String method(String filePath)
{
// Declaring an object of StringBuilder class
StringBuilder contentBuilder = new StringBuilder();
// try block to check for exceptions
// Reading file to string using File.lines() method
// and storing it in an object of Stream class
try (Stream<String> stream
= Files.lines(Paths.get(filePath),
StandardCharsets.UTF_8)) {
stream.forEach(
s -> contentBuilder.append(s).append("\n"));
}
// Catch block to handle the exceptions
catch (IOException e) {
// Print the line number where exception occurred
// using printStackTrace() method
e.printStackTrace();
}
// Returning the string builder by
// calling tostring() method
return contentBuilder.toString();
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Custom file path is stored as as string
String filePath = "C:\\Users\\HP\\Desktop\\gfg.txt";
// Calling method 1 to read content of a file
System.out.println(method(filePath));
}
}
Producción:
Geeks-for-Geeks A computer science portal World's largest technical hub
Método 5: Usar el método next() y hasNext() de la clase Scanner
La clase Scanner funciona dividiendo la entrada en tokens que se recuperan secuencialmente del flujo de entrada. La clase Scanner tiene dos métodos de compilación llamados next() y hasNext(). Ambos métodos integrados devuelven objetos de tipo String.
Ejemplo
Java
// Java Program Illustrating Reading a File to a String
// Using next() and hasNext() method of Scanner class
// Importing required classes
import java.io.*;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Scanner;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
throws IOException
{
// Creating object of Path class where custom local
// directory path is passed as arguments using .of()
// method
Path fileName
= Path.of("C:\\Users\\HP\\Desktop\\gfg.txt");
// Creating an object of Scanner class
Scanner sc = new Scanner(fileName);
// It holds true till there is single element left
// via hasNext() method
while (sc.hasNext()) {
// Iterating over elements in object
System.out.println(sc.next());
}
// Closing scanner class object to avoid errors and
// free up memory space
sc.close();
}
}
Producción:
Geeks-for-Geeks A computer science portal World's largest technical hub
Publicación traducida automáticamente
Artículo escrito por manastole01 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA