Как мне создать строку Java из содержимого файла?

Если Вы готовы пользоваться внешней библиотекой, проверьте Apache Commons IO (JAR 200 КБ). Это содержит org.apache.commons.io.FileUtils.readFileToString() метод, который позволяет Вам читать все File в String с одной строкой кода.

Пример:

import java.io.*;
import java.nio.charset.*;
import org.apache.commons.io.*;

public String readFile() throws IOException {
    File file = new File("data.txt");
    return FileUtils.readFileToString(file, StandardCharsets.UTF_8);
}

Если Вы ищете альтернативу, которая не вовлекает стороннюю библиотеку (например, ввод-вывод палаты общин ), можно использовать Сканер класс:

private String readFile(String pathname) throws IOException {

    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int)file.length());        

    try (Scanner scanner = new Scanner(file)) {
        while(scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine() + System.lineSeparator());
        }
        return fileContents.toString();
    }
}

Java пытается быть чрезвычайно общим, и гибким всего он делает. В результате что-то, что относительно просто в языке сценариев (Ваш код был бы заменен" open(file).read()" в Python) намного более сложно. Кажется, нет никакого более короткого способа сделать его, кроме пользования внешней библиотекой (как Willi aus Рор упомянутый). Ваши опции:

• Пользуются внешней библиотекой.
• Копия этот код во все Ваши проекты.
• Создают Вашу собственную мини-библиотеку, которая содержит функции, которые Вы часто используете.

Ваш лучший выбор является, вероятно, 2-м, поскольку это имеет наименьшее количество зависимостей.

Существует изменение на той же теме, которая использует для цикла, вместо некоторое время цикла, для ограничения объема переменной строки. "Лучше" ли это, вопрос персонального вкуса.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}

Тот код нормализует разрывы строки, которые могут или не могут быть тем, что Вы действительно хотите сделать.

Вот альтернатива, которая не делает этого, и которая является (IMO) более простой понять, чем код NIO (хотя это все еще использует java.nio.charset.Charset):

public static String readFile(String file, String csName)
            throws IOException {
    Charset cs = Charset.forName(csName);
    return readFile(file, cs);
}

public static String readFile(String file, Charset cs)
            throws IOException {
    // No real need to close the BufferedReader/InputStreamReader
    // as they're only wrapping the stream
    FileInputStream stream = new FileInputStream(file);
    try {
        Reader reader = new BufferedReader(new InputStreamReader(stream, cs));
        StringBuilder builder = new StringBuilder();
        char[] buffer = new char[8192];
        int read;
        while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
            builder.append(buffer, 0, read);
        }
        return builder.toString();
    } finally {
        // Potential issue here: if this throws an IOException,
        // it will mask any others. Normally I'd use a utility
        // method which would log exceptions and swallow them
        stream.close();
    }        
}

Read весь текст из файла

Java 11 добавил readString () метод для чтения маленьких файлов как String, сохранив разделители строки:

String content = Files.readString(path, StandardCharsets.US_ASCII);

Для версий между Java 7 и 11, вот компактная, устойчивая идиома, обернутая в служебном методе:

static String readFile(String path, Charset encoding) 
  throws IOException 
{
  byte[] encoded = Files.readAllBytes(Paths.get(path));
  return new String(encoded, encoding);
}

строки Read текста из файла

Java 7 добавили удобный метод считать файл как строки текста, представленный как List<String>. Этот подход "с потерями", потому что разделители строки разделяются от конца каждой строки.

List<String> lines = Files.readAllLines(Paths.get(path), encoding);

Java 8 добавил Files.lines() метод для создания Stream<String>. Снова, этот метод с потерями, потому что разделители строки разделяются. Если IOException встречен при чтении файла, он обертывается в UncheckedIOException , так как Stream не принимает лямбды тот бросок контролируемые исключительные ситуации.

try (Stream<String> lines = Files.lines(path, encoding)) {
  lines.forEach(System.out::println);
}

Этому Stream действительно нужно close() вызов; это плохо документируется на API, и я подозреваю, что многие люди не делают даже уведомление Stream имеет close() метод. Обязательно используйте блок ARM как показано.

, Если Вы работаете с источником кроме файла, можно использовать lines() метод в [1 118] вместо этого.

Использование памяти

первый метод, который сохраняет разрывы строки, может временно несколько раз требовать памяти размер файла, потому что в течение короткого времени необработанное содержание файла (массив байтов), и декодируемые символы (каждый из которых составляет 16 битов, даже если закодированный как 8 битов в файле) находится в памяти сразу. Является самым безопасным относиться к файлам, которые Вы знаете, чтобы быть маленькими относительно доступной памяти.

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

Для чтения больших файлов, Вам нужен различный дизайн для Вашей программы, та, которая читает блок текста от потока, обрабатывает его, и затем идет дальше к следующему, снова используя тот же блок памяти фиксированного размера. Здесь, "большой" зависит от компьютерных спецификаций. В наше время этот порог мог бы быть многими гигабайтами RAM. Третий метод, с помощью Stream<String> является одним способом сделать это, если вход "записи", оказывается, отдельные строки. (Используя readLine() метод BufferedReader является процедурным эквивалентом этому подходу.)

Кодировка символов

Одной вещью, которая отсутствует в образце в исходном сообщении, является кодировка символов. Существуют некоторые особые случаи, где значение по умолчанию платформы - то, что Вы хотите, но они редки, и необходимо быть в состоянии, выравнивают по ширине выбор.

StandardCharsets класс определяют некоторые константы для кодировки, требуемой всех Сред выполнения Java:

String content = readFile("test.txt", StandardCharsets.UTF_8);

значение по умолчанию платформы доступно от [1 131] Charset сам класс :

String content = readFile("test.txt", Charset.defaultCharset());

public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

    BufferedReader reader = new BufferedReader(new FileReader(file));

    try {
        char[] buf = new char[1024];

        int r = 0;

        while ((r = reader.read(buf)) != -1) {
            result.append(buf, 0, r);
        }
    }
    finally {
        reader.close();
    }

    return result.toString();
}

Guava имеет метод, похожий на метод из Commons IOUtils, о котором упоминал Вилли Аус Рор:

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

// ...

String text = Files.toString(new File(path), Charsets.UTF_8);

EDIT by PiggyPiglet
Files # toString устарел и подлежит удалению в октябре 2019 года. Вместо этого используйте Files.asCharSource (новый файл (путь), StandardCharsets.UTF_8) .read ();

EDIT by Oscar Reyes

​​Это (упрощенный) базовый код указанной библиотеки:

InputStream in = new FileInputStream(file);
byte[] b  = new byte[file.length()];
int len = b.length;
int total = 0;

while (total < len) {
  int result = in.read(b, total, len - total);
  if (result == -1) {
    break;
  }
  total += result;
}

return new String( b , Charsets.UTF_8 );

Правка (от Jonik): Вышеупомянутое не соответствует исходному коду последних версий Guava. Текущий источник см. В классах Files , CharStreams , ByteSource и CharSource в com.google.common.io пакет.

Чтобы прочитать файл как двоичный и преобразовать в конце

public static String readFileAsString(String filePath) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
    try {
        long len = new File(filePath).length();
        if (len > Integer.MAX_VALUE) throw new IOException("File "+filePath+" too large, was "+len+" bytes.");
        byte[] bytes = new byte[(int) len];
        dis.readFully(bytes);
        return new String(bytes, "UTF-8");
    } finally {
        dis.close();
    }
}