Hay varias formas presentes en java para leer el archivo de texto como BufferReader , FileReader y Scanner . Todos y cada uno de los métodos proporcionan una forma única de leer el archivo de texto.
Métodos:
- Usando la clase de archivos
- Usando la clase FileReader
- Usando la clase BufferReader
- Usando la clase de escáner
Veamos todos y cada uno de los métodos en detalle con un ejemplo para entender mejor los métodos para, posteriormente, implementar los mismos para extraer el contenido de un documento de texto.
Método 1: Usando la clase de Archivos
Como Java proporciona java.nio.file . API podemos usar la clase java.nio.file.Files para leer todo el contenido de un archivo en una array. Para leer un archivo de texto, podemos usar el método readAllBytes() de la clase Files con el que se usa este método, cuando necesita todo el contenido del archivo en la memoria, así como cuando está trabajando en archivos pequeños.
Ejemplo:
Java
// Java Program to Extract Content From a Text Document
// Using Files class
// Importing java.nio package for network linking
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
// Importing List class from java.util package
import java.util.List;
// Main class
public class GFG {
// Method 1
// To read the file using class
private static void readUsingClass(String fileName)
throws IOException
{
// Creating an object of Path class
Path path = Paths.get(fileName);
// To read file to byte array
byte[] bytes = Files.readAllBytes(path);
// Display message only
System.out.println(
"Read text file using Files class");
// Reading the file to String List
@SuppressWarnings("unused")
// Creating a List class object of string type
// as data in file to be read is words
List<String> allLines = Files.readAllLines(
path, StandardCharsets.UTF_8);
System.out.println(new String(bytes));
}
// Method 2
// Main driver method
public static void main(String[] args)
throws IOException
{
// Custom input directory passed where text
String fileName
= "/Users/mayanksolanki/Desktop/file.txt";
// read using FileReader, no encoding support, not
// efficient
readUsingClass(fileName);
}
}
Producción:
Método 2: Usar la clase FileReader
Podemos usar java.io.FileReader se puede usar para leer datos (en caracteres) de archivos. Este es un método muy eficiente para leer el archivo línea por línea.
Sintaxis:
FileReader input = new FileReader(String name);
Ejemplo:
Java
// Java Program to Extract Content From a Text Document
// Using FileReader class
// Importing required libraries
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
// Main class
public class GFG {
// Method
// To read the file using File Reader
private static void readUsingFileReader(String fileName)
throws IOException
{
File file = new File(fileName);
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
String line;
System.out.println(
"Reading text file using FileReader");
while ((line = br.readLine()) != null) {
// process the line
System.out.println(line);
}
br.close();
fr.close();
}
// Method 2
// Main driver method
public static void main(String[] args)
throws IOException
{
String fileName
= "/Users/mayanksolanki/Desktop/file.txt";
// read using FileReader, no encoding support, not
// efficient
readUsingFileReader(fileName);
}
}
Producción:
Método 3: usar la clase BufferedReader
Si desea leer el archivo línea por línea y si desea procesar en ese archivo, debe usar BufferedReader. También se usa para procesar el archivo grande y también admite la codificación. La operación de lectura es muy eficiente en BufferReader.
Nota: Especifique el tamaño de BufferReader o mantenga el tamaño predeterminado de BufferReader, que es de 8 KB.
Sintaxis:
BufferedReader in = new BufferedReader(Reader in, int size);
Implementación:
Hello I am learning web- development. I am writing article for GFG. I am cloud enthusiast. I am an open-source contributor.
Nota: Antes de comenzar, cree un archivo de texto usando la extensión .txt en su máquina local y use la ruta de ese archivo siempre que lo necesite mientras practica.
Ejemplo:
Java
// Java Program to Extract Content From a Text Document
// Using BufferedReader class
// Importing required libraries
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
// Main class
public class GFG {
// Method
// To read the file using Buffered Reader
private static void
readUsingBufferedReader(String fileName)
throws IOException
{
File file = new File(fileName);
FileReader fr = new FileReader(file);
// read file line by line
BufferedReader br = new BufferedReader(fr);
String line;
System.out.println(
"Read text file using BufferedReader");
while ((line = br.readLine()) != null) {
// process the line
System.out.println(line);
}
// close resources
br.close();
fr.close();
}
// Method 2
// Main driver method
public static void main(String[] args)
throws IOException
{
String fileName
= "/Users/mayanksolanki/Desktop/file.txt";
// read using FileReader, no encoding support, not
// efficient
readUsingBufferedReader(fileName);
}
}
Producción:
Método 4: Usar la clase Scanner
Si queremos leer el documento en función de alguna expresión y si desea leer el documento línea por línea, usamos la clase Scanner. Un escáner divide la entrada en tokens, que por defecto coincide con el espacio en blanco.
Ejemplo :
Java
// Java Program to Extract Content From a Text Document
// Using Scanner class
// Importing required libraries
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;
// Main class
public class GFG {
// Method 1
// To read the file using Scanner
private static void readUsingScanner(String fileName)
throws IOException
{
// Again, creating Path class object in main()
// method
Path path = Paths.get(fileName);
// Creating Scanner class object to take input
Scanner scanner = new Scanner(path);
// Display message for readability
System.out.println("Read text file using Scanner");
// Now reading file line by line
// using hasNextLine() method
while (scanner.hasNextLine()) {
// Processing each line
String line = scanner.nextLine();
// Printing processed lines
System.out.println(line);
}
// close() method is used to close all the read
// write connections
scanner.close();
}
// Method 2
// Main driver method
public static void main(String[] args)
throws IOException
{
// Custom input text document
// present already on the machine
String fileName
= "/Users/mayanksolanki/Desktop/file.txt";
// Now lastly reading using FileReader
// no encoding support, not efficient
readUsingScanner(fileName);
}
}
Producción:
Implementación:
Aquí » my_file.txt» es un archivo de demostración utilizado para el programa que se muestra a continuación, donde las líneas de muestra son las siguientes:
Hello I am learning web- development. I am writing article of GFG. I am cloud enthusiast. I am an open-source contributor.
Ejemplo 1:
Java
// Java Program to Implement Extraction of Content
// From a Text Document
// Importing required libraries
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Scanner;
// Main class
public class read_file {
// Method 1
// To read the file using File Reader
private static void readUsingFileReader(String fileName)
throws IOException
{
File file = new File(fileName);
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
String line;
System.out.println(
"Reading text file using FileReader");
while ((line = br.readLine()) != null) {
// process the line
System.out.println(line);
}
br.close();
fr.close();
}
// Method 2
// To read the file using Buffered Reader
private static void
readUsingBufferedReader(String fileName)
throws IOException
{
File file = new File(fileName);
FileReader fr = new FileReader(file);
// read file line by line
BufferedReader br = new BufferedReader(fr);
String line;
System.out.println(
"Read text file using BufferedReader");
while ((line = br.readLine()) != null) {
// process the line
System.out.println(line);
}
// Closing resources to
// release memory spaces
br.close();
fr.close();
}
// Method 3
// To read the file using Scanner
private static void readUsingScanner(String fileName)
throws IOException
{
Path path = Paths.get(fileName);
Scanner scanner = new Scanner(path);
System.out.println("Read text file using Scanner");
// read line by line
while (scanner.hasNextLine()) {
// process each line
String line = scanner.nextLine();
System.out.println(line);
}
scanner.close();
}
// Method 4
// To read the file using class
private static void readUsingClass(String fileName)
throws IOException
{
Path path = Paths.get(fileName);
// read file to byte array
byte[] bytes = Files.readAllBytes(path);
System.out.println(
"Read text file using Files class");
// read file to String list
@SuppressWarnings("unused")
List<String> allLines = Files.readAllLines(
path, StandardCharsets.UTF_8);
System.out.println(new String(bytes));
}
// Method 5
// main driver method
public static void main(String[] args)
throws IOException
{
String fileName
= "C:\\Users\\HP\\Desktop\\my_file.txt";
// using Java 7 Files class to
// process small files, get complete file data
readUsingClass(fileName);
// using Scanner class for
// large files, to read line by line
readUsingScanner(fileName);
// read using BufferedReader, to read line by line
readUsingBufferedReader(fileName);
// read using FileReader, no encoding support, not
// efficient
readUsingFileReader(fileName);
}
}
Ejemplo 2: lectura de líneas específicas de un archivo de texto
Ahora, si desea leer las líneas específicas del documento dado, usamos el método BufferReader. Dependiendo del archivo, se utiliza el método BufferReader() para que nuestro código funcione de manera más rápida y eficiente. En este programa, el archivo de texto almacenado en BufferReader es un recorrido a través de todas las líneas usando for loop, y cuando la condición se vuelve verdadera, imprimiremos esas líneas
Implementación:
“ myfile.txt ” es el archivo de demostración que se utilizará.
Estas son las líneas de muestra contenidas en este archivo que consta de palabras arbitrarias aleatorias compuestas en líneas
La impresión 3D o fabricación aditiva es un proceso de creación de objetos sólidos tridimensionales a partir de un archivo digital.
La creación de un objeto impreso en 3D se logra mediante procesos aditivos. En un proceso aditivo, se crea un objeto colocando capas sucesivas de material hasta que se crea el objeto. Cada una de estas capas se puede ver como una sección transversal del objeto en rodajas finas.
La impresión 3D es lo opuesto a la fabricación sustractiva, que consiste en cortar/ahuecar una pieza de metal o plástico con, por ejemplo, una fresadora.
La impresión 3D le permite producir formas complejas.
Utiliza menos material que los métodos de fabricación tradicionales.
Java
// Java program to Read Specific Lines from a Text File
// Importing required libraries
import java.io.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Initially taking empty string
String text = "";
// Declaring a variable to lookup for
// number of lines in afile
int lineNumber;
// Try block to check for exceptions
try {
// Creating a FileReader object so as to
// get the directory of file to be read
FileReader readfile = new FileReader(
"C:\\Users\\HP\\Desktop\\Exam.txt");
// Creating a BufferReader class object to
// read file as passed above
BufferedReader readbuffer
= new BufferedReader(readfile);
// Buffer reader declaration
// Conditionality for specific line/s
// Loop for the traversing line by line
// into the text file
for (lineNumber = 1; lineNumber < 10;
lineNumber++) {
// If spefic line/s is found
if (lineNumber == 7) {
// Store the content of this specific
// line
text = readbuffer.readLine();
}
else {
// Just keep on reading
readbuffer.readLine();
}
}
}
// Catching IOException exception
catch (IOException e) {
// Print the line number where exception occurred
e.printStackTrace();
}
// Print the specific line from the file read
System.out.println(" The specific Line is: "
+ text);
}
}
Salida: La línea específica es:
3D printing enables you to produce complex shapes.
Publicación traducida automáticamente
Artículo escrito por manastole01 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA