BufferedReader: lee varias líneas en una sola cadena

Question

Estoy leyendo números de un archivo txt usando BufferedReader para su análisis. La forma en que voy de esto ahora es- leer una línea usando .readline, partiendo esta cadena en una matriz de cadenas usando .split

public InputFile() { 
    fileIn = null; 

    //stuff here 

    fileIn = new FileReader((filename + ".txt")); 
    buffIn = new BufferedReader(fileIn); 


    return; 
    //stuff here 
} 

---

public String ReadBigStringIn() { 
    String line = null; 

    try { line = buffIn.readLine(); } 
    catch(IOException e){}; 

    return line; 
} 

---

public ProcessMain() { 
    initComponents(); 
    String[] stringArray; 
    String line; 

    try { 
     InputFile stringIn = new InputFile(); 
     line = stringIn.ReadBigStringIn(); 
     stringArray = line.split("[^0-9.+Ee-]+"); 
     // analysis etc. 
    } 
} 

Estos trabajos bien, pero ¿y si el archivo txt tiene múltiples líneas de texto? ¿Hay alguna forma de generar una sola cadena larga, o quizás otra forma de hacerlo? Tal vez usar while(buffIn.readline != null) {}? No estoy seguro de cómo implementar esto.

Ideas apreciadas, gracias.

Answer 1

Tiene usted razón, sería necesario aquí un bucle.

El idioma habitual (usando sólo Java normal) es algo como esto:

public String ReadBigStringIn(BufferedReader buffIn) throws IOException { 
    StringBuilder everything = new StringBuilder(); 
    String line; 
    while((line = buffIn.readLine()) != null) { 
     everything.append(line); 
    } 
    return everything.toString(); 
} 

Esto elimina los saltos de línea - si desea retenerlos, no utilice el método readLine(), sino que simplemente leen en un char[] en su lugar (y añada esto a su StringBuilder).

Answer 2

Si lo que desea es leer la totalidad de un archivo en una cadena, le sugiero que utilice Guava 's Files clase:

String text = Files.toString("filename.txt", Charsets.UTF_8); 

Por supuesto, esto es suponiendo que desea mantener los saltos de línea. Si desea eliminar los saltos de línea, se puede cargar ya sea de esa manera y luego usar String.replace, o se puede utilizar de nuevo la guayaba:

List<String> lines = Files.readLines(new File("filename.txt"), Charsets.UTF_8); 
String joined = Joiner.on("").join(lines); 

Answer 3

suena como usted quiere Apache IO FileUtils

String text = FileUtils.readStringFromFile(new File(filename + ".txt")); 
String[] stringArray = text.split("[^0-9.+Ee-]+"); 

Answer 4

Si crea un StringBuilder, puede agregarle cada línea y devolver el String usando toString() al final.

Puede reemplazar su ReadBigStringIn() con

public String ReadBigStringIn() { 
     StringBuilder b = new StringBuilder(); 

     try { 
      String line = buffIn.readLine(); 
      while (line != null) { 
       b.append(line); 
       line = buffIn.readLine(); 
      } 
     } 
     catch(IOException e){}; 

     return b.toString(); 
} 

Answer 5

Esto crea una cadena larga, cada línea se seprateted de cadena "" (un espacio):

public String ReadBigStringIn() { 
    StringBuffer line = new StringBuffer(); 


    try { 
     while(buffIn.ready()) { 
     line.append(" " + buffIn.readLine()); 
    } catch(IOException e){ 
     e.printStackTrace(); 
    } 

    return line.toString(); 
} 

Answer 6

Tiene un archivo que contiene dobles. Parece que tienes más de un número por línea y puede tener varias líneas.

Lo más simple es leer las líneas en un ciclo while.

Puede devolver nulo desde su método ReadBigStringIn cuando se alcanza la última línea y finalizar allí su ciclo.

Pero más normal sería crear y usar el lector en un método. Tal vez podría cambiar a un método que lea el archivo y devuelva una matriz o una lista de dobles.

Por cierto, ¿podría simplemente dividir sus cadenas por espacios en blanco?

Leer todo un archivo en una sola Cadena puede adaptarse a su caso particular, pero tenga en cuenta que podría causar una explosión de memoria si su archivo era muy grande. El enfoque de transmisión es generalmente más seguro para dicha E/S.

Answer 7

Recomendaría encarecidamente el uso de la biblioteca aquí, pero desde Java 8 puede hacer esto también utilizando secuencias.

try (InputStreamReader in = new InputStreamReader(System.in); 
     BufferedReader buffer = new BufferedReader(in)) { 
     final String fileAsText = buffer.lines().collect(Collectors.joining()); 
     System.out.println(fileAsText); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

Se nota también que es muy eficaz como joining está utilizando StringBuilder internamente.