Похоже, что существуют различные способы чтения и записи данных файлов в Java.
Я хочу прочитать данные ASCII из файла. Каковы возможные способы и их различия?
Мой любимый способ чтения небольшого файла - использовать 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
}
ASCII - это текстовый файл, поэтому для чтения вы будете использовать Readers
. Java также поддерживает чтение из двоичного файла с помощью InputStreams
. Если считываемые файлы огромны, то для повышения производительности чтения лучше использовать BufferedReader
поверх FileReader
.
О том, как использовать Reader
, читайте в этой статье.
Я также рекомендую вам скачать и прочитать эту замечательную (пока бесплатную) книгу под названием Thinking In Java.
In Java 7:
new String(Files.readAllBytes(...))
(docs) или
Files.readAllLines(...)
В Java 8:
Files.lines(..).forEach(...)
Самый простой способ - использовать класс 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)
Здесь'ы другой способ сделать это без использования внешних библиотек:
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.линий(путей.вам (и"/Путь/к/файлу.тхт на")).карте(линия -> линия.сплит (с";", У))
- это не вариант.
Я тестировал на Java 1.8, Windows 7 и оба SSD и HDD дисков.
Я написал шесть различных реализаций:
rawParse: использовать BufferedInputStream через FileInputStream, а затем вырезать линии читать байт за байтом. Это опережает любой другой однопоточный подход, но это может быть очень неудобно для не-ASCII файлов.
lineReaderParse: использовать командой bufferedreader через FileReader, читать построчно, разбить строки на строку вызова.сплит(). Это approximatedly 20% медленнее, что rawParse.
lineReaderParseParallel: это так же, как lineReaderParse, но он использует несколько потоков. Это самый быстрый вариант в целом во всех случаях.
nioFilesParse: используйте Java.НИО.файлов.Файлов.линии()
nioAsyncParse: используйте AsynchronousFileChannel с обработчиком завершения, и пул потоков.
nioMemoryMappedParse: использовать памяти файл. Это действительно плохая идея, уступая времени выполнения, по крайней мере, в три раза дольше, чем любой другой реализации.
Это среднее время для чтения файлов 204 от 4&ампер;усилитель; nbsp;МБ каждый на четырехъядерный 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 или HDD диск является SSD приблизительно на 15% быстрее. Это может быть потому, что файлы генерируются на дефрагментированный HDD и они считываются последовательно, поэтому диск может выполнять почти как SSD.
Меня удивила низкая результативность реализации nioAsyncParse. Либо я реализовал что-то неправильно или многопоточной реализации с использованием Nio и обработчик завершения выполняется та же (или даже хуже), чем однопотоковая реализация с Java.интерфейс программирования приложений. Кроме того, асинхронные разобрать с 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
Здесь представлены три рабочие и проверенные методы:
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);
}
}
}
Сканер
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());
}
}
}
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);
}
}
}
сканер
класса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)
Что ты хочешь делать с текстом? Это файл достаточно мал, чтобы поместиться в памяти? Я попытаюсь найти простой способ, чтобы обработать файл для ваших нужд. Библиотека пакета fileutils очень ручки для этого.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
Я документально 15 способов, чтобы прочитать файл в Java, а затем проверили их на скорости с различных файловых размеров - от 1&ампер;усилитель; nbsp;КБ 1&усилителя;усилитель; nbsp;ГБ, а вот в тройку способов сделать это:
Ява.НИО.файл.Файлов.readAllBytes()
Протестирован для работы в Java 7, 8 и 9.
импорт Java.Ио.Файл; импорт Java.Ио.Класс IOException; импорт Java.НИО.файл.Файлы;
открытый класс ReadFile_Files_ReadAllBytes { общественности статической силы основных(string [] pArgs) бросает IOException { Строке filename = "и c:\temp\sample-10KB.txt"; Файл файл = новый файл(имяфайла);
байт [] fileBytes = файлы.readAllBytes(файл.параметру topath()); голец singleChar; для(байт B : fileBytes) { singleChar = (чар) б; Системы.из.печати(singleChar); } } }
Ява.Ио.Командой bufferedreader.с readline()
Протестирован для работы в Java 7, 8, 9.
импорт Java.Ио.Командой bufferedreader; импорт Java.Ио.FileReader; импорт Java.Ио.Класс IOException;
открытый класс ReadFile_BufferedReader_ReadLine { общественности статической силы основных(string [] аргументы) бросает IOException { Строке filename = "и c:\temp\sample-10KB.txt"; FileReader fileReader = новый FileReader(именем);
попробовать (командой bufferedreader командой bufferedreader = читает(fileReader)) { Строки; в то время как((строка = командой bufferedreader.с readline()) != значение null) { Системы.из.метод println(линия); } } } }
Ява.НИО.файл.Файлов.линии()
Это было протестировано для работы в Java 8 и 9, но выиграл't работа в Java 7 из-за требования лямбда-выражение.
импорт Java.Ио.Файл; импорт Java.Ио.Класс IOException; импорт Java.НИО.файл.Файлы; импорт Java.утиль.поток.Потока;
открытый класс ReadFile_Files_Lines { общественности статической силы основных(string[] pArgs) бросает IOException { Строке filename = "и c:\temp\sample-10KB.txt"; Файл файл = новый файл(имяфайла);
попробовать (linesStream поток = файлы.строк(файл.параметру topath())) { linesStream.(линия -&объекту ГТ; { Системы.из.метод println(линия); }); } } }
Это, по сути, точно такой же, как Иисус Рамос' ответ, кроме как с файл вместо 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
Используя Командой 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();
}
Наверное, не так быстро, как с буферизацией ввода-вывода, но довольно лаконична:
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
Этот узор\з говорит
сканер` что разделитель ВФ.
Буферизованный поток классы являются гораздо более эффективным на практике, так что НИО.2 API включает методы, которые специально возвращать эти классы потоков, в частности, чтобы побудить вас всегда использовать буферизованные потоки в вашем приложении.
Вот пример:
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 является использование *файл * класс для чтения файла и сканер** класса, чтобы прочитать содержимое файла.
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();
}
}
}
ЗЫ: Дон'т забудьте импортировать Java.утиль.*; для сканера для работы.
Я не'т см. Он еще упоминается в других до сих пор ответы. Но если ты такой "Лучший фильм" означает скорость, потом новый Java ввода-вывода (НИО) может обеспечить быстрый быстродействия, но не всегда самый простой, чтобы выяснить, на кого учиться.
http://download.oracle.com/javase/tutorial/essential/io/file.html
Вы можете использовать readAllLines и "присоединиться" метод, чтобы получить все содержимое файла в одну строку:
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 быстрее и точнее, потому что он не заменяет новую строку с \п
, а также новая линия может быть\р\н`. Это в зависимости от ваших потребностей, какой из них подходит.
Это не может быть точного ответа на вопрос. Это's просто еще один способ чтения файла, где вы не указываете путь к файлу в вашем 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 и распечатать его на консоль.
Вы также можете сделать систему.из.метод println()
запись в конкретный файл через командную строку следующим образом:
java InputReader < input.txt > output.txt
Это читать с input.txt и напишите output.txt
.
Фейхоа обеспечивает один лайнер для этого:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);