Чтение простого текстового файла на Java
Кажется, есть разные способы чтения и записи данных файлов в Java.
Я хочу прочитать данные ASCII из файла. Каковы возможные пути и их отличия?
32 ответа
ASCII - это текстовый файл, поэтому вы должны использовать Readers для чтения. Java также поддерживает чтение из двоичного файла с использованием InputStreams, Если читаемые файлы огромны, вы можете использовать BufferedReader на вершине FileReader улучшить производительность чтения.
Прочтите эту статью о том, как использовать Reader
Я бы также порекомендовал вам скачать и прочитать эту замечательную (но бесплатную) книгу под названием Thinking In Java
В Java 7:
new String(Files.readAllBytes(...))
(документы) или
Files.readAllLines(...)
В Java 8:
Files.lines(..).forEach(...)
Мой любимый способ прочитать небольшой файл - это использовать BufferedReader и StringBuilder. Это очень просто и точно (хотя и не особенно эффективно, но достаточно хорошо для большинства случаев):
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
} finally {
br.close();
}
Некоторые отмечают, что после Java 7 вы должны использовать функции try-with-resources (то есть автоматического закрытия):
try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
}
Когда я читаю строки, подобные этим, я обычно все равно хочу выполнить некоторую обработку строк для каждой строки, поэтому я перехожу к этой реализации.
Хотя, если я действительно хочу просто прочитать файл в строку, я всегда использую Apache Commons IO с методом класса IOUtils.toString(). Вы можете взглянуть на источник здесь:
http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html
FileInputStream inputStream = new FileInputStream("foo.txt");
try {
String everything = IOUtils.toString(inputStream);
} finally {
inputStream.close();
}
И даже проще с Java 7:
try(FileInputStream inputStream = new FileInputStream("foo.txt")) {
String everything = IOUtils.toString(inputStream);
// do something with everything string
}
Самый простой способ - это использовать Scanner класс в Java и объект FileReader. Простой пример:
Scanner in = new Scanner(new FileReader("filename.txt"));
Scanner имеет несколько методов для чтения в строках, числах и т. д. Более подробную информацию вы можете найти на странице документации Java.
Например, читая весь контент в String:
StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
sb.append(in.next());
}
in.close();
outString = sb.toString();
Также, если вам нужна определенная кодировка, вы можете использовать ее вместо FileReader:
new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Вот простое решение:
String content;
content = new String(Files.readAllBytes(Paths.get("sample.txt")));
Вот еще один способ сделать это без использования внешних библиотек:
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public String readFile(String filename)
{
String content = null;
File file = new File(filename); // For example, foo.txt
FileReader reader = null;
try {
reader = new FileReader(file);
char[] chars = new char[(int) file.length()];
reader.read(chars);
content = new String(chars);
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(reader != null){
reader.close();
}
}
return content;
}
Я должен был сравнить различные способы. Я прокомментирую мои выводы, но, вкратце, самый быстрый способ - это использовать простой старый BufferedInputStream поверх FileInputStream. Если нужно прочитать много файлов, то три потока уменьшат общее время выполнения примерно до половины, но добавление большего количества потоков будет постепенно снижать производительность, пока не потребуется три раза больше времени для завершения с двадцатью потоками, чем с одним потоком.
Предполагается, что вы должны прочитать файл и сделать что-то значимое с его содержимым. В приведенных здесь примерах чтение строк из журнала и подсчет тех, которые содержат значения, превышающие определенный порог. Так что я предполагаю, что однострочная Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) это не вариант.
Я тестировал на Java 1.8, Windows 7 и SSD и HDD дисках.
Я написал шесть разных реализаций:
rawParse: используйте BufferedInputStream поверх FileInputStream, а затем обрезайте строки, читая побайтно. Это превосходит любой другой однопоточный подход, но может быть очень неудобно для файлов, не относящихся к ASCII.
lineReaderParse: используйте BufferedReader поверх FileReader, читайте построчно, разбивайте строки, вызывая String.split(). Это примерно на 20% медленнее, чем rawParse.
lineReaderParseParallel: это то же самое, что lineReaderParse, но использует несколько потоков. Это самый быстрый вариант в целом во всех случаях.
nioFilesParse: используйте java.nio.files.Files.lines ()
nioAsyncParse: используйте AsynchronousFileChannel с обработчиком завершения и пулом потоков.
nioMemoryMappedParse: использовать отображенный в памяти файл. Это действительно плохая идея, которая дает время выполнения по крайней мере в три раза дольше, чем любая другая реализация.
Это среднее время чтения 204 файлов по 4 МБ каждый на четырехъядерном диске i7 и SSD. Файлы создаются на лету, чтобы избежать кеширования диска.
rawParse 11.10 sec
lineReaderParse 13.86 sec
lineReaderParseParallel 6.00 sec
nioFilesParse 13.52 sec
nioAsyncParse 16.06 sec
nioMemoryMappedParse 37.68 sec
Я обнаружил разницу, меньшую, чем я ожидал, между работой на SSD или жестком диске, поскольку SSD работает примерно на 15% быстрее. Это может быть связано с тем, что файлы создаются на нефрагментированном жестком диске и считываются последовательно, поэтому вращающийся диск может работать почти как SSD.
Я был удивлен низкой производительностью реализации nioAsyncParse. Либо я реализовал что-то неправильно, либо многопоточная реализация с использованием NIO и обработчик завершения выполняет то же самое (или даже хуже), чем однопоточная реализация с API java.io. Более того, асинхронный анализ с CompletionHandler намного длиннее в строках кода и сложен для правильной реализации, чем прямая реализация в старых потоках.
Теперь за шестью реализациями следует класс, содержащий их все, плюс параметризуемый метод main(), который позволяет играть с количеством файлов, размером файла и степенью параллелизма. Обратите внимание, что размер файлов варьируется плюс минус 20%. Это позволит избежать какого-либо эффекта, поскольку все файлы имеют одинаковый размер.
rawParse
public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
overrunCount = 0;
final int dl = (int) ';';
StringBuffer lineBuffer = new StringBuffer(1024);
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileInputStream fin = new FileInputStream(fl);
BufferedInputStream bin = new BufferedInputStream(fin);
int character;
while((character=bin.read())!=-1) {
if (character==dl) {
// Here is where something is done with each line
doSomethingWithRawLine(lineBuffer.toString());
lineBuffer.setLength(0);
}
else {
lineBuffer.append((char) character);
}
}
bin.close();
fin.close();
}
}
public final void doSomethingWithRawLine(String line) throws ParseException {
// What to do for each line
int fieldNumber = 0;
final int len = line.length();
StringBuffer fieldBuffer = new StringBuffer(256);
for (int charPos=0; charPos<len; charPos++) {
char c = line.charAt(charPos);
if (c==DL0) {
String fieldValue = fieldBuffer.toString();
if (fieldValue.length()>0) {
switch (fieldNumber) {
case 0:
Date dt = fmt.parse(fieldValue);
fieldNumber++;
break;
case 1:
double d = Double.parseDouble(fieldValue);
fieldNumber++;
break;
case 2:
int t = Integer.parseInt(fieldValue);
fieldNumber++;
break;
case 3:
if (fieldValue.equals("overrun"))
overrunCount++;
break;
}
}
fieldBuffer.setLength(0);
}
else {
fieldBuffer.append(c);
}
}
}
lineReaderParse
public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
String line;
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null)
doSomethingWithLine(line);
brd.close();
frd.close();
}
}
public final void doSomethingWithLine(String line) throws ParseException {
// Example of what to do for each line
String[] fields = line.split(";");
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
lineReaderParseParallel
public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
Thread[] pool = new Thread[degreeOfParalelism];
int batchSize = numberOfFiles / degreeOfParalelism;
for (int b=0; b<degreeOfParalelism; b++) {
pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
pool[b].start();
}
for (int b=0; b<degreeOfParalelism; b++)
pool[b].join();
}
class LineReaderParseThread extends Thread {
private String targetDir;
private int fileFrom;
private int fileTo;
private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private int overrunCounter = 0;
public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
this.targetDir = targetDir;
this.fileFrom = fileFrom;
this.fileTo = fileTo;
}
private void doSomethingWithTheLine(String line) throws ParseException {
String[] fields = line.split(DL);
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCounter++;
}
@Override
public void run() {
String line;
for (int f=fileFrom; f<fileTo; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
try {
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null) {
doSomethingWithTheLine(line);
}
brd.close();
frd.close();
} catch (IOException | ParseException ioe) { }
}
}
}
nioFilesParse
public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
for (int f=0; f<numberOfFiles; f++) {
Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
Consumer<String> action = new LineConsumer();
Stream<String> lines = Files.lines(ph);
lines.forEach(action);
lines.close();
}
}
class LineConsumer implements Consumer<String> {
@Override
public void accept(String line) {
// What to do for each line
String[] fields = line.split(DL);
if (fields.length>1) {
try {
Date dt = fmt.parse(fields[0]);
}
catch (ParseException e) {
}
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
}
}
nioAsyncParse
public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();
for (int b=0; b<numberOfThreads; b++)
byteBuffers.add(ByteBuffer.allocate(bufferSize));
for (int f=0; f<numberOfFiles; f++) {
consumerThreads.acquire();
String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
channel.read(consumer.buffer(), 0l, channel, consumer);
}
consumerThreads.acquire(numberOfThreads);
}
class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {
private ConcurrentLinkedQueue<ByteBuffer> buffers;
private ByteBuffer bytes;
private String file;
private StringBuffer chars;
private int limit;
private long position;
private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
buffers = byteBuffers;
bytes = buffers.poll();
if (bytes==null)
bytes = ByteBuffer.allocate(bufferSize);
file = fileName;
chars = new StringBuffer(bufferSize);
frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
limit = bufferSize;
position = 0l;
}
public ByteBuffer buffer() {
return bytes;
}
@Override
public synchronized void completed(Integer result, AsynchronousFileChannel channel) {
if (result!=-1) {
bytes.flip();
final int len = bytes.limit();
int i = 0;
try {
for (i = 0; i < len; i++) {
byte by = bytes.get();
if (by=='\n') {
// ***
// The code used to process the line goes here
chars.setLength(0);
}
else {
chars.append((char) by);
}
}
}
catch (Exception x) {
System.out.println(
"Caught exception " + x.getClass().getName() + " " + x.getMessage() +
" i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
", position="+String.valueOf(position));
}
if (len==limit) {
bytes.clear();
position += len;
channel.read(bytes, position, channel, this);
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
@Override
public void failed(Throwable e, AsynchronousFileChannel channel) {
}
};
ПОЛНАЯ БЕЗОПАСНАЯ РЕАЛИЗАЦИЯ ВСЕХ СЛУЧАЙ
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java
Вот три рабочих и проверенных метода:
С помощью BufferedReader
package io;
import java.io.*;
public class ReadFromFile2 {
public static void main(String[] args)throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
BufferedReader br = new BufferedReader(new FileReader(file));
String st;
while((st=br.readLine()) != null){
System.out.println(st);
}
}
}
С помощью Scanner
package io;
import java.io.File;
import java.util.Scanner;
public class ReadFromFileUsingScanner {
public static void main(String[] args) throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
Scanner sc = new Scanner(file);
while(sc.hasNextLine()){
System.out.println(sc.nextLine());
}
}
}
С помощью FileReader
package io;
import java.io.*;
public class ReadingFromFile {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
int i;
while ((i=fr.read()) != -1){
System.out.print((char) i);
}
}
}
Прочитать весь файл без цикла, используя Scanner учебный класс
package io;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ReadingEntireFileWithoutLoop {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
Scanner sc = new Scanner(file);
sc.useDelimiter("\\Z");
System.out.println(sc.next());
}
}
Методы в org.apache.commons.io.FileUtils также может быть очень удобным, например:
/**
* Reads the contents of a file line by line to a List
* of Strings using the default encoding for the VM.
*/
static List readLines(File file)
Я задокументировал 15 способов чтения файла в Java, а затем проверил их на скорость при различных размерах файлов - от 1 КБ до 1 ГБ, и вот три основных способа сделать это:
java.nio.file.Files.readAllBytes()Проверено на работу в Java 7, 8 и 9.
import java.io.File; import java.io.IOException; import java.nio.file.Files; public class ReadFile_Files_ReadAllBytes { public static void main(String [] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); byte [] fileBytes = Files.readAllBytes(file.toPath()); char singleChar; for(byte b : fileBytes) { singleChar = (char) b; System.out.print(singleChar); } } }java.io.BufferedReader.readLine()Проверено на работу в Java 7, 8, 9.
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class ReadFile_BufferedReader_ReadLine { public static void main(String [] args) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; FileReader fileReader = new FileReader(fileName); try (BufferedReader bufferedReader = new BufferedReader(fileReader)) { String line; while((line = bufferedReader.readLine()) != null) { System.out.println(line); } } } }java.nio.file.Files.lines()Это было проверено для работы в Java 8 и 9, но не будет работать в Java 7 из-за требования лямбда-выражения.
import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.util.stream.Stream; public class ReadFile_Files_Lines { public static void main(String[] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); try (Stream linesStream = Files.lines(file.toPath())) { linesStream.forEach(line -> { System.out.println(line); }); } } }
Что вы хотите сделать с текстом? Файл достаточно мал, чтобы поместиться в память? Я постараюсь найти самый простой способ обработки файла для ваших нужд. Библиотека FileUtils очень удобна для этого.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
Самый интуитивно понятный метод представлен в Java 11 Files.readString
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String args[]) throws IOException {
String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
System.out.print(content);
}
}
PHP обладает этой роскошью десятилетней давности! ☺
Ниже приведено описание того, как сделать это в стиле Java 8. Если предположить, text.txt Файл находится в корне каталога проекта Eclipse.
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
Классы буферизованных потоков на практике намного более производительны, настолько, что API NIO.2 включает методы, которые специально возвращают эти классы потоков, отчасти, чтобы поощрять вас всегда использовать буферизованные потоки в вашем приложении.
Вот пример:
Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
// Read from the stream
String currentLine = null;
while ((currentLine = reader.readLine()) != null)
//do your code here
} catch (IOException e) {
// Handle file I/O exception...
}
Вы можете заменить этот код
BufferedReader reader = Files.newBufferedReader(path);
с
BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));
Я рекомендую эту статью, чтобы узнать, как использовать Java NIO и IO.
Использование BufferedReader:
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
BufferedReader br;
try {
br = new BufferedReader(new FileReader("/fileToRead.txt"));
try {
String x;
while ( (x = br.readLine()) != null ) {
// Printing out each line in the file
System.out.println(x);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
catch (FileNotFoundException e) {
System.out.println(e);
e.printStackTrace();
}
Это в основном то же самое, что и ответ Иисуса Рамоса, за исключением того, что File вместо FileReader плюс итерация для просмотра содержимого файла.
Scanner in = new Scanner(new File("filename.txt"));
while (in.hasNext()) { // Iterates each line in the file
String line = in.nextLine();
// Do something with line
}
in.close(); // Don't forget to close resource leaks
... броски FileNotFoundException
Вероятно, не так быстро, как с буферизованным вводом / выводом, но довольно кратко:
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
\Z шаблон говорит Scanner что разделитель EOF.
Вы можете использовать readAllLines и join способ получить содержимое всего файла в одну строку:
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
По умолчанию используется кодировка UTF-8, которая правильно читает данные ASCII.
Также вы можете использовать readAllBytes:
String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);
Я думаю, что readAllBytes быстрее и точнее, потому что он не заменяет новую строку \n а также новая строка может быть \r\n, Это зависит от ваших потребностей, какой из них подходит.
Самый простой способ чтения данных из файла в Java - это использование класса File для чтения файла и класса Scanner для чтения содержимого файла.
public static void main(String args[])throws Exception
{
File f = new File("input.txt");
takeInputIn2DArray(f);
}
public static void takeInputIn2DArray(File f) throws Exception
{
Scanner s = new Scanner(f);
int a[][] = new int[20][20];
for(int i=0; i<20; i++)
{
for(int j=0; j<20; j++)
{
a[i][j] = s.nextInt();
}
}
}
PS: не забудьте импортировать java.util.*; для работы сканера.
Пока я не вижу упоминания в других ответах. Но если "Наилучший" означает скорость, то новый Java I/O (NIO) может обеспечить самое быстрое предварительное выполнение, но не всегда самое простое, чтобы понять кого-то, кто изучает.
http://download.oracle.com/javase/tutorial/essential/io/file.html
Гуава предоставляет для этого одну строку:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
Cactoos дает вам декларативный однострочный:
new TextOf(new File("a.txt")).asString();
Это может быть не точный ответ на вопрос. Это просто еще один способ чтения файла, в котором вы не указываете явно путь к своему файлу в своем Java-коде, а вместо этого вы читаете его как аргумент командной строки.
С помощью следующего кода,
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class InputReader{
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s="";
while((s=br.readLine())!=null){
System.out.println(s);
}
}
}
просто продолжайте и запустите его с:
java InputReader < input.txt
Это будет читать содержание input.txt и распечатайте его на своей консоли.
Вы также можете сделать свой System.out.println() записать в определенный файл через командную строку следующим образом:
java InputReader < input.txt > output.txt
Это будет читать из input.txt и написать output.txt,
Для веб-приложений Maven на основе JSF просто используйте ClassLoader и Resources Папка для чтения в любом файле, который вы хотите:
- Поместите любой файл, который вы хотите прочитать, в папку "Ресурсы".
Поместите зависимость ввода-вывода Apache Commons в свой POM:
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-io</artifactId> <version>1.3.2</version> </dependency>Используйте код ниже, чтобы прочитать его (например, ниже читает в файле.json):
String metadata = null; FileInputStream inputStream; try { ClassLoader loader = Thread.currentThread().getContextClassLoader(); inputStream = (FileInputStream) loader .getResourceAsStream("/metadata.json"); metadata = IOUtils.toString(inputStream); inputStream.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return metadata;
Вы можете сделать то же самое для текстовых файлов, файлов.properties, схем XSD и т. Д.
try {
File f = new File("filename.txt");
Scanner r = new Scanner(f);
while (r.hasNextLine()) {
String data = r.nextLine();
JOptionPane.showMessageDialog(data);
}
r.close();
} catch (FileNotFoundException ex) {
JOptionPane.showMessageDialog("Error occurred");
ex.printStackTrace();
}
Для разработчиков Android, оказавшихся здесь (которые используют Kotlin):
val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val text = myFileUrl.readText() // Not recommended for huge files
println(text)
Другое решение:
val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
val lines = file.readLines() // Not recommended for huge files
lines.forEach(::println)
Еще одно хорошее решение, которое можно использовать и для огромных файлов:
val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
file
.bufferedReader()
.lineSequence()
.forEach(::println)
Или:
val myFileUrl = object{}.javaClass.getResource("/vegetables.txt")
val file = File(myFileUrl.toURI())
file.useLines { lines ->
lines.forEach(::println)
}
Примечания:
Файл овощи.txt должен находиться в вашем пути к классам (например, в каталоге src/main/resources )
Все вышеперечисленные решения обрабатывают кодировки файлов как
UTF-8по умолчанию. Вы можете указать желаемую кодировку в качестве аргумента для функций.Приведенные выше решения не требуют каких-либо дополнительных действий, таких как закрытие файлов или программ чтения. О них автоматически заботится стандартная библиотека Kotlin.
import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;
class ReadFile {
public static void main(String[] args) {
String filename = "Test.txt";
try(Stream<String> stream = Files.lines(Paths.get(filename))) {
stream.forEach(System.out:: println);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Просто используйте Java 8 Stream.
Используйте Java поцелуй, если речь идет о простоте структуры:
import static kiss.API.*;
class App {
void run() {
String line;
try (Close in = inOpen("file.dat")) {
while ((line = readLine()) != null) {
println(line);
}
}
}
}
try (Stream<String> stream = Files.lines(Paths.get(String.valueOf(new File("yourFile.txt"))))) {
stream.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
new File(<path_name>)
Создает новый экземпляр File путем преобразования заданной строки пути в абстрактный путь. Если данная строка является пустой строкой, то результатом является пустой абстрактный путь. Параметры: имя_пути — строка имени пути. Выдает:NullPointerException — если аргумент имени пути равен нулю.
Files.linesвозвращает поток String
Stream<String> stream = Files.lines(Paths.get(String.valueOf(new File("yourFile.txt"))))может генерировать nullPointerExcetion , FileNotFoundException, поэтому держите его внутри, попробуйте позаботиться об исключении во время выполнения
stream.forEach(System.out::println);
Это используется для перебора потока и печати в консоли. Если у вас другой вариант использования, вы можете предоставить свою пользовательскую функцию для управления потоком строк.
Если у вас есть большой файл , вы можете использовать Apache Commons IO для итеративной обработки файла без исчерпания доступной памяти.
try (LineIterator it = FileUtils.lineIterator(theFile, "UTF-8")) {
while (it.hasNext()) {
String line = it.nextLine();
// do something with line
}
}
Мой новый любимый подход к простому чтению всего текстового файла из ввода BufferedReader:
String text = input.lines().collect(Collectors.joining(System.lineSeparator())));
Это будет читать весь файл, добавляя новую строку (lineSeparator) после каждой строки. Без разделителя все строки будут объединены в одну. Похоже, это существует с Java 8.