Читання простого текстового файлу на Java


933

Здається, є різні способи зчитування та запису даних у файли на Java.

Я хочу прочитати дані ASCII з файлу. Які можливі шляхи та їх відмінності?


24
Я також не згоден із закриттям як "неконструктивним". На щастя, це цілком можна закрити як дублікат . Хороші відповіді, наприклад, як створити рядок із вмісту файлу? , Який найпростіший спосіб прочитати файл у String? , Які найпростіші класи для читання файлів?
Джонік

Без циклів: {{{Scanner sc = новий сканер (файл, "UTF-8"); sc.useDelimiter ("$ ^"); // Регекс, що не відповідає нічого String text = sc.next (); sc.close (); }}}
Айвар

3
це настільки цікаво, що у python немає нічого подібного до "read ()", щоб прочитати весь файл у рядку
kommradHomer

2
Це найпростіший спосіб зробити це: mkyong.com/java/…
dellasavia

Відповіді:


567

ASCII - це текстовий файл, який ви використовуєте Readersдля читання. Java також підтримує читання з двійкового файлу за допомогою InputStreams. Якщо файлів, які читаються, величезні, тоді ви хочете скористатись BufferedReaderповерх a, FileReaderщоб поліпшити продуктивність читання.

Перегляньте цю статтю про те, як користуватисяReader

Я також рекомендую вам завантажити та прочитати цю чудову (але безкоштовно) книгу під назвою Thinking In Java

На Java 7 :

new String(Files.readAllBytes(...))

(документи) або

Files.readAllLines(...)

(документи)

На Java 8 :

Files.lines(..).forEach(...)

(документи)


14
Вибір Reader дійсно залежить від того, для чого вам потрібен вміст файлу. Якщо файл невеликий (ish) і вам це потрібно все, то швидше (орієнтоване нами: 1,8-2x) просто використовувати FileReader і прочитати все (або принаймні досить великі шматки). Якщо ви обробляєте його рядок за рядком, тоді перейдіть до BufferedReader.
Влад

3
Чи збережеться порядок рядків при використанні "Files.lines (..). ForEach (...)". Я розумію, що порядок буде довільним після цієї операції.
Даніїл Шевельов

38
Files.lines(…).forEach(…)не зберігає порядок рядків, але виконується паралельно, @Dash. Якщо замовлення важливе, ви можете використовувати Files.lines(…).forEachOrdered(…), який повинен зберігати замовлення (не перевіряв, хоча).
Палець

2
@Palec це цікаво, але чи можете ви цитувати з документів, де написано, що Files.lines(...).forEach(...)виконується паралельно? Я думав, що це лише той випадок, коли ви явно робите потік паралельним використанням Files.lines(...).parallel().forEach(...).
Klitos Kyriacou

3
Моя оригінальна рецептура не є куленепробивною, @KlitosKyriacou. Справа в тому, що forEachне гарантує жодного порядку, а причина - легка паралелізація. Якщо замовлення потрібно зберегти, використовуйте forEachOrdered.
Палець

687

Мій улюблений спосіб прочитати невеликий файл - це використовувати 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(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();
}

Коли я читаю такі рядки, зазвичай я хочу робити обробку рядків у рядку в будь-якому випадку, тож я переходжу до цієї реалізації.

Хоча, якщо я хочу просто прочитати файл у String, я завжди використовую IO 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
}

6
Я вніс невелику поправку, щоб зупинити додавання нового рядка (\ n), якщо буде досягнуто останній рядок. code while (рядок! = null) {sb.append (рядок); line = br.readLine (); // Додайте новий рядок лише тоді, коли curline НЕ є останнім рядком .. if (рядок! = Null) {sb.append ("\ n"); }}code
Рамон Фінкен

2
Подібно до Apache Common IO IOUtils # toString () є sun.misc.IOUtils # readFully (), що входить до JRE Sun / Oracle.
gb96

3
Для продуктивності завжди дзвоніть sb.append ('\ n') у перевагу sb.append ("\ n"), оскільки знак додається до StringBuilder швидше, ніж String
gb96

2
FileReader може кинути FileNotFoundException, а BufferedRead може кинути IOException, тому вам доведеться їх ловити.
камачі

4
немає необхідності використовувати читачі безпосередньо, а також немає потреби в йоутилях. java7 має вбудовані методи для читання цілого файлу / всіх рядків: Див. docs.oracle.com/javase/7/docs/api/java/nio/file/… та docs.oracle.com/javase/7/docs/api / java / nio / file /…
kritzikratzi

142

Найпростіший спосіб - використовувати 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)

28
while (in.hasNext ()) {System.out.println (in.next ()); }
Джин Бо

16
@Hissain Але набагато простіше у використанні, ніжBufferedReader
Ісус Рамос

3
Обов’язково обведіть його спробу Catch
Рахал Канішка

@JesusRamos Не дуже, чому ти так вважаєш? Що в цьому легше, ніж while ((line = br.readLine()) != null) { sb.append(line); }?
користувач207421


57

Ось ще один спосіб зробити це без використання зовнішніх бібліотек:

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

10
або скористайтеся спробу "спробувати з ресурсами" (FileReader reader = новий FileReader (файл))
Hernán Eche

3
Я помітив file.length (), як добре це працює з utf-16 файлами?
Уейн

5
Ця методика передбачає, що read () заповнює буфер; що кількість знаків дорівнює кількості байтів; що кількість байтів вписується в пам'ять; і що кількість байт вписується в ціле число. -1
користувач207421

1
@HermesTrismegistus Я наводив чотири причини, чому це неправильно. StefanReich цілком коректно погодитися зі мною.
користувач207421

34

Мені довелося орієнтувати різні способи. Я прокоментую свої висновки, але, коротше кажучи, найшвидший спосіб - це використовувати звичайний старий 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% повільніше, ніж сировина.

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


24

Ось три робочі та перевірені методи:

Використання 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());
    }
}

