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

Мой любимый способ прочитать небольшой файл - использовать 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();
}

Когда я читаю строки, подобные этому, я обычно хочу делать некоторую обработку строк на строку в любом случае, поэтому я иду на эту реализацию.

Хотя, если я хочу просто прочитать файл в String, я всегда использую Apache Commons IO с помощью метода класса IOUtils.toString(). Вы можете посмотреть источник здесь:

http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

И даже проще с Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}

Самый простой способ - использовать класс Scanner в Java и объект FileReader. Простой пример:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner имеет несколько методов для чтения в строках, числах и т.д. Вы можете найти дополнительную информацию об этом на странице документации Java.

Например, прочитав весь контент в String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Также, если вам нужна конкретная кодировка, вы можете использовать это вместо FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

Вот простое решение:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));

Здесь другой способ сделать это без использования внешних библиотек:

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}

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

Предполагается, что вы должны прочитать файл и сделать что-то значимое с его содержимым. В приведенных здесь примерах читаются строки из журнала и подсчитываются те, которые содержат значения, превышающие определенный порог. Поэтому я предполагаю, что однострочный Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) не является вариантом.

Я тестировал на Java 1.8, Windows 7 и диски SSD и HDD.

Я написал шесть разных реализаций:

rawParse: используйте BufferedInputStream через FileInputStream и затем сокращайте строки, читающие байты по байтам. Это превосходит любой другой однопоточный подход, но может быть очень неудобным для файлов, отличных от ASCII.

lineReaderParse: используйте BufferedReader поверх FileReader, читайте строки за строкой, разделяя строки, вызывая String.split(). Это примерно на 20% медленнее, чем rawParse.

lineReaderParseParallel: это то же самое, что и lineReaderParse, но использует несколько потоков. Это самый быстрый вариант во всех случаях.

nioFilesParse: используйте java.nio.files.Files.lines()

nioAsyncParse. Используйте AsynchronousFileChannel с обработчиком завершения и пулом потоков.

nioMemoryMappedParse: используйте файл с отображением памяти. Это действительно плохая идея, дающая время выполнения как минимум в три раза дольше, чем любая другая реализация.

Это среднее время для чтения 204 файлов с 4 байтами каждый на четырехъядерном i7 и SSD-диске. Файлы создаются "на лету", чтобы избежать кэширования диска.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Я обнаружил разницу, меньшую, чем я ожидал, между запуском на SSD или жестком диске SSD примерно на 15% быстрее. Это может быть связано с тем, что файлы создаются на необразованном жестком диске, и они считываются последовательно, поэтому вращающийся диск может работать как SSD.

Я был удивлен низкой производительностью реализации nioAsyncParse. Либо я реализовал что-то не так, либо многопоточную реализацию с использованием NIO, а обработчик завершения выполняет то же (или даже хуже), чем однопоточную реализацию с API java.io. Кроме того, асинхронный синтаксический разбор с CompletionHandler намного длиннее в строках кода и сложнее реализовать правильно, чем прямая реализация старых потоков.

Теперь шесть реализаций, за которыми следует класс, содержащий их все, плюс параметризованный метод main(), который позволяет воспроизводить количество файлов, размер файла и степень concurrency. Обратите внимание, что размер файлов варьируется плюс минус 20%. Это делается для того, чтобы избежать какого-либо эффекта из-за того, что все файлы имеют точно такой же размер.

rawParse

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(fin);
        int character;
        while((character=bin.read())!=-1) {
            if (character==dl) {

                // Here is where something is done with each line
                doSomethingWithRawLine(lineBuffer.toString());
                lineBuffer.setLength(0);
            }
            else {
                lineBuffer.append((char) character);
            }
        }
        bin.close();
        fin.close();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(256);
    for (int charPos=0; charPos<len; charPos++) {
        char c = line.charAt(charPos);
        if (c==DL0) {
            String fieldValue = fieldBuffer.toString();
            if (fieldValue.length()>0) {
                switch (fieldNumber) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

lineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] fields = line.split(";");
    Date dt = fmt.parse(fields[0]);
    double d = Double.parseDouble(fields[1]);
    int t = Integer.parseInt(fields[2]);
    if (fields[3].equals("overrun"))
        overrunCount++;
}

lineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

nioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] fields = line.split(DL);
        if (fields.length>1) {
            try {
                Date dt = fmt.parse(fields[0]);
            }
            catch (ParseException e) {
            }
            double d = Double.parseDouble(fields[1]);
            int t = Integer.parseInt(fields[2]);
            if (fields[3].equals("overrun"))
                overrunCount++;
        }
    }
}

