Leer archivo en una array en Java

En Java, podemos almacenar el contenido del archivo en una array leyendo el archivo usando un escáner o bufferedReader o FileReader o usando el método readAllLines. Para almacenar el contenido del archivo, utilice mejor el tipo de almacenamiento de colección en lugar de una array estática, ya que no conocemos las líneas exactas ni el recuento de palabras de los archivos. Luego convierta el tipo de colección a la array según el requisito.

• Para leer el contenido del archivo, primero debemos crear un archivo con algo de texto. Consideremos que el siguiente texto está presente en el archivo llamado file.txt

Geeks,for
Geeks
Learning portal

Existen principalmente 4 enfoques para leer el contenido del archivo y almacenarlo en la array. Se mencionan a continuación-

1. Usando BufferedReader para leer el archivo
2. Uso del escáner para leer el archivo
3. método readAllLines()
4. Uso de FileReader

1. Usando BufferedReader para leer el archivo

Fue la forma más fácil para los desarrolladores de codificarlo para obtener el contenido del archivo y también es una forma preferida de leer el archivo porque requiere menos llamadas de lectura de números porque usa un búfer de caracteres que lee simultáneamente múltiples valores de una entrada de caracteres. corriente.

Sintaxis:

BufferedReader bf=new BufferedReader (new FileReader(filename))

BufferedReader también proporciona un método llamado readLine que toma la línea completa de un archivo como una string.

A continuación se muestra el código de ejemplo para almacenar el contenido del archivo en una array.

Ejemplo:

// import necessary packages
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
public class GFG {
    // to handle exceptions include throws
    public static void main(String[] args)
        throws IOException
    {
        // list that holds strings of a file
        List<String> listOfStrings
            = new ArrayList<String>();
       
        // load data from file
        BufferedReader bf = new BufferedReader(
            new FileReader("file.txt"));
       
        // read entire line as string
        String line = bf.readLine();
       
        // checking for end of file
        while (line != null) {
            listOfStrings.add(line);
            line = bf.readLine();
        }
       
        // closing bufferreader object
        bf.close();
       
        // storing the data in arraylist to array
        String[] array
            = listOfStrings.toArray(new String[0]);
       
        // printing each line of file
        // which is stored in array
        for (String str : array) {
            System.out.println(str);
        }
    }
}

Producción:

Geeks,for
Geeks
Learning portal

Explicación: en este código, usamos BufferedReader para leer y cargar el contenido de un archivo, y luego usamos el método readLine para obtener cada línea del archivo como una string y almacenarla/agregarla en ArrayList y finalmente convertimos esa ArrayList en Array utilizando el método toArray.

Pero para especificar cualquier delimitador para separar datos en un archivo, en ese caso, un escáner será útil. Como podemos ver, hay 2 strings en la primera línea de un archivo, pero al usar BufferedReader las obtuvimos como una string combinada.

Nota: Mientras lee el archivo, si el archivo está en la misma ubicación donde se guardó el código del programa, no es necesario mencionar la ruta, solo especifique el nombre del archivo. Si el archivo está en una ubicación diferente con respecto a la ubicación guardada del programa, debemos especificar la ruta junto con el nombre del archivo.

2. Uso del escáner para leer el archivo 

El escáner se utiliza principalmente para leer datos de usuarios para tipos de datos primitivos. Pero incluso para obtener datos de un archivo, Scanner puede usarse junto con File o FileReader para cargar datos de un archivo. Este analizador generalmente divide los tokens en strings mediante un espacio delimitador predeterminado, pero incluso podemos especificar explícitamente los otros delimitadores utilizando el método useDelimiter.

Sintaxis:

Scanner sc = new Scanner(new FileReader("filename")).useDelimiter("delimiter to separate strings");

El escáner está presente en el paquete util que debemos importar antes de usarlo y también proporciona readLine() y hasNext() para verificar el final del archivo, es decir, si hay strings disponibles o no para leer.

A continuación se muestra el código de ejemplo para almacenar el contenido del archivo en una array utilizando Scanner.

Ejemplo:

// import necessary packages
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class GFG {
    // include throws to handle some file handling exceptions
    public static void main(String[] args)
        throws IOException
    {
        // arraylist to store strings
        List<String> listOfStrings
            = new ArrayList<String>();
       
        // load content of file based on specific delimiter
        Scanner sc = new Scanner(new FileReader("file.txt"))
                         .useDelimiter(",\\s*");
        String str;
       
        // checking end of file
        while (sc.hasNext()) {
            str = sc.next();
           
            // adding each string to arraylist
            listOfStrings.add(str);
        }
       
        // convert any arraylist to array
        String[] array
            = listOfStrings.toArray(new String[0]);
       
        // print each string in array
        for (String eachString : array) {
            System.out.println(eachString);
        }
    }
}

 
Producción

