Чтение простого текстового файла на 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верхнюю часть 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 (...)». Насколько я понимаю, после этой операции порядок будет произвольным.
Даниил Шевелев

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

6
Я сделал небольшую корректировку, чтобы прекратить добавление новой строки (\ n), если достигнута последняя строка. code while (line! = null) {sb.append (line); line = br.readLine (); // Добавлять новую строку можно только тогда, когда curline НЕ является последней строкой .. if (line! = 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
нет необходимости использовать читателей напрямую, а также нет необходимости в ioutils. 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
Нужно окружить его с попыткой поймать
Рахаль Канишка

@JesusRamos Не совсем, почему ты так думаешь? Что проще в этом, чем while ((line = br.readLine()) != null) { sb.append(line); }?
Маркиз Лорн


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
или используйте попытку с использованием ресурсов try (FileReader reader = new FileReader (file))
Эрнан Эче

3
Я заметил file.length (), насколько хорошо это работает с файлами utf-16?
Уэйн

5
Этот метод предполагает, что read () заполняет буфер; что число символов равно количеству байтов; что количество байтов помещается в память; и что количество байтов вписывается в целое число. -1
Маркиз Лорн

1
@HermesTrismegistus Я привел четыре причины, почему это неправильно. StefanReich совершенно правильно согласен со мной.
Маркиз Лорн

35

Я должен был сравнить различные способы. Я прокомментирую мои выводы, но, вкратце, самый быстрый способ - это использовать обычный старый BufferedInputStream поверх FileInputStream. Если нужно прочитать много файлов, то три потока сократят общее время выполнения примерно до половины, но добавление большего количества потоков будет постепенно снижать производительность, пока не потребуется три раза больше времени для завершения с двадцатью потоками, чем с одним потоком.

Предполагается, что вы должны прочитать файл и сделать что-то значимое с его содержимым. В примерах здесь читаются строки из журнала и подсчитываются те, которые содержат значения, превышающие определенный порог. Так что я предполагаю, что однострочная Java 8Files.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


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). Кодировка может быть предоставлена ​​также в виде строки.
Палек


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

По сути, это то же самое, что и ответ Иисуса Рамоса, за исключением того, что 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


3
File vs FileReader. При использовании FileReader файл должен существовать, а разрешения операционной системы должны разрешать доступ. С файлом можно проверить эти разрешения или проверить, является ли файл каталогом. Файл имеет полезные функции: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), exist (), mkdir (), delete (). File.createTempFile () записывает в системный временный каталог по умолчанию. Этот метод возвращает объект файла, который можно использовать для открытия объектов FileOutputStream и т. Д. Source
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


Вы должны были заявить, как это делается, а не давать ссылку для подражания
Орар

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

Гуава предоставляет для этого одну строку:

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. Поместите зависимость Apache 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.
Маркиз Лорн


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
Маркиз Лорн

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.