Когда использовать BufferedReader
В общем, BufferedReader пригодится, если мы хотим читать текст из любого источника ввода, будь то файлы, сокеты или что-то еще.
Проще говоря, это позволяет нам минимизировать количество операций ввода-вывода, считывая фрагменты символов и сохраняя их во внутреннем буфере. Пока в буфере есть данные, считыватель будет считывать их из него, а не непосредственно из базового потока.
2.1. Буферизация Другого Считывателя
Как и большинство классов ввода-вывода Java,/ | BufferedReader реализует Шаблон декоратора, что означает, что он ожидает Reader в своем конструкторе. Таким образом, это позволяет нам гибко расширять экземпляр реализации Reader с функцией буферизации:
BufferedReader reader =
new BufferedReader(new FileReader("src/main/resources/input.txt"));
Но, если буферизация не имеет для нас значения, мы могли бы просто использовать FileReader напрямую:
FileReader reader =
new FileReader("src/main/resources/input.txt");
В дополнение к буферизации, BufferedReader также предоставляет некоторые полезные вспомогательные функции для чтения файлов построчно . Таким образом, хотя может показаться, что проще использовать FileReader напрямую, BufferedReader может быть большой помощью.
2.2. Буферизация потока
В общем, мы можем настроить BufferedReader для использования любого типа входного потока | в качестве базового источника . Мы можем сделать это с помощью InputStreamReader и обернуть его в конструктор:
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
В приведенном выше примере мы читаем из System.in , который обычно соответствует вводу с клавиатуры. Аналогично, мы могли бы передать входной поток для чтения из сокета, файла или любого мыслимого типа текстового ввода. Единственным условием является наличие подходящего InputStream реализация для него.
2.3. BufferedReader vs Сканер
В качестве альтернативы мы могли бы использовать класс Scanner для достижения той же функциональности, что и с BufferedReader.
Однако между этими двумя классами существуют существенные различия, которые могут сделать их более или менее удобными для нас, в зависимости от нашего варианта использования:
- BufferedReader синхронизируется (потокобезопасно), а сканер – нет
- Сканер может анализировать примитивные типы и строки с помощью регулярных выражений
- BufferedReader позволяет изменять размер буфера, в то время как сканер не имеет фиксированного размера буфера
- BufferedReader имеет больший размер буфера по умолчанию
- Сканер скрывает IOException , в то время как BufferedReader заставляет нас обрабатывать его
- BufferedReader обычно быстрее, чем Сканер , потому что он только считывает данные без их анализа
Имея это в виду, если мы анализируем отдельные токены в файле, то Scanner будет чувствовать себя немного более естественно, чем BufferedReader. Но просто чтение строки за раз-это то, где BufferedReader сияет.
При необходимости у нас также есть руководство по сканеру.
Другие Полезные Методы
Теперь давайте сосредоточимся на различных полезных методах, доступных в BufferedReader.
4.1. Чтение одного символа
Мы можем использовать метод read() для чтения одного символа. Давайте прочитаем весь контент по символам до конца потока:
public String readAllCharsOneByOne(BufferedReader reader) throws IOException {
StringBuilder content = new StringBuilder();
int value;
while ((value = reader.read()) != -1) {
content.append((char) value);
}
return content.toString();
}
Это приведет к считыванию символов (возвращаемых в виде значений ASCII), приведению их к char и добавлению их к результату. Мы повторяем это до конца потока, на что указывает значение ответа -1 из метода read () .
4.2. Чтение Нескольких Символов
Если мы хотим прочитать несколько символов одновременно, мы можем использовать метод read(char[] cbuf, int off, int len) :
public String readMultipleChars(BufferedReader reader) throws IOException {
int length;
char[] chars = new char;
int charsRead = reader.read(chars, 0, length);
String result;
if (charsRead != -1) {
result = new String(chars, 0, charsRead);
} else {
result = "";
}
return result;
}
В приведенном выше примере кода мы прочитаем до 5 символов в массив символов и построим из него строку. В случае, если в нашей попытке чтения не было прочитано ни одного символа (т. Е. Мы достигли конца потока), мы просто вернем пустую строку.
4.3. Пропуск Символов
Мы также можем пропустить заданное количество символов, вызвав метод skip(long n) :
@Test
public void givenBufferedReader_whensSkipChars_thenOk() throws IOException {
StringBuilder result = new StringBuilder();
try (BufferedReader reader =
new BufferedReader(new StringReader("1__2__3__4__5"))) {
int value;
while ((value = reader.read()) != -1) {
result.append((char) value);
reader.skip(2L);
}
}
assertEquals("12345", result);
}
В приведенном выше примере мы читаем из входной строки, которая содержит числа, разделенные двумя символами подчеркивания. Чтобы построить строку, содержащую только числа, мы пропускаем подчеркивания, вызывая метод skip .
4.4. пометка и сброс
Мы можем использовать методы mark(int readAheadLimit) и reset () , чтобы отметить некоторую позицию в потоке и вернуться к ней позже. В качестве несколько надуманного примера давайте использовать mark() и reset () , чтобы игнорировать все пробелы в начале потока:
@Test
public void givenBufferedReader_whenSkipsWhitespacesAtBeginning_thenOk()
throws IOException {
String result;
try (BufferedReader reader =
new BufferedReader(new StringReader(" Lorem ipsum dolor sit amet."))) {
do {
reader.mark(1);
} while(Character.isWhitespace(reader.read()))
reader.reset();
result = reader.readLine();
}
assertEquals("Lorem ipsum dolor sit amet.", result);
}
В приведенном выше примере мы используем метод mark () , чтобы отметить позицию, которую мы только что прочитали. Присвоение ему значения 1 означает, что только код запомнит метку на один символ вперед. Это удобно здесь, потому что, как только мы увидим наш первый символ без пробелов, мы сможем вернуться и перечитывать этот символ без необходимости повторной обработки всего потока. Не имея метки, мы потеряем L в нашей последней строке.
Обратите внимание , что, поскольку mark() может вызвать исключение UnsupportedOperationException , довольно часто связывают markSupported() с кодом, который вызывает mark (). Хотя на самом деле он нам здесь не нужен
Это потому, что markSupported() всегда возвращает true для BufferedReader .
Конечно, мы могли бы сделать это немного более элегантно другими способами, и действительно, mark и reset не очень типичные методы. Они, безусловно, пригодятся, хотя, когда есть необходимость смотреть вперед .
BufferedReader Читает файл
Мы можем использовать BufferedReader для считывания содержимого текстового файла в массив символов .
BufferedReader эффективен для чтения файла, поскольку он буферизует входные данные из указанного файла. Без буферизации каждый вызов методов read() или readLine() будет считывать байты из файла, затем преобразовываться в символы и возвращаться, что будет очень неэффективно.
package com.journaldev.io.readfile;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ReadFileUsingBufferedReader {
public static void main(String[] args) {
BufferedReader reader;
char[] buffer = new char;
try {
reader = new BufferedReader(new FileReader(
"/Users/pankaj/Downloads/myfile.txt"));
while (reader.read(buffer) != -1) {
System.out.print(new String(buffer));
buffer = new char;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
В приведенной выше программе я печатаю данные файла на консоль. Давайте рассмотрим другой класс утилит для выполнения операций чтения файлов.
- Прочитайте полный файл в виде строки
- Считывайте файл строка за строкой и возвращайте список строк
- Подсчитайте вхождение строки в данный файл.
package com.journaldev.java;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class ReadFileJavaExample {
/**
* Main function to invoke different functions to
* 1. readCompleteFileAsString - Read complete file as String
* 2. readFileToListOfLines - Read lines from file and return list of line String
* 3. countStringInFile - Count occurrence of a String in the file
* @param args
*/
public static void main(String[] args) {
String filePath = "/Users/pankaj/Downloads/myfile.txt";
String str="Java";
String fileData = readCompleteFileAsString(filePath);
System.out.println("Complete File Data:"+fileData);
List linesData = readFileToListOfLines(filePath);
if(linesData!=null){
for(int i=0; i readFileToListOfLines(String filePath) {
List linesData = new ArrayList();
BufferedReader reader;
try {
reader = new BufferedReader(
new FileReader(filePath));
} catch (FileNotFoundException e) {
System.out.println("File is not present in the classpath or given location.");
return null;
}
String line;
try {
while ((line=reader.readLine()) != null) {
linesData.add(line);
}
} catch (IOException e) {
System.out.println("IOException in reading data from file.");
return null;
}
try {
reader.close();
} catch (IOException e) {
System.out.println("IOException in closing the Buffered Reader.");
return null;
}
return linesData;
}
/**
* This function will read complete file and return it as String
* @param filePath
* @return
*/
private static String readCompleteFileAsString(String filePath) {
StringBuilder fileData = new StringBuilder();
BufferedReader reader;
try {
reader = new BufferedReader(
new FileReader(filePath));
} catch (FileNotFoundException e) {
System.out.println("File is not present in the classpath or given location.");
return null;
}
char[] buf = new char;
int numRead=0;
try {
while((numRead=reader.read(buf)) != -1){
String readData = String.valueOf(buf, 0, numRead);
fileData.append(readData);
buf = new char;
}
} catch (IOException e) {
System.out.println("IOException in reading data from file.");
return null;
}
try {
reader.close();
} catch (IOException e) {
System.out.println("IOException in closing the Buffered Reader.");
return null;
}
return fileData.toString();
}
}
();>
Reversing a File
<source lang="java">
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class ReverseLines {
public static void main(String[] args) {
try {
BufferedReader input = new BufferedReader(new FileReader(args));
ArrayList list = new ArrayList();
String line;
while ((line = input.readLine()) != null) {
list.add(line);
}
input.close();
Collections.reverse(list);
PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(args)));
for (Iterator i = list.iterator(); i.hasNext();) {
output.println((String) i.next());
}
output.close();
} catch (IOException e) {
System.err.println(e);
}
}
}</source>
Create BufferReader from InputStreamReader
<source lang="java">
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Locale;
public class DateClient {
final static int PORT = 5000;
public static void main(String[] args) {
try {
Socket s = new Socket("localhost", PORT);
ObjectOutputStream oos;
oos = new ObjectOutputStream(s.getOutputStream());
oos.writeObject(Locale.getDefault());
InputStreamReader isr;
isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
System.out.println(br.readLine());
} catch (Exception e) {
System.err.println(e);
}
}
}</source>
Git Essentials
Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!
Файл используется для чтения файлов. Он предлагает методы и , которые возвращают один символ и несколько символов соответственно. Кроме того, он принимает или в конструктор.
Считыватель файлов.чтение(символ[])
Давайте откроем файл с помощью и прочитаем его содержимое:
FileReader in = new FileReader("input.txt");
char[] chars = new char;
int n = in.read(chars, 0, chars.length);
String contents = new String(chars);
Метод принимает последовательность символов (в которой мы храним прочитанные символы), начальную и конечную точки того, что мы хотели бы прочитать. В частности, мы решили прочитать не более 256 символов. Если имеет больше, мы будем читать только 256 символов. Если в нем меньше, возвращаются читаемые символы.
Возвращаемое значение, хранящееся внутри целого числа , может быть использовано для проверки того, сколько символов метод на самом деле прочитал. В случае, если достигнут конец потока, метод возвращает .
Поскольку метод заполняет , мы можем преобразовать его в . Аналогичный результат можно получить с помощью .
Читатель файлов.чтение()
Метод без считывает по одному символу за раз. Мы захотим просмотреть содержимое и прочитать каждый символ самостоятельно:
FileReader in = new FileReader("input.txt");
StringBuilder sb = new StringBuilder();
while(in.read() != -1) {
sb.append(in.read());
}
String contents = sb.toString();
in.close();
Здесь мы проверяем, не является ли прочитанный символ , что указывало на то, что для чтения больше не осталось символов. Если нет, мы его в и, наконец, преобразуем его в .
Примечание: Оба и считанные байты, преобразуйте их в символы и возвращайте их по одному . Это неэффективно и должно выполняться с помощью буферизации , когда это возможно.
Буферизатор
-это объект, предназначенный для чтения текста из потока ввода символов. Он буферизован, что означает, что он использует внутренний буфер для временного хранения. Как мы видели в предыдущем разделе, “обычное” сканирование иногда бывает неэффективным.
Рекомендуется обернуть любой потенциально дорогостоящий в для повышения производительности, поскольку буферизация символов обеспечивает более эффективное чтение входного текста.
Давайте создадим экземпляр :
BufferedReader in = new BufferedReader(new FileReader("input.txt"));
На данный момент у нас есть объект bufferedreader, готовый для чтения содержимого из . В этом примере мы будем читать файл построчно, хотя поддерживает чтение отдельных символов по отдельности, а также нескольких символов в массив.
Давайте используем этот экземпляр для чтения файла и сохранения его содержимого, строка за строкой, в строку:
StringBuilder sb = new StringBuilder();
while(in.readLine != null) {
sb.append(in.readLine()).append("\n");
}
String contents = sb.toString();
in.close();
Еще раз, мы используем для сбора всех строк. Чтобы разделить каждую строку, мы добавляем нулевой терминатор ( ) между ними. Наконец, мы закрываем ручей.
Вывод
В этой статье мы рассмотрели некоторые распространенные методы чтения файлов в строки на Java. Существует множество вариантов, но большинство из них имеют схожий основной принцип: укажите путь к файлу, прочитайте содержимое в структуру данных (например, или строку); затем выполните некоторую окончательную обработку, чтобы собрать все содержимое файла соответствующим образом.
Мы рассмотрели метод , метод , метод , а также классы , и
Буферизация символьных потоков. BufferedReader и BufferedWriter
Последнее обновление: 26.04.2018
Запись текста через буфер и BufferedWriter
Класс BufferedWriter записывает текст в поток, предварительно буферизируя записываемые символы, тем самым снижая количество
обращений к физическому носителю для записи данных.
Класс BufferedWriter имеет следующие конструкторы:
BufferedWriter(Writer out) BufferedWriter(Writer out, int sz)
В качестве параметра он принимает поток вывода, в который надо осуществить запись. Второй параметр указывает на размер буфера.
Например, осуществим запись в файл:
import java.io.*;
public class Program {
public static void main(String[] args) {
try(BufferedWriter bw = new BufferedWriter(new FileWriter("notes4.txt")))
{
String text = "Hello World!\nHey! Teachers! Leave them kids alone.";
bw.write(text);
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
}
}
Чтение текста и BufferedReader
Класс BufferedReader считывает текст из символьного потока ввода, буферизируя прочитанные символы. Использование буфера
призвано увеличить производительность чтения данных из потока.
Класс BufferedReader имеет следующие конструкторы:
BufferedReader(Reader in) BufferedReader(Reader in, int sz)
Второй конструктор, кроме потока ввода, из которого производится чтение, также определяет размер буфера, в который будут считываться символы.
Так как BufferedReader наследуется от класса , то он может использовать все те методы для чтения из потока, которые определены в
Reader. И также BufferedReader определяет свой собственный метод readLine(), который позволяет считывать из потока построчно.
Рассмотрим применение BufferedReader:
import java.io.*;
public class Program {
public static void main(String[] args) {
try(BufferedReader br = new BufferedReader (new FileReader("notes4.txt")))
{
// чтение посимвольно
int c;
while((c=br.read())!=-1){
System.out.print((char)c);
}
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
}
}
Также можно считать текст построчно:
try(BufferedReader br = new BufferedReader(new FileReader("notes4.txt")))
{
//чтение построчно
String s;
while((s=br.readLine())!=null){
System.out.println(s);
}
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
Считывание с консоли в файл
Соединим оба класса BufferedReader и BufferedWriter для считывания с консоли в файл. Для этого определим следующий код программы:
import java.io.*;
public class Program {
public static void main(String[] args) {
try(BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new FileWriter("notes5.txt")))
{
// чтение построчно
String text;
while(!(text=br.readLine()).equals("ESC")){
bw.write(text + "\n");
bw.flush();
}
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
}
}
Здесь объект BufferedReader устанавливается для чтения с консоли с помощью объекта .
В цикле while считывается введенный текст. И пока пользователь не введет строку «ESC», объект BufferedWriter будет записывать текст файл.
НазадВперед
FileInputStream – Считывание двоичных файлов в байты
Мы всегда должны использовать поток для чтения файлов, не основанных на символах, таких как изображения, видео и т.д.
package com.journaldev.io.readfile;
import java.io.FileInputStream;
import java.io.IOException;
public class ReadFileUsingFileInputStream {
public static void main(String[] args) {
FileInputStream fis;
byte[] buffer = new byte;
try {
fis = new FileInputStream("/Users/pankaj/Downloads/myfile.txt");
while (fis.read(buffer) != -1) {
System.out.print(new String(buffer));
buffer = new byte;
}
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Операция чтения FileInputStream используется с массивом байтов, в то время как операция чтения BufferedReader использует массив символов.
Поток ввода файлов – Более высокая производительность
3.1 Просмотрите исходный код , каждый вызовет метод для чтения байта с диска.
package java.io;
public class FileInputStream extends InputStream {
/**
* Reads a byte of data from this input stream. This method blocks
* if no input is yet available.
*
* @return the next byte of data, or -1 if the end of the
* file is reached.
* @exception IOException if an I/O error occurs.
*/
public int read() throws IOException {
return read0();
}
private native int read0() throws IOException;
//...
}
3.2 Мы можем использовать для чтения предопределенных байтов в массив байтов; это значительно увеличит производительность чтения.
package com.mkyong.io.api.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileInputStreamExample3 {
public static void main(String[] args) {
readFileBetterPerformance("c:\\test\\file.txt");
}
private static void readFileBetterPerformance(String fileName) {
try (FileInputStream fis = new FileInputStream(new File(fileName))) {
// remaining bytes that can be read
System.out.println("Remaining bytes that can be read : " + fis.available());
// 8k a time
byte[] bytes = new byte;
// reads 8192 bytes at a time, if end of the file, returns -1
while (fis.read(bytes) != -1) {
// convert bytes to string for demo
System.out.println(new String(bytes, StandardCharsets.UTF_8));
System.out.println("Remaining bytes that can be read : " + fis.available());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Приведенный выше пример будет гласить байт за раз, а для файла, содержащего 10 байт, он считывается только один раз.
Remaining bytes that can be read : 10 mkyong.com Remaining bytes that can be read : 0
Примечание Например, если файл, содержащий байт (80 кб), значение по умолчанию потребует 81920 собственных вызовов для чтения всех байтов из файла; В то время как (для размера 8192) нам нужно всего 10 собственных вызовов. Разница огромна.
Read content of a file
<source lang="java">
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class Main {
public static void main(String[] argv) {
readTextFile(new File("c:\\a.txt"));
}
public static String readTextFile(File filename) {
try {
BufferedReader br = new BufferedReader(new FileReader(filename));
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line + "\n");
line = br.readLine();
}
br.close();
return sb.toString();
} catch (Exception e) {
e.printStackTrace();
System.err.println(filename);
System.err.println(e);
return "";
}
}
}</source>
RandomAccessFile – Чтение файлов в режиме только для чтения
Класс RandomAccessFile позволяет нам читать файл в разных режимах. Это хороший вариант, если вы хотите убедиться, что в файле не выполняется случайная операция записи.
package com.journaldev.io.readfile;
import java.io.IOException;
import java.io.RandomAccessFile;
public class ReadFileUsingRandomAccessFile {
public static void main(String[] args) {
try {
RandomAccessFile file = new RandomAccessFile("/Users/pankaj/Downloads/myfile.txt", "r");
String str;
while ((str = file.readLine()) != null) {
System.out.println(str);
}
file.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Это все для чтения файла на Java с использованием различных классов из Java IO API.
Рекомендации:
Поток ввода файла против потока ввода буфера
Поток считывает байт за раз, и каждый будет собственным считыванием с диска. Для чтения большого файла это замедлится.
считывает байт (по умолчанию) за раз и буферизует их до тех пор, пока они не понадобятся; по-прежнему возвращает по одному байту за раз, но остальные оставшиеся байты находятся в буфере и зарезервированы для следующего чтения. Концепция аналогична описанной выше Концепция аналогична описанной выше
Обычная практика использует для обертывания для обеспечения буферного кэша для повышения производительности чтения.
package com.mkyong.io.api.inputstream;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamExample4 {
public static void main(String[] args) {
readFileBetterPerformance2("c:\\test\\file.txt");
}
private static void readFileBetterPerformance2(String fileName) {
try (BufferedInputStream bis =
new BufferedInputStream(
new FileInputStream(new File(fileName)))) {
// remaining bytes that can be read
System.out.println("Remaining bytes that can be read : " + bis.available());
int content;
// reads 8192 bytes at a time and buffers them until they are needed,
// if end of the file, returns -1
while ((content = bis.read()) != -1) {
// convert bytes to string for demo
System.out.println((char) content);
System.out.println("Remaining bytes that can be read : " + bis.available());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Выход
Remaining bytes that can be read : 10 m Remaining bytes that can be read : 9 k Remaining bytes that can be read : 8 y Remaining bytes that can be read : 7 o Remaining bytes that can be read : 6 n Remaining bytes that can be read : 5 g Remaining bytes that can be read : 4 . Remaining bytes that can be read : 3 c Remaining bytes that can be read : 2 o Remaining bytes that can be read : 1 m Remaining bytes that can be read : 0
Create PrintWriter from BufferedWriter
<source lang="java">
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.EOFException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
public class MainClass {
public static void main(String[] args) throws IOException {
try {
BufferedReader in4 = new BufferedReader(new StringReader("asdf"));
PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
int lineCount = 1;
String s = null;
while((s = in4.readLine()) != null )
out1.println(lineCount++ + ": " + s);
out1.close();
} catch(EOFException e) {
System.err.println("End of stream");
}
}
}</source>
Чтение Текста С Помощью BufferedReader
Давайте пройдем весь процесс создания, использования и уничтожения BufferReader для правильного чтения из текстового файла.
3.1. Инициализация BufferedReader
Во-первых, давайте создадим BufferedReader , используя его BufferedReader(Reader) конструктор :
BufferedReader reader =
new BufferedReader(new FileReader("src/main/resources/input.txt"));
Обертывание File Reader подобным образом-хороший способ добавить буферизацию в качестве аспекта для других читателей.
По умолчанию для этого будет использоваться буфер размером 8 КБ. Однако, если мы хотим буферизировать меньшие или большие блоки, мы можем использовать конструктор BufferedReader(Reader, int) :
BufferedReader reader =
new BufferedReader(new FileReader("src/main/resources/input.txt")), 16384);
Это установит размер буфера равным 16384 байтам (16 КБ).
Оптимальный размер буфера зависит от таких факторов, как тип входного потока и аппаратное обеспечение, на котором выполняется код. По этой причине, чтобы достичь идеального размера буфера, мы должны найти его сами, экспериментируя.
Лучше всего использовать мощность 2 в качестве размера буфера, так как большинство аппаратных устройств имеют мощность 2 в качестве размера блока.
Наконец, есть еще один удобный способ создать BufferedReader с помощью Файлов вспомогательного класса из java.nio |/API:
BufferedReader reader =
Files.newBufferedReader(Paths.get("src/main/resources/input.txt"))
Создание его подобным образом-хороший способ буферизации, если мы хотим прочитать файл, потому что нам не нужно сначала вручную создавать FileReader , а затем обертывать его.
3.2. Чтение построчно
Затем давайте прочитаем содержимое файла с помощью метода readLine :
public String readAllLines(BufferedReader reader) throws IOException {
StringBuilder content = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
content.append(line);
content.append(System.lineSeparator());
}
return content.toString();
}
Мы можем сделать то же самое, что и выше, используя метод lines , введенный в Java 8 немного проще:
public String readAllLinesWithStream(BufferedReader reader) {
return reader.lines()
.collect(Collectors.joining(System.lineSeparator()));
}
3.3. Закрытие потока
После использования BufferedReader мы должны вызвать его метод close () , чтобы освободить все системные ресурсы, связанные с ним. Это делается автоматически, если мы используем try-with-resources block:
try (BufferedReader reader =
new BufferedReader(new FileReader("src/main/resources/input.txt"))) {
return readAllLines(reader);
}