1
Як прокласти шлях, якщо папки присутні у проекті?
Кавіпрія

2
Про що java.nio.file.Files? Тепер ми можемо просто використовувати readAllLines, readAllBytesі lines.
Клод Мартін

21

Способи всередині 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)

Або якщо ви віддаєте перевагу Guava (більш сучасну, що активно підтримується бібліотека), вона має подібні утиліти у своєму класі Files . Прості приклади у цій відповіді .
Джонік

1
або ви просто використовуєте вбудований метод, щоб отримати всі рядки: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi

Посилання на apache commons здається мертвим.
кебачки

17

Що ви хочете зробити з текстом? Файл достатньо малий, щоб вміститися в пам'яті? Я б спробував знайти найпростіший спосіб обробки файлу для ваших потреб. Бібліотека FileUtils дуже справляється з цим.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);

2
він також вбудований у java7: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi

@PeterLawrey, ймовірно, означає org.apache.commons.io.FileUtils. Посилання Google може з часом змінювати вміст, оскільки зміщується найпоширеніше значення, але це відповідає його запиту і виглядає правильно.
Палець

2
На жаль, на сьогоднішній день такого немає readLines(String)і readLines(File)застаріло на користь readLines(File, Charset). Кодування може поставлятися також як рядок.
Palec


12

Я задокументував 15 способів прочитати файл на Java і потім протестував їх на швидкість з різними розмірами файлів - від 1 Кб до 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);
        }
      }
    }
  2. 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);
          }
        }
      }
    }
  3. 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);
          });
        }
      }
    }

9

Нижче наводиться однолінійна робота із способом Java 8. Припустимо, що text.txtфайл знаходиться в корені каталогу проектів Eclipse.

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());

7

Використання 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();
}

7

Це в основному те саме, що відповідь Ісуса Рамоса, за винятком файлу замість 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