nioAsyncParse

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();

    for (int b=0; b<numberOfThreads; b++)
        byteBuffers.add(ByteBuffer.allocate(bufferSize));

    for (int f=0; f<numberOfFiles; f++) {
        consumerThreads.acquire();
        String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
        BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int len = bytes.limit();
                int i = 0;
                try {
                    for (i = 0; i < len; i++) {
                        byte by = bytes.get();
                        if (by=='\n') {
                            // ***
                            // The code used to process the line goes here
                            chars.setLength(0);
                        }
                        else {
                                chars.append((char) by);
                        }
                    }
                }
                catch (Exception x) {
                    System.out.println(
                        "Caught exception " + x.getClass().getName() + " " + x.getMessage() +
                        " i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
                        ", position="+String.valueOf(position));
                }

                if (len==limit) {
                    bytes.clear();
                    position += len;
                    channel.read(bytes, position, channel, this);
                }
                else {
                    try {
                        channel.close();
                    }
                    catch (IOException e) {
                    }
                    consumerThreads.release();
                    bytes.clear();
                    buffers.add(bytes);
                }
            }
            else {
                try {
                    channel.close();
                }
                catch (IOException e) {
                }
                consumerThreads.release();
                bytes.clear();
                buffers.add(bytes);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

ПОЛНОЕ ВЗАИМОДЕЙСТВИЕ ВСЕХ СЛУЧАЯХ

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java

Вот три рабочих и проверенных метода:

Использование BufferedReader

package io;
import java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

Использование Scanner

package io;

import java.io.File;
import java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

Использование FileReader

package io;
import java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

Прочитайте весь файл без цикла, используя класс Scanner

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}

Методы внутри org.apache.commons.io.FileUtils также могут быть очень удобными, например:

/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)

Что вы хотите сделать с текстом? Является ли файл достаточно маленьким, чтобы вписаться в память? Я попытался бы найти самый простой способ обработки файла для ваших нужд. Библиотека FileUtils очень удобна для этого.

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

Я задокументировал 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 из-за требования выражения lambda.

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

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

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

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

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

Образец \Z сообщает Scanner, что разделителем является EOF.

Буферизованные классы потоков на практике гораздо более эффективны, настолько, что 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.

Самый простой способ чтения данных из файла в 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();
        }
    }
}

PS: Не забудьте импортировать java.util. *; для работы сканера.

Пока я еще не упомянул об этом в других ответах. Но если "Лучшее" означает скорость, то новый Java I/O (NIO) может обеспечить самую быструю предварительную подготовку, но не всегда легче всего понять, кто-то учится.

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

Это не может быть точным ответом на вопрос. Это просто еще один способ чтения файла, в котором вы явно не указываете путь к вашему файлу в вашем 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.

Guava предоставляет однострочный для этого:

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

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

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

Cactoos дает вам декларативный однострочный шрифт:

new TextOf(new File("a.txt")).asString();

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

• Поместите любой файл, который вы хотите прочитать в папке Ресурсы.

• Положите зависимость IO от Apache Commons в ваш POM:

  <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
  </dependency>
  

• Используйте следующий код, чтобы прочитать его (например, ниже читается в .json файле):

  String metadata = null;
  FileInputStream inputStream;
  try {
  
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      inputStream = (FileInputStream) loader
              .getResourceAsStream("/metadata.json");
      metadata = IOUtils.toString(inputStream);
      inputStream.close();
  }
  catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
  }
  catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
  }
  return metadata;
  

Вы можете сделать то же самое для текстовых файлов, файлов .properties, XSD и т.д.

Вот простое решение:

String content = new String(java.nio.file.Files.readAllBytes(
    java.nio.file.Paths.get("sample.txt")));

Используйте Java kiss, если речь идет о простоте структуры:

import static kiss.API.*;

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

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

Этот код, который я запрограммировал, намного быстрее для очень больших файлов:

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