txt - leer y escribir archivos en java

Java: cómo leer un archivo de texto

Question

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?

Answer 1

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());
}
}
}

Answer 2

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<Integer> integers = new ArrayList<Integer>();
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 fuentes de entrada, diferentes delimitadores y diferentes tipos de datos.

Answer 3

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());
}
}
}

Answer 4

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

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<Integer> 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<Integer> 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

Answer 5

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<Integer> 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, this ). 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; ;-)}

Answer 6

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<Integer> readIntegers(File file) throws IOException {
List<Integer> 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.

Answer 7

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<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);

Answer 8

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.

Answer 9

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