3
Файл проти FileReader: За допомогою FileReader файл повинен існувати, і дозволи операційної системи повинні дозволяти доступ. За допомогою файлу можна перевірити ці дозволи або перевірити, чи файл є каталогом. У файлі є корисні функції: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), існує (), mkdir (), delete (). File.createTempFile () записує в системний тимчасовий каталог за замовчуванням. Цей метод поверне файл-об’єкт, який можна використовувати для відкриття FileOutputStream об'єктів тощо. Джерело
ThisClark

7

Класи буферизованих потоків на практиці набагато ефективніші, настільки, що 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.


6

Можливо, не так швидко, як з буферизованим введенням / виводом, але досить коротко:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

\ZКартина розповідає , Scannerщо роздільник є EOF.


1
Дуже споріднена, вже існуюча відповідь - Ісус Рамос.
Палець

1
Щоправда, має бути: if(scanner.hasNext()) content = scanner.next();
Давид Сороко

1
Це не вдається для мене на Android 4.4. Прочитано лише 1024 байти. YMMV.
Роджер Кійс

3

Я не бачу його ще згадується в інших відповідях. Але якщо "Кращий" означає швидкість, то новий Java I / O (NIO) може забезпечити найшвидший показник, але не завжди найпростіше зрозуміти того, хто навчається.

http://download.oracle.com/javase/tutorial/essential/io/file.html


Вам слід було б сказати, як це робиться, і не давати посилання для того, щоб слідкувати
Orar

3

Найпростіший спосіб зчитувати дані з файлу на 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. *; для роботи сканера.


2

Guava надає для цього один вкладиш:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);

2

Це може бути не точною відповіддю на питання. Це просто інший спосіб читання файлу, де ви не чітко вказуєте шлях до файлу у вашому коді 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.


2

Ви можете використовувати 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. Це залежно від ваших потреб, який з них підходить.


1

Для веб-додатків Maven на базі JSF просто використовуйте ClassLoader та Resourcesпапку для читання в будь-якому файлі, який ви бажаєте:

  1. Помістіть будь-який файл, який ви хочете прочитати, у папку "Ресурси".
  2. Покладіть залежність AOche Commons IO у свою POM:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Використовуйте код нижче, щоб прочитати його (наприклад, читання у файлі .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- схем тощо.


Ви не можете використовувати це у будь-якому файлі, який ви хочете. Ви можете використовувати його лише для ресурсів, які були запаковані у файл JAR або WAR.
користувач207421


0

Використовуйте Java-поцілунок, якщо мова йде про простоту структури:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

0
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.


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

0

Найінтуїтивніший метод введений в 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 має цю розкіш з десятиліть тому! ☺


-3

Цей код я запрограмував набагато швидше для дуже великих файлів:

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}

10
Набагато швидше, я сумніваюся в цьому, якщо ви використовуєте просте з'єднання рядків замість StringBuilder ...
PhiLho

6
Я думаю, що головне збільшення швидкості - це читання в 1МБ (1024 * 1024) блоках. Однак ви могли зробити те саме, передавши 1024 * 1024 як другий аргумент конструктору BufferedReader.
gb96

3
я не вірю, що це взагалі перевірено. використання +=таким чином дає вам квадратичну (!) складність для завдання, яке повинно бути лінійної складності. це почне сканувати файли на кілька мегабайт. Щоб обійти це, вам слід або зберегти текстові блоки в списку <string>, або скористатися згаданим строкобудівником.
kritzikratzi

5
Набагато швидше, ніж що? Це, звичайно, не швидше, ніж додавання до StringBuffer. -1
користувач207421

1
@ gb96 Я вважав те саме щодо розмірів буфера, але детальний експеримент у цьому питанні дав дивовижні результати в подібному контексті: буфер 16 КБ був стабільно і помітно швидшим.
chiastic-security

-3
String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Наведений вище рядок може бути записаний в один рядок у вигляді:

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

Додавання до конструктора рядків (Якщо файл у вас величезний, рекомендується використовувати інструмент для створення рядків, а також використовувати звичайний об'єкт String)

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();
    }
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.