Байтовые потоки (на основе InputStream/OutputStream) обрабатывают бинарные данные (сырые байты) без привязки к кодировке.
Символьные потоки (на основе Reader/Writer) обрабатывают текстовые данные (Unicode символы), автоматически выполняя преобразование байтов в символы и обратно согласно заданной кодировке.
Буферизованные потоки (BufferedInputStream, BufferedReader и их аналоги для вывода) используют внутренний буфер для чтения/записи крупными блоками, что повышает производительность и уменьшает количество обращений к внешнему ресурсу.
Пояснение:
Байтовые vs символьные потоки: Разделение на байтовые и символьные потоки является ключевым для правильной работы с данными. Байтовые потоки читают и пишут данные по байтам. Они ничего не знают о структуре данных – для них любая информация это просто последовательность байтов. Вы выбираете байтовый поток, когда имеете дело с двоичными форматами: например, читаете изображение (JPEG, PNG), видео, ZIP-архив или любые файлы, где содержание не является текстом. В этих случаях не нужно пытаться интерпретировать байты как символы – важно сохранить их точное значение.
Символьные потоки, напротив, предназначены для работы с текстом. Поскольку текст в компьютере также хранится в виде байтов, возникает задача преобразования набора байтов в символы. Различные языки и алфавиты кодируются разными способами (UTF-8, UTF-16, ASCII, ISO 8859-5 и др.). Символьные потоки автоматически выполняют это преобразование, используя кодировку по умолчанию или указанную явно. Например, при чтении файла через FileReader (который является наследником Reader), Java возьмет байты из файла и превратит их во внутреннее представление символов Unicode. Если в системе установлена UTF-8, то байтовая последовательность 0xD0 0x9F будет распознана как символ 'П' (кириллическая П). Аналогично, при записи через Writer, символы преобразуются обратно в байты по указанной кодировке. Практический вывод: для работы с человеческим читаемым текстом (CSV файлы, JSON, исходный код, и т.д.) лучше применять Reader/Writer (часто вместе с BufferedReader/BufferedWriter), чтобы избежать проблем с кодировкой. Если же использовать байтовые потоки (InputStream/OutputStream) для текста, нужно вручную обернуть их в соответствующие InputStreamReader/OutputStreamWriter и указать нужную Charset. Неверная или неуказанная кодировка может привести к искаженному тексту.
Ниже приведен пример чтения текстового файла с помощью символьного потока с буферизацией. Мы используем BufferedReader, который читает данные из файла через FileReader и предоставляет удобный метод readLine() для построчного чтения:
import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
String line;
while ((line = br.readLine()) != null) { // читаем построчно
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
В этом коде BufferedReader внутренне считывает сразу большой блок символов из файла notes.txt, что минимизирует количество обращений к диску. Метод readLine() возвращает сразу строку текста без символов перевода строки, что упрощает обработку содержимого файла построчно. Обратите внимание, мы не указали явно кодировку в FileReader, поэтому он использует системную кодировку по умолчанию. В реальных приложениях желательно указывать кодировку явно, например, создать BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8)), чтобы гарантировать правильное чтение UTF-8 текста независимо от настроек системы.
Буферизованные потоки: Буферизация – распространенный прием оптимизации ввода-вывода. Без буферизации при чтении из файла каждый вызов read() может приводить к системному вызову для чтения единственного байта (или небольшого количества байт) с диска, что относительно медленно. Буферизованный поток (BufferedInputStream для байтов или BufferedReader для символов) оборачивает базовый поток и читает сразу большой блок данных (например, 8 КБ) во внутренний буфер памяти. Затем выдает вам данные по одному байту или по одной строке из этого буфера. Когда буфер расходуется, поток подтягивает следующую порцию данных. Аналогично, BufferedOutputStream и BufferedWriter накапливают данные, предназначенные для записи, во внутреннем буфере, и физически записывают их, когда буфер заполнится (или когда вы вызовете flush()/закроете поток). За счет этого количество обращений к диску или сети резко сокращается, что ускоряет ввод-вывод.
Разработчики часто комбинируют разные обертки потоков: например, можно обернуть FileInputStream в BufferedInputStream, а его – в DataInputStream (для чтения чисел примитивных типов из бинарного файла). Каждый слой добавляет свои возможности: буферизация, преобразование типов, и т.д. Важно помнить про вызов flush() при использовании буферизованных выходных потоков, если нужно гарантировать немедленную запись. В случае входных потоков буферизация происходит прозрачно и не требует дополнительных действий – вы просто читаете данные, как обычно.
Напоследок отметим, что в современной Java (начиная с Java 7 и особенно в Java 8+), помимо классического API java.io, существует пакет java.nio.file с утилитным классом Files. Он предоставляет удобные методы для простых операций ввода-вывода. Например, Files.readAllBytes(path) мгновенно считывает весь файл в массив байтов, Files.write(path, byteArray) записывает массив байтов в файл, Files.lines(path) дает поток строк файла (java.util.stream.Stream), а начиная с Java 11 появился метод Files.readString(path, charset) для чтения всего текста из файла за раз. Внутри эти методы все равно используют потоки, но они позволяют значительно сократить шаблонный код. Тем не менее, знание базовых классов потоков ввода-вывода по-прежнему необходимо, чтобы понимать, что происходит «под капотом» и уметь обрабатывать нестандартные ситуации.
Байтовые и символьные потоки. Буферизация
Байтовые потоки (на основе InputStream/OutputStream) обрабатывают бинарные данные (сырые байты) без привязки к кодировке.
Символьные потоки (на основе Reader/Writer) обрабатывают текстовые данные (Unicode символы), автоматически выполняя преобразование байтов в символы и обратно согласно заданной кодировке.
Буферизованные потоки (BufferedInputStream, BufferedReader и их аналоги для вывода) используют внутренний буфер для чтения/записи крупными блоками, что повышает производительность и уменьшает количество обращений к внешнему ресурсу.
Пояснение:
Байтовые vs символьные потоки: Разделение на байтовые и символьные потоки является ключевым для правильной работы с данными. Байтовые потоки читают и пишут данные по байтам. Они ничего не знают о структуре данных – для них любая информация это просто последовательность байтов. Вы выбираете байтовый поток, когда имеете дело с двоичными форматами: например, читаете изображение (JPEG, PNG), видео, ZIP-архив или любые файлы, где содержание не является текстом. В этих случаях не нужно пытаться интерпретировать байты как символы – важно сохранить их точное значение.
Символьные потоки, напротив, предназначены для работы с текстом. Поскольку текст в компьютере также хранится в виде байтов, возникает задача преобразования набора байтов в символы. Различные языки и алфавиты кодируются разными способами (UTF-8, UTF-16, ASCII, ISO 8859-5 и др.). Символьные потоки автоматически выполняют это преобразование, используя кодировку по умолчанию или указанную явно. Например, при чтении файла через FileReader (который является наследником Reader), Java возьмет байты из файла и превратит их во внутреннее представление символов Unicode. Если в системе установлена UTF-8, то байтовая последовательность 0xD0 0x9F будет распознана как символ 'П' (кириллическая П). Аналогично, при записи через Writer, символы преобразуются обратно в байты по указанной кодировке. Практический вывод: для работы с человеческим читаемым текстом (CSV файлы, JSON, исходный код, и т.д.) лучше применять Reader/Writer (часто вместе с BufferedReader/BufferedWriter), чтобы избежать проблем с кодировкой. Если же использовать байтовые потоки (InputStream/OutputStream) для текста, нужно вручную обернуть их в соответствующие InputStreamReader/OutputStreamWriter и указать нужную Charset. Неверная или неуказанная кодировка может привести к искаженному тексту.
Ниже приведен пример чтения текстового файла с помощью символьного потока с буферизацией. Мы используем BufferedReader, который читает данные из файла через FileReader и предоставляет удобный метод readLine() для построчного чтения:
import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
String line;
while ((line = br.readLine()) != null) { // читаем построчно
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
В этом коде BufferedReader внутренне считывает сразу большой блок символов из файла notes.txt, что минимизирует количество обращений к диску. Метод readLine() возвращает сразу строку текста без символов перевода строки, что упрощает обработку содержимого файла построчно. Обратите внимание, мы не указали явно кодировку в FileReader, поэтому он использует системную кодировку по умолчанию. В реальных приложениях желательно указывать кодировку явно, например, создать BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8)), чтобы гарантировать правильное чтение UTF-8 текста независимо от настроек системы.
Буферизованные потоки: Буферизация – распространенный прием оптимизации ввода-вывода. Без буферизации при чтении из файла каждый вызов read() может приводить к системному вызову для чтения единственного байта (или небольшого количества байт) с диска, что относительно медленно. Буферизованный поток (BufferedInputStream для байтов или BufferedReader для символов) оборачивает базовый поток и читает сразу большой блок данных (например, 8 КБ) во внутренний буфер памяти. Затем выдает вам данные по одному байту или по одной строке из этого буфера. Когда буфер расходуется, поток подтягивает следующую порцию данных. Аналогично, BufferedOutputStream и BufferedWriter накапливают данные, предназначенные для записи, во внутреннем буфере, и физически записывают их, когда буфер заполнится (или когда вы вызовете flush()/закроете поток). За счет этого количество обращений к диску или сети резко сокращается, что ускоряет ввод-вывод.
Разработчики часто комбинируют разные обертки потоков: например, можно обернуть FileInputStream в BufferedInputStream, а его – в DataInputStream (для чтения чисел примитивных типов из бинарного файла). Каждый слой добавляет свои возможности: буферизация, преобразование типов, и т.д. Важно помнить про вызов flush() при использовании буферизованных выходных потоков, если нужно гарантировать немедленную запись. В случае входных потоков буферизация происходит прозрачно и не требует дополнительных действий – вы просто читаете данные, как обычно.
Напоследок отметим, что в современной Java (начиная с Java 7 и особенно в Java 8+), помимо классического API java.io, существует пакет java.nio.file с утилитным классом Files. Он предоставляет удобные методы для простых операций ввода-вывода. Например, Files.readAllBytes(path) мгновенно считывает весь файл в массив байтов, Files.write(path, byteArray) записывает массив байтов в файл, Files.lines(path) дает поток строк файла (java.util.stream.Stream), а начиная с Java 11 появился метод Files.readString(path, charset) для чтения всего текста из файла за раз. Внутри эти методы все равно используют потоки, но они позволяют значительно сократить шаблонный код. Тем не менее, знание базовых классов потоков ввода-вывода по-прежнему необходимо, чтобы понимать, что происходит «под капотом» и уметь обрабатывать нестандартные ситуации.
Символьные потоки (на основе Reader/Writer) обрабатывают текстовые данные (Unicode символы), автоматически выполняя преобразование байтов в символы и обратно согласно заданной кодировке.
Буферизованные потоки (BufferedInputStream, BufferedReader и их аналоги для вывода) используют внутренний буфер для чтения/записи крупными блоками, что повышает производительность и уменьшает количество обращений к внешнему ресурсу.
Пояснение:
Байтовые vs символьные потоки: Разделение на байтовые и символьные потоки является ключевым для правильной работы с данными. Байтовые потоки читают и пишут данные по байтам. Они ничего не знают о структуре данных – для них любая информация это просто последовательность байтов. Вы выбираете байтовый поток, когда имеете дело с двоичными форматами: например, читаете изображение (JPEG, PNG), видео, ZIP-архив или любые файлы, где содержание не является текстом. В этих случаях не нужно пытаться интерпретировать байты как символы – важно сохранить их точное значение.
Символьные потоки, напротив, предназначены для работы с текстом. Поскольку текст в компьютере также хранится в виде байтов, возникает задача преобразования набора байтов в символы. Различные языки и алфавиты кодируются разными способами (UTF-8, UTF-16, ASCII, ISO 8859-5 и др.). Символьные потоки автоматически выполняют это преобразование, используя кодировку по умолчанию или указанную явно. Например, при чтении файла через FileReader (который является наследником Reader), Java возьмет байты из файла и превратит их во внутреннее представление символов Unicode. Если в системе установлена UTF-8, то байтовая последовательность 0xD0 0x9F будет распознана как символ 'П' (кириллическая П). Аналогично, при записи через Writer, символы преобразуются обратно в байты по указанной кодировке. Практический вывод: для работы с человеческим читаемым текстом (CSV файлы, JSON, исходный код, и т.д.) лучше применять Reader/Writer (часто вместе с BufferedReader/BufferedWriter), чтобы избежать проблем с кодировкой. Если же использовать байтовые потоки (InputStream/OutputStream) для текста, нужно вручную обернуть их в соответствующие InputStreamReader/OutputStreamWriter и указать нужную Charset. Неверная или неуказанная кодировка может привести к искаженному тексту.
Ниже приведен пример чтения текстового файла с помощью символьного потока с буферизацией. Мы используем BufferedReader, который читает данные из файла через FileReader и предоставляет удобный метод readLine() для построчного чтения:
import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
String line;
while ((line = br.readLine()) != null) { // читаем построчно
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
В этом коде BufferedReader внутренне считывает сразу большой блок символов из файла notes.txt, что минимизирует количество обращений к диску. Метод readLine() возвращает сразу строку текста без символов перевода строки, что упрощает обработку содержимого файла построчно. Обратите внимание, мы не указали явно кодировку в FileReader, поэтому он использует системную кодировку по умолчанию. В реальных приложениях желательно указывать кодировку явно, например, создать BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8)), чтобы гарантировать правильное чтение UTF-8 текста независимо от настроек системы.
Буферизованные потоки: Буферизация – распространенный прием оптимизации ввода-вывода. Без буферизации при чтении из файла каждый вызов read() может приводить к системному вызову для чтения единственного байта (или небольшого количества байт) с диска, что относительно медленно. Буферизованный поток (BufferedInputStream для байтов или BufferedReader для символов) оборачивает базовый поток и читает сразу большой блок данных (например, 8 КБ) во внутренний буфер памяти. Затем выдает вам данные по одному байту или по одной строке из этого буфера. Когда буфер расходуется, поток подтягивает следующую порцию данных. Аналогично, BufferedOutputStream и BufferedWriter накапливают данные, предназначенные для записи, во внутреннем буфере, и физически записывают их, когда буфер заполнится (или когда вы вызовете flush()/закроете поток). За счет этого количество обращений к диску или сети резко сокращается, что ускоряет ввод-вывод.
Разработчики часто комбинируют разные обертки потоков: например, можно обернуть FileInputStream в BufferedInputStream, а его – в DataInputStream (для чтения чисел примитивных типов из бинарного файла). Каждый слой добавляет свои возможности: буферизация, преобразование типов, и т.д. Важно помнить про вызов flush() при использовании буферизованных выходных потоков, если нужно гарантировать немедленную запись. В случае входных потоков буферизация происходит прозрачно и не требует дополнительных действий – вы просто читаете данные, как обычно.
Напоследок отметим, что в современной Java (начиная с Java 7 и особенно в Java 8+), помимо классического API java.io, существует пакет java.nio.file с утилитным классом Files. Он предоставляет удобные методы для простых операций ввода-вывода. Например, Files.readAllBytes(path) мгновенно считывает весь файл в массив байтов, Files.write(path, byteArray) записывает массив байтов в файл, Files.lines(path) дает поток строк файла (java.util.stream.Stream), а начиная с Java 11 появился метод Files.readString(path, charset) для чтения всего текста из файла за раз. Внутри эти методы все равно используют потоки, но они позволяют значительно сократить шаблонный код. Тем не менее, знание базовых классов потоков ввода-вывода по-прежнему необходимо, чтобы понимать, что происходит «под капотом» и уметь обрабатывать нестандартные ситуации.
Автор: к.п.н., Румянцев Сергей Александрович, доцент Финансового университета при Правительстве РФ; доцент ОЧУВО Международного инновационного университета; Консалтинг, управление разработкой ПО; системный и бизнес анализ; менеджмент; аналитиз данных; управление ИТ. Телефон для связи +79269444818 (мессенджеры)
Короткая ссылка:
Байтовые потоки (на основе InputStream/OutputStream) обрабатывают бинарные данные (сырые байты) без привязки к кодировке.
Символьные потоки (на основе Reader/Writer) обрабатывают текстовые данные (Unicode символы), автоматически выполняя преобразование байтов в символы и обратно согласно заданной кодировке.
Буферизованные потоки (BufferedInputStream, BufferedReader и их аналоги для вывода) используют внутренний буфер для чтения/записи крупными блоками, что повышает производительность и уменьшает количество обращений к внешнему ресурсу.
Пояснение:
Байтовые vs символьные потоки: Разделение на байтовые и символьные потоки является ключевым для правильной работы с данными. Байтовые потоки читают и пишут данные по байтам. Они ничего не знают о структуре данных – для них любая информация это просто последовательность байтов. Вы выбираете байтовый поток, когда имеете дело с двоичными форматами: например, читаете изображение (JPEG, PNG), видео, ZIP-архив или любые файлы, где содержание не является текстом. В этих случаях не нужно пытаться интерпретировать байты как символы – важно сохранить их точное значение.
Символьные потоки, напротив, предназначены для работы с текстом. Поскольку текст в компьютере также хранится в виде байтов, возникает задача преобразования набора байтов в символы. Различные языки и алфавиты кодируются разными способами (UTF-8, UTF-16, ASCII, ISO 8859-5 и др.). Символьные потоки автоматически выполняют это преобразование, используя кодировку по умолчанию или указанную явно. Например, при чтении файла через FileReader (который является наследником Reader), Java возьмет байты из файла и превратит их во внутреннее представление символов Unicode. Если в системе установлена UTF-8, то байтовая последовательность 0xD0 0x9F будет распознана как символ 'П' (кириллическая П). Аналогично, при записи через Writer, символы преобразуются обратно в байты по указанной кодировке. Практический вывод: для работы с человеческим читаемым текстом (CSV файлы, JSON, исходный код, и т.д.) лучше применять Reader/Writer (часто вместе с BufferedReader/BufferedWriter), чтобы избежать проблем с кодировкой. Если же использовать байтовые потоки (InputStream/OutputStream) для текста, нужно вручную обернуть их в соответствующие InputStreamReader/OutputStreamWriter и указать нужную Charset. Неверная или неуказанная кодировка может привести к искаженному тексту.
Ниже приведен пример чтения текстового файла с помощью символьного потока с буферизацией. Мы используем BufferedReader, который читает данные из файла через FileReader и предоставляет удобный метод readLine() для построчного чтения:
import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
String line;
while ((line = br.readLine()) != null) { // читаем построчно
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
В этом коде BufferedReader внутренне считывает сразу большой блок символов из файла notes.txt, что минимизирует количество обращений к диску. Метод readLine() возвращает сразу строку текста без символов перевода строки, что упрощает обработку содержимого файла построчно. Обратите внимание, мы не указали явно кодировку в FileReader, поэтому он использует системную кодировку по умолчанию. В реальных приложениях желательно указывать кодировку явно, например, создать BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8)), чтобы гарантировать правильное чтение UTF-8 текста независимо от настроек системы.
Буферизованные потоки: Буферизация – распространенный прием оптимизации ввода-вывода. Без буферизации при чтении из файла каждый вызов read() может приводить к системному вызову для чтения единственного байта (или небольшого количества байт) с диска, что относительно медленно. Буферизованный поток (BufferedInputStream для байтов или BufferedReader для символов) оборачивает базовый поток и читает сразу большой блок данных (например, 8 КБ) во внутренний буфер памяти. Затем выдает вам данные по одному байту или по одной строке из этого буфера. Когда буфер расходуется, поток подтягивает следующую порцию данных. Аналогично, BufferedOutputStream и BufferedWriter накапливают данные, предназначенные для записи, во внутреннем буфере, и физически записывают их, когда буфер заполнится (или когда вы вызовете flush()/закроете поток). За счет этого количество обращений к диску или сети резко сокращается, что ускоряет ввод-вывод.
Разработчики часто комбинируют разные обертки потоков: например, можно обернуть FileInputStream в BufferedInputStream, а его – в DataInputStream (для чтения чисел примитивных типов из бинарного файла). Каждый слой добавляет свои возможности: буферизация, преобразование типов, и т.д. Важно помнить про вызов flush() при использовании буферизованных выходных потоков, если нужно гарантировать немедленную запись. В случае входных потоков буферизация происходит прозрачно и не требует дополнительных действий – вы просто читаете данные, как обычно.
Напоследок отметим, что в современной Java (начиная с Java 7 и особенно в Java 8+), помимо классического API java.io, существует пакет java.nio.file с утилитным классом Files. Он предоставляет удобные методы для простых операций ввода-вывода. Например, Files.readAllBytes(path) мгновенно считывает весь файл в массив байтов, Files.write(path, byteArray) записывает массив байтов в файл, Files.lines(path) дает поток строк файла (java.util.stream.Stream), а начиная с Java 11 появился метод Files.readString(path, charset) для чтения всего текста из файла за раз. Внутри эти методы все равно используют потоки, но они позволяют значительно сократить шаблонный код. Тем не менее, знание базовых классов потоков ввода-вывода по-прежнему необходимо, чтобы понимать, что происходит «под капотом» и уметь обрабатывать нестандартные ситуации.
https://webprogr.ru/~XnqJg
Символьные потоки (на основе Reader/Writer) обрабатывают текстовые данные (Unicode символы), автоматически выполняя преобразование байтов в символы и обратно согласно заданной кодировке.
Буферизованные потоки (BufferedInputStream, BufferedReader и их аналоги для вывода) используют внутренний буфер для чтения/записи крупными блоками, что повышает производительность и уменьшает количество обращений к внешнему ресурсу.
Пояснение:
Байтовые vs символьные потоки: Разделение на байтовые и символьные потоки является ключевым для правильной работы с данными. Байтовые потоки читают и пишут данные по байтам. Они ничего не знают о структуре данных – для них любая информация это просто последовательность байтов. Вы выбираете байтовый поток, когда имеете дело с двоичными форматами: например, читаете изображение (JPEG, PNG), видео, ZIP-архив или любые файлы, где содержание не является текстом. В этих случаях не нужно пытаться интерпретировать байты как символы – важно сохранить их точное значение.
Символьные потоки, напротив, предназначены для работы с текстом. Поскольку текст в компьютере также хранится в виде байтов, возникает задача преобразования набора байтов в символы. Различные языки и алфавиты кодируются разными способами (UTF-8, UTF-16, ASCII, ISO 8859-5 и др.). Символьные потоки автоматически выполняют это преобразование, используя кодировку по умолчанию или указанную явно. Например, при чтении файла через FileReader (который является наследником Reader), Java возьмет байты из файла и превратит их во внутреннее представление символов Unicode. Если в системе установлена UTF-8, то байтовая последовательность 0xD0 0x9F будет распознана как символ 'П' (кириллическая П). Аналогично, при записи через Writer, символы преобразуются обратно в байты по указанной кодировке. Практический вывод: для работы с человеческим читаемым текстом (CSV файлы, JSON, исходный код, и т.д.) лучше применять Reader/Writer (часто вместе с BufferedReader/BufferedWriter), чтобы избежать проблем с кодировкой. Если же использовать байтовые потоки (InputStream/OutputStream) для текста, нужно вручную обернуть их в соответствующие InputStreamReader/OutputStreamWriter и указать нужную Charset. Неверная или неуказанная кодировка может привести к искаженному тексту.
Ниже приведен пример чтения текстового файла с помощью символьного потока с буферизацией. Мы используем BufferedReader, который читает данные из файла через FileReader и предоставляет удобный метод readLine() для построчного чтения:
import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;
try (BufferedReader br = new BufferedReader(new FileReader("notes.txt"))) {
String line;
while ((line = br.readLine()) != null) { // читаем построчно
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
В этом коде BufferedReader внутренне считывает сразу большой блок символов из файла notes.txt, что минимизирует количество обращений к диску. Метод readLine() возвращает сразу строку текста без символов перевода строки, что упрощает обработку содержимого файла построчно. Обратите внимание, мы не указали явно кодировку в FileReader, поэтому он использует системную кодировку по умолчанию. В реальных приложениях желательно указывать кодировку явно, например, создать BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("notes.txt"), StandardCharsets.UTF_8)), чтобы гарантировать правильное чтение UTF-8 текста независимо от настроек системы.
Буферизованные потоки: Буферизация – распространенный прием оптимизации ввода-вывода. Без буферизации при чтении из файла каждый вызов read() может приводить к системному вызову для чтения единственного байта (или небольшого количества байт) с диска, что относительно медленно. Буферизованный поток (BufferedInputStream для байтов или BufferedReader для символов) оборачивает базовый поток и читает сразу большой блок данных (например, 8 КБ) во внутренний буфер памяти. Затем выдает вам данные по одному байту или по одной строке из этого буфера. Когда буфер расходуется, поток подтягивает следующую порцию данных. Аналогично, BufferedOutputStream и BufferedWriter накапливают данные, предназначенные для записи, во внутреннем буфере, и физически записывают их, когда буфер заполнится (или когда вы вызовете flush()/закроете поток). За счет этого количество обращений к диску или сети резко сокращается, что ускоряет ввод-вывод.
Разработчики часто комбинируют разные обертки потоков: например, можно обернуть FileInputStream в BufferedInputStream, а его – в DataInputStream (для чтения чисел примитивных типов из бинарного файла). Каждый слой добавляет свои возможности: буферизация, преобразование типов, и т.д. Важно помнить про вызов flush() при использовании буферизованных выходных потоков, если нужно гарантировать немедленную запись. В случае входных потоков буферизация происходит прозрачно и не требует дополнительных действий – вы просто читаете данные, как обычно.
Напоследок отметим, что в современной Java (начиная с Java 7 и особенно в Java 8+), помимо классического API java.io, существует пакет java.nio.file с утилитным классом Files. Он предоставляет удобные методы для простых операций ввода-вывода. Например, Files.readAllBytes(path) мгновенно считывает весь файл в массив байтов, Files.write(path, byteArray) записывает массив байтов в файл, Files.lines(path) дает поток строк файла (java.util.stream.Stream), а начиная с Java 11 появился метод Files.readString(path, charset) для чтения всего текста из файла за раз. Внутри эти методы все равно используют потоки, но они позволяют значительно сократить шаблонный код. Тем не менее, знание базовых классов потоков ввода-вывода по-прежнему необходимо, чтобы понимать, что происходит «под капотом» и уметь обрабатывать нестандартные ситуации.
Короткая ссылка на новость:https://webprogr.ru/~XnqJg
Последние новости