Geeks
for
Geeks
Learning portal

Explicación: En este código, usamos Scanner para leer y cargar el contenido del archivo, y aquí existe la flexibilidad de especificar el delimitador usando el método useDelimiter para que podamos separar strings según el delimitador y cada una de estas strings separadas según El delimitador se almacena/agrega en ArrayList y podemos verificar EOF usando el método hasNext. Finalmente, convertimos ese ArrayList en Array usando el método toArray.

Como especificamos el valor del delimitador como «,» (coma), obtuvimos 2 strings separadas geeks y for. Si no especificamos ningún método delimitador para Scanner, separará las strings en función de los espacios.

Nota: hay otro método llamado readAllLines presente en el uso de la clase Files para leer el contenido del archivo línea por línea

3. método readAllLines()

Para usar esto primero, necesitamos importar clases de archivos y rutas desde el paquete de archivos. El beneficio de usar este método es que reduce las líneas de código para obtener y almacenar datos. La sintaxis de esto se menciona a continuación:

FIles.readAllLines(Paths("filename"))

A continuación se muestra el código para cargar el contenido del archivo y almacenarlo en una array utilizando el método readAllLines.

Ejemplo:

// import necessary packages and classes
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
 
public class Box {
    // add throws to main method to handle exceptions
    public static void main(String[] args)
        throws IOException
    {
        List<String> listOfStrings
            = new ArrayList<String>();
       
        // load the data from file
        listOfStrings
            = Files.readAllLines(Paths.get("file.txt"));
       
        // convert arraylist to array
        String[] array
            = listOfStrings.toArray(new String[0]);
       
        // print each line of string in array
        for (String eachString : array) {
            System.out.println(eachString);
        }
    }
}

Producción

Geeks,for
Geeks
Learning portal

Explicación: aquí usamos el método readAllLines para obtener cada línea en un archivo y devolver una lista de strings. Esta lista se convierte en una array mediante el método toArray. 

4. Uso de FileReader

Usando FileReader podemos cargar los datos en el archivo y podemos leer datos de caracteres del objeto FileReader. Antes de usar FIleReader en un programa, necesitamos importar la clase FileReader del paquete io.

Sintaxis:

FileReader filereaderObj=new FileReader("filename");

Veamos el siguiente código de ejemplo para leer datos de un archivo y almacenarlos en una array usando FileReader.

Ejemplo:

// import necessary packages
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
class GFG {
    // to handle exceptions include throws
    public static void main(String[] args)
        throws IOException
    {
        // list that holds strings of a file
        List<String> listOfStrings
            = new ArrayList<String>();
       
        // load data from file
        FileReader fr = new FileReader("file.txt");
       
        // Created a string to store each character
        // to form word
        String s = new String();
        char ch;
       
        // checking for EOF
        while (fr.ready()) {
            ch = (char)fr.read();
               
            // Used to specify the delimiters
            if (ch == '\n' || ch == ' ' || ch == ',') {
               
                // Storing each string in arraylist
                listOfStrings.add(s.toString());
               
                // clearing content in string
                s = new String();
            }
            else {
                // appending each character to string if the
                // current character is not delimiter
                s += ch;
            }
        }
        if (s.length() > 0) {
           
            // appending last line of strings to list
            listOfStrings.add(s.toString());
        }
        // storing the data in arraylist to array
        String[] array
            = listOfStrings.toArray(new String[0]);
       
        // printing each line of file which is stored in
        // array
        for (String str : array) {
            System.out.println(str);
        }
    }
}

 Producción

Geeks
for
Geeks
Learning
portal

Explicación: en este código, usamos FileReader para cargar datos de un archivo en su objeto. Este objeto contiene datos como un flujo de caracteres y podemos obtener datos de él carácter por carácter. Así que almacenamos cada carácter en una string y si el carácter obtenido fue un delimitador, es decir, especificado en la instrucción if [\n, (espacio) ‘ ‘, (coma) ‘,’] entonces almacenamos esa string en ArrayList y borramos el contenido en la string si no, agregue ese carácter a la string. Así, almacenamos todas las strings en un archivo en un ArrayList y esto se convierte en Array.

Estos son todos los enfoques posibles que se pueden seguir para leer datos de archivos y almacenarlos en la array.