Java: Como ler um arquivo de texto

Eu quero ler um arquivo de texto contendo valores separados por espaço. Valores são inteiros. Como posso lê-lo e colocá-lo em uma lista de matriz?

Aqui está um exemplo de conteúdo do arquivo de texto:

1 62 4 55 5 6 77 

Eu quero tê-lo em um arraylist como [1, 62, 4, 55, 5, 6, 77] . Como posso fazer isso em Java?

Você pode usar o Files#readAllLines() para obter todas as linhas de um arquivo de texto em uma List .

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

Tutorial: E / S básica> E / S de arquivo> Leitura, gravação e criação de arquivos de texto


Você pode usar String#split() para dividir uma String em partes com base em uma expressão regular.

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

Tutorial: Números e Strings> Strings> Manipulando Caracteres em uma String


Você pode usar Integer#valueOf() para converter uma String em um Integer .

 Integer i = Integer.valueOf(part); 

Tutorial: Números e Strings> Strings> Convertendo entre Números e Strings


Você pode usar List#add() para adicionar um elemento a uma List .

 numbers.add(i); 

Tutorial: Interfaces> A Interface de Lista


Então, em poucas palavras (supondo que o arquivo não tenha linhas vazias nem espaços em branco iniciais / finais).

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

Se você já estiver no Java 8, poderá usar a API do Stream para isso, começando com 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: Processando Dados com Fluxos Java 8

O Java 1.5 introduziu a class Scanner para manipular a input de arquivos e streams.

É usado para obter números inteiros de um arquivo e seria algo como isto:

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

Verifique a API embora. Há muito mais opções para lidar com diferentes tipos de fonts de input, diferentes delimitadores e diferentes tipos de dados.

Este código de exemplo mostra como ler o arquivo em 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()); } } } 

Veja este exemplo e tente fazer o seu próprio:

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

Apenas por diversão, aqui está o que eu provavelmente faria em um projeto real, onde eu já estou usando todas as minhas bibliotecas favoritas (neste caso, Guava , anteriormente conhecido 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)); } 

Benefício: Não há muito código próprio para manter (contraste com, por exemplo, isso ). Edit : Embora seja importante notar que, neste caso, a solução de Scanner do tschaible não tem mais nenhum código!

Desvantagem: você obviamente pode não querer adicionar novas dependencies de bibliotecas apenas para isso. (Então, novamente, você seria bobo em não fazer uso de Guava em seus projetos 😉

Use o Apache Commons (IO e Lang) para coisas simples / comuns como esta.

Importações:

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

Feito.

Usando o Java 7 para ler arquivos com NIO.2

Importe esses pacotes:

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

Este é o processo para ler um arquivo:

 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 ler todas as linhas de um arquivo de uma só vez:

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

Todas as respostas dadas envolvem a leitura do arquivo linha por linha, inserindo a linha como String e processando a String .

Não há dúvida de que essa é a abordagem mais fácil de entender e, se o arquivo for bem curto (digamos, dezenas de milhares de linhas), ele também será aceitável em termos de eficiência. Mas se o arquivo for longo , é uma maneira muito ineficiente de fazê-lo, por dois motivos:

  1. Cada caractere é processado duas vezes, uma vez na construção da String e uma vez no processamento.
  2. O coletor de lixo não será seu amigo se houver muitas linhas no arquivo. Você está construindo uma nova String para cada linha e, em seguida, jogando fora quando você passa para a próxima linha. O coletor de lixo eventualmente terá que descartar todos esses objects String que você não deseja mais. Alguém tem que limpar depois de você.

Se você se preocupa com a velocidade, é muito melhor ler um bloco de dados e depois processá-lo byte por byte em vez de linha por linha. Toda vez que você chega ao final de um número, você o adiciona à List você está construindo.

Vai sair algo assim:

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

O código acima assume que este é ASCII (embora possa ser facilmente ajustado para outras codificações), e que qualquer coisa que não seja um dígito (em particular, um espaço ou uma nova linha) representa um limite entre os dígitos. Ele também assume que o arquivo termina com um não-dígito (na prática, a última linha termina com uma nova linha), embora, novamente, possa ser ajustada para lidar com o caso em que isso não acontece.

É muito, muito mais rápido do que qualquer uma das abordagens baseadas em String , também dadas como respostas a essa pergunta. Há uma investigação detalhada de um problema muito semelhante nesta questão . Você verá que existe a possibilidade de melhorá-lo ainda mais se quiser descer a linha multi-thread.

leia o arquivo e faça o que quiser java8 Files.lines (Paths.get (“c: //lines.txt”)). collect (Collectors.toList ());