Java: cómo leer un archivo de texto

Quiero leer un archivo de texto que contenga valores separados por espacios. Los valores son enteros. ¿Cómo puedo leerlo y ponerlo en una lista de arreglo?

Aquí hay un ejemplo de contenido del archivo de texto:

1 62 4 55 5 6 77 

Quiero tenerlo en un arraylist como [1, 62, 4, 55, 5, 6, 77] . ¿Cómo puedo hacerlo en Java?

Puede usar los Files#readAllLines() para obtener todas las líneas de un archivo de texto en una List .

 for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) { // ... } 

Tutorial: E / S básica> E / S de archivos> Lectura, escritura y creación de archivos de texto


Puede usar String#split() para dividir una String en partes en función de una expresión regular.

 for (String part : line.split("\\s+")) { // ... } 

Tutorial: Números y cadenas> Cadenas> Manipulación de caracteres en una cadena


Puede usar Integer#valueOf() para convertir una String en un Integer .

 Integer i = Integer.valueOf(part); 

Tutorial: Números y cadenas> Cadenas> Conversión entre números y cadenas


Puede usar List#add() para agregar un elemento a una List .

 numbers.add(i); 

Tutorial: Interfaces> La interfaz de lista


Por lo tanto, en pocas palabras (suponiendo que el archivo no tiene líneas vacías ni espacios en blanco al final / adelante).

 List numbers = new ArrayList<>(); for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) { for (String part : line.split("\\s+")) { Integer i = Integer.valueOf(part); numbers.add(i); } } 

Si ya está en Java 8, puede usar Stream API para esto, comenzando con Files#lines() .

 List numbers = Files.lines(Paths.get("/path/to/test.txt")) .map(line -> line.split("\\s+")).flatMap(Arrays::stream) .map(Integer::valueOf) .collect(Collectors.toList()); 

Tutorial: procesamiento de datos con flujos de Java 8

Java 1.5 introdujo la clase Scanner para manejar la entrada de archivos y flujos.

Se usa para obtener enteros de un archivo y se vería así:

 List integers = new ArrayList(); Scanner fileScanner = new Scanner(new File("c:\\file.txt")); while (fileScanner.hasNextInt()){ integers.add(fileScanner.nextInt()); } 

Verifique la API sin embargo. Hay muchas más opciones para tratar con diferentes tipos de fonts de entrada, diferentes delimitadores y diferentes tipos de datos.

Este código de ejemplo muestra cómo leer un archivo en Java.

 import java.io.*; /** * This example code shows you how to read file in Java * * IN MY CASE RAILWAY IS MY TEXT FILE WHICH I WANT TO DISPLAY YOU CHANGE WITH YOUR OWN */ public class ReadFileExample { public static void main(String[] args) { System.out.println("Reading File from Java code"); //Name of the file String fileName="RAILWAY.txt"; try{ //Create object of FileReader FileReader inputFile = new FileReader(fileName); //Instantiate the BufferedReader Class BufferedReader bufferReader = new BufferedReader(inputFile); //Variable to hold the one line data String line; // Read file line by line and print on the console while ((line = bufferReader.readLine()) != null) { System.out.println(line); } //Close the buffer reader bufferReader.close(); }catch(Exception e){ System.out.println("Error while reading file line by line:" + e.getMessage()); } } } 

Mira este ejemplo e intenta hacer el tuyo:

 import java.io.*; public class ReadFile { public static void main(String[] args){ String string = ""; String file = "textFile.txt"; // Reading try{ InputStream ips = new FileInputStream(file); InputStreamReader ipsr = new InputStreamReader(ips); BufferedReader br = new BufferedReader(ipsr); String line; while ((line = br.readLine()) != null){ System.out.println(line); string += line + "\n"; } br.close(); } catch (Exception e){ System.out.println(e.toString()); } // Writing try { FileWriter fw = new FileWriter (file); BufferedWriter bw = new BufferedWriter (fw); PrintWriter fileOut = new PrintWriter (bw); fileOut.println (string+"\n test of read and write !!"); fileOut.close(); System.out.println("the file " + file + " is created!"); } catch (Exception e){ System.out.println(e.toString()); } } } 

Solo por diversión, esto es lo que probablemente haría en un proyecto real, donde ya estoy usando todas mis bibliotecas favoritas (en este caso, Guava , anteriormente conocida como Google Collections ).

 String text = Files.toString(new File("textfile.txt"), Charsets.UTF_8); List list = Lists.newArrayList(); for (String s : text.split("\\s")) { list.add(Integer.valueOf(s)); } 

Beneficio: No hay mucho código propio que mantener (contraste con, por ejemplo, esto ). Editar : ¡Aunque vale la pena señalar que en este caso la solución de escáner de tschaible no tiene más código!

Drawback: es posible que no desee agregar nuevas dependencias de biblioteca solo para esto. (Por otra parte, sería una tontería no hacer uso de la guayaba en sus proyectos; 😉

Utilice Apache Commons (IO y Lang) para cosas simples / comunes como esta.

Importaciones:

 import org.apache.commons.io.FileUtils; import org.apache.commons.lang3.ArrayUtils; 

Código:

 String contents = FileUtils.readFileToString(new File("path/to/your/file.txt")); String[] array = ArrayUtils.toArray(contents.split(" ")); 

Hecho.

Usar Java 7 para leer archivos con NIO.2

Importar estos paquetes:

 import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; 

Este es el proceso para leer un archivo:

 Path file = Paths.get("C:\\Java\\file.txt"); if(Files.exists(file) && Files.isReadable(file)) { try { // File reader BufferedReader reader = Files.newBufferedReader(file, Charset.defaultCharset()); String line; // read each line while((line = reader.readLine()) != null) { System.out.println(line); // tokenize each number StringTokenizer tokenizer = new StringTokenizer(line, " "); while (tokenizer.hasMoreElements()) { // parse each integer in file int element = Integer.parseInt(tokenizer.nextToken()); } } reader.close(); } catch (Exception e) { e.printStackTrace(); } } 

Para leer todas las líneas de un archivo a la vez:

 Path file = Paths.get("C:\\Java\\file.txt"); List lines = Files.readAllLines(file, StandardCharsets.UTF_8); 

Todas las respuestas dadas hasta ahora implican leer el archivo línea por línea, tomar la línea como una String y luego procesar la String .

No hay duda de que este es el enfoque más fácil de entender, y si el archivo es bastante corto (digamos, decenas de miles de líneas), también será aceptable en términos de eficiencia. Pero si el archivo es largo , es una forma muy ineficiente de hacerlo, por dos razones:

  1. Cada personaje se procesa dos veces, una al construir la String y otra vez al procesarla.
  2. El recolector de basura no será tu amigo si hay muchas líneas en el archivo. Estás construyendo un nuevo String para cada línea, y luego lo tirarás cuando pases a la siguiente línea. El recolector de basura eventualmente tendrá que deshacerse de todos estos objetos String que ya no desea. Alguien tiene que limpiar después de ti.

Si te preocupa la velocidad, es mucho mejor leer un bloque de datos y luego procesarlo byte por byte en lugar de línea por línea. Cada vez que llegas al final de un número, lo agregas a la List que estás creando.

Saldrá algo como esto:

 private List readIntegers(File file) throws IOException { List result = new ArrayList<>(); RandomAccessFile raf = new RandomAccessFile(file, "r"); byte buf[] = new byte[16 * 1024]; final FileChannel ch = raf.getChannel(); int fileLength = (int) ch.size(); final MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0, fileLength); int acc = 0; while (mb.hasRemaining()) { int len = Math.min(mb.remaining(), buf.length); mb.get(buf, 0, len); for (int i = 0; i < len; i++) if ((buf[i] >= 48) && (buf[i] < = 57)) acc = acc * 10 + buf[i] - 48; else { result.add(acc); acc = 0; } } ch.close(); raf.close(); return result; } 

El código anterior asume que esto es ASCII (aunque podría modificarse fácilmente para otras codificaciones), y que cualquier cosa que no sea un dígito (en particular, un espacio o una nueva línea) representa un límite entre los dígitos. También asume que el archivo termina con un no dígito (en la práctica, que la última línea termina con una nueva línea), aunque, de nuevo, podría modificarse para tratar el caso donde no lo hace.

Es mucho, mucho más rápido que cualquiera de los enfoques basados ​​en String que también se dan como respuestas a esta pregunta. Hay una investigación detallada de un problema muy similar en esta pregunta . Verá allí que existe la posibilidad de mejorarlo aún más si quiere ir por la línea de subprocesos múltiples.

lea el archivo y luego haga lo que quiera java8 Files.lines (Paths.get (“c: //lines.txt”)) collect (Collectors.toList ());