В каких случаях использовать reader и scanner
насколько я знаю, два наиболее распространенных метода чтения символьных данных из файла на Java используют Scanner или BufferedReader . Я также знаю, что BufferedReader эффективно считывайте файлы с помощью буфера, чтобы избежать операций на физическом диске. Мои вопросы:
- тут Scanner выполняет, а также BufferedReader ?
- почему бы вам выбрать Scanner над BufferedReader или наоборот?
Scanner используется для разбора токенов из содержимого потока while BufferedReader просто считывает поток и не делает никакого специального разбора.
на самом деле вы можете пройти BufferedReader до scanner в качестве источника символов для анализа.
в настоящее время последний релиз JDK6/build (b27), the Scanner имеет меньший буфер (1024 символов) в отличие от BufferedReader (8192 chars), но этого более чем достаточно.
что касается выбора, используйте Scanner Если вы хотите парсить файл, используйте BufferedReader Если вы хотите читать файл строка за строкой. Также см. вводный текст их aforelinked API документации.
- извлечение = интерпретация данного ввода как токенов (частей). Он может вернуть вам определенные части непосредственно как int, string, decimal и т. д. Смотрите также все те nextXxx() методы Scanner класса.
- чтение = немой потоковой передачи. Он продолжает возвращать вам все символы, которые вы, в свою очередь, должны вручную проверить, хотите ли вы сопоставить или составить что-то полезное. Но если тебе все равно не нужно этого делать . , тогда достаточно чтения.
посмотреть этот ссылке, оттуда цитируется следующее:
BufferedReader-это простой класс, предназначенный для эффективного чтения из подчиненного потока. Как правило, каждый запрос чтения читателя как FileReader вызывает соответствующий запрос на чтение основной поток. Каждый вызов read () или readLine() может заставить байты считываться из файла, преобразовываться в символы и затем возвращается, что может быть очень неэффективно. Эффективность улучшена заметно, если читатель искривлен в BufferedReader.
BufferedReader синхронизирован, поэтому операции чтения на BufferedReader можно безопасно сделать из нескольких потоков.
сканер, с другой стороны, имеет гораздо больше сыра, встроенного в него; это может делать все, что может BufferedReader и на одном уровне эффективность также. Однако, кроме того, сканер может анализировать базовый поток для примитивных типов и строк с помощью регулярных выражения. Он также может обозначать базовый поток с помощью разделитель по вашему выбору. Он может также сделать переднее сканирование основной поток игнорирует разделитель!
сканер, однако, не является потокобезопасным, он должен быть внешним синхронизированный.
выбор использования BufferedReader или сканера зависит от кода вы пишете, если вы пишете простой Буферизованный log reader читатель адекватен. Однако, если вы пишу сканер анализатора XML это более естественный выбор.
даже во время чтения ввода, если вы хотите принять строку ввода пользователя строка и сказать просто добавить его в файл, BufferedReader достаточно хорошо. С другой стороны, если вы хотите принять ввод пользователя в командной с несколько вариантов, а затем намерены выполнять различные операции на основе указанной команды и параметров сканер подойдет лучше.
BufferedReader имеет значительно большую буферную память, чем сканер. Использовать BufferedReader Если вы хотите получить длинные строки из потока, и использовать Scanner Если вы хотите проанализировать определенный тип токена из потока.
Scanner можно использовать tokenize с помощью пользовательского разделителя и анализировать поток в примитивные типы данных, в то время как BufferedReader можно только читать и хранить строку.
BufferedReader это синхронно в то время как Scanner нет. Использовать BufferedReader Если вы работаете с несколькими потоками.
Scanner скрывает IOException в то время как BufferedReader сразу же бросает его.
Я предлагаю использовать BufferedReader для чтения текста. Scanner скрывает IOException пока BufferedReader сразу же бросает его.
- BufferedReader это синхронно в то время как Scanner нет.
- BufferedReader следует использовать, если мы работаем с несколькими потоками.
- BufferedReader имеет значительно большую буферную память, чем Scanner .
- на Scanner имеет небольшой буфер (буфер 1Kb char) в отличие от BufferedReader (8kb байтовый буфер), но этого более чем достаточно.
- BufferedReader немного быстрее по сравнению с Scanner , потому что Scanner делает парсинг входных данных и BufferedReader просто считывает последовательность характеров.
на сканер класс является дополнением Formater класса (используется для преобразования двоичных данных в форматированный текст). Сканер считывает форматированный ввод и преобразует его в двоичную форму. Хотя всегда можно было прочитать форматированный ввод, это потребовало больше усилий, чем большинство программистов предпочли бы. Из-за добавления блока развертки, теперь легко прочитать все типы числовых значений, строк и других типов данных, приходит ли оно от файла диска, клавиатура или другой источник. Сканер может использоваться для чтения входных данных из консоли, файла, строки или любого другого источника, реализующего читаемый интерфейс или ReadableByteChannel. Например, с помощью сканера можно прочитать число с клавиатуры и присвоить его значение переменной.
командой bufferedreader, С другой стороны, является классом ввода-вывода символьного потока. Символьные потоки обеспечивают удобный способ ввода и вывода с точки зрения символов (Unicode). BufferedReader в основном используется для ввода данных с консоли, System.in . Требуется InputStreamReader объект в качестве аргумента.
Основные Отличия:
- сканер
- простой текстовый сканер, который может анализировать примитивные типы и строки с помощью регулярных выражений.
- сканер разбивает входные данные на маркеры с помощью шаблона разделителя, который по умолчанию соответствует пробелам. Полученные токены затем могут быть преобразованы в значения разных типов с помощью различных next методы.
выводит следующий вывод:
тот же вывод может быть сгенерирован с помощью этого кода, который использует регулярное выражение для анализа всех четырех токенов сразу:
командой bufferedreader:
читает текст из потока ввода символов, буферизуя символы, чтобы обеспечить эффективное чтение символов, массивы и строки.
может быть указан размер буфера или использоваться размер по умолчанию. Значение по умолчанию достаточно велико для большинства целей.
В общем случае каждый запрос чтения, сделанный из считывателя, вызывает соответствующий запрос чтения базового символа или потока байтов. Поэтому рекомендуется обернуть BufferedReader вокруг любого читателя, операции read() которого могут быть дорогостоящими, например FileReaders и InputStreamReaders. Например,
будет буферизировать входные данные из указанного файла. Без буферизации каждый вызов read() или readLine () может привести к считыванию байтов из файла, преобразованию в символы, а затем возвращению, что может быть очень неэффективным. Программы, использующие DataInputStreams для текстового ввода, можно локализовать, заменив каждый DataInputStream соответствующим Командой bufferedreader.
Ниже приведены различия между BufferedReader и Scanner
- BufferedReader только считывает данные, но сканер также анализирует данные.
- вы можете читать только строку с помощью BufferedReader, но вы можете читать int, long или float с помощью сканера.
- BufferedReader старше от сканера, он существует из jdk 1.1 в то время как Сканер был добавлен в выпуск JDK 5.
- размер буфера BufferedReader большой(8KB) по сравнению с 1KB из Сканер.
- BufferedReader больше подходит для чтения файла с длинной строкой пока блок развертки более соответствующ для чтения малого входного сигнала потребителя от командная строка.
- BufferedReader синхронизирован, но сканер-нет, что означает, что вы нельзя делить сканер между несколькими потоками.
- BufferedReader быстрее, чем сканер, потому что он не тратит время на разбор
- BufferedReader немного быстрее по сравнению со сканером
- командой bufferedreader это с Явы.пакет io и сканер от java.пакет утиль на основании пунктов мы можем выбрать наш выбор.
разницу между командой bufferedreader и сканер следующие:
- BufferedReader является синхронизироваться но сканер не синхронизируется.
- BufferedReader является thread safe но сканер не потокобезопасными.
- командой bufferedreader имеет большую буферную память но сканер имеет меньшую буферную память.
- командой bufferedreader это быстрее но сканер замедление в исполнении.
код для чтения строки из консоли:
командой bufferedreader:
сканер:
существуют различные способы ввода в java, такие как:
1) BufferedReader 2) Сканер 3) Аргументы Командной Строки
BufferedReader считывает текст из потока ввода символов, буферизуя символы, чтобы обеспечить эффективное чтение символов, массивов и строк.
где сканер-это простой текстовый сканер, который может анализировать примитивные типы и строки с помощью регулярных выражений.
Если вы пишете простой читатель журнала Буферизованный читатель адекватен. если вы пишете сканер синтаксического анализатора XML, это более естественный выбор.
для получения дополнительной информации, пожалуйста, обратитесь:
при чтении ввода с консоли существует два варианта для достижения этого. Первое использование Scanner , используя BufferedReader . У обоих разные характеристики. Это означает различия в том, как его использовать.
сканер обрабатывается как токен. BufferedReader просто читает строку за строкой, заданную как строка. Сканер IT self обеспечивает возможности синтаксического анализа только как nextInt(), nextFloat().
но, что есть другие отличия?
- сканер обрабатывается как токен. BufferedReader как строка/строка потока
- сканер размечается с учетом ввода с помощью regex. Используя командой bufferedreader должны писать дополнительный код
- BufferedReader быстрее, чем сканер *точка нет. 2
- сканер не синхронизирован, BufferedReader синхронизирован
сканер поставляется с версией JDK 1.5 выше.
когда следует использовать сканер, или Буферизованный читатель?
рассмотрим основные различия между ними, с помощью маркера, используя другие линии потока. Когда вам нужны возможности синтаксического анализа, используйте Scanner вместо этого. Но мне более комфортно с BufferedReader. Когда вам нужно прочитать из файла, используйте BufferedReader, потому что он использует буфер при чтении файла. Или вы можете использовать BufferedReader в качестве входа в сканер.
листинг несколько.
java.util.Scanner класса простой текстовый сканер, который может проанализировать типы примитивов и строки. Он внутренне использует регулярные выражения для чтения различных типов.
Java.io.BufferedReader класс считывает текст из потока ввода символов, буферизуя символы, чтобы обеспечить эффективное чтение последовательности символов
1) BufferedReader происходит синхронно, а Scanner нет. BufferedReader должно быть использовано если мы работаем с различные потоки.
2) BufferedReader имеет значительно большую буферную память, чем Scanner . The Scanner имеет небольшой буфер (буфер 1Kb char) в отличие от BufferedReader (8kb байтовый буфер), но этого более чем достаточно.
3) BufferedReader немного быстрее по сравнению с Scanner , потому что Scanner делает разбор входных данных и BufferedReader просто читает последовательность символов.
BufferedReader, вероятно, даст вам лучшую производительность (потому что сканер основан на inputstreamreader, посмотрите источники).ups, для чтения из файлов он использует nio. Когда я тестировал производительность nio против производительности BufferedReader для больших файлов, nio показывает немного лучшую производительность.- для чтения из файла попробуйте Apache Commons IO.
предпочитаю Scanner потому что он не бросает проверенные исключения, и поэтому его использование приводит к более обтекаемому коду.
As far I know, the two most common methods of reading character-based data from a file in Java is using Scanner or BufferedReader . I also know that the BufferedReader reads files efficiently by using a buffer to avoid physical disk operations.
- Does Scanner perform as well as BufferedReader ?
- Why would you choose Scanner over BufferedReader or vice versa?
I generally also use Scanner for reading from standard in ('Scanner in = new Scanner(System.in)' feels much cleaner). Not sure if that's actually less efficient, but since reading from std in is blocking, I can't imagine the efficiency of Scanner would be the issue.
12 Answers 12
Scanner is used for parsing tokens from the contents of the stream while BufferedReader just reads the stream and does not do any special parsing.
In fact you can pass a BufferedReader to a scanner as the source of characters to parse.
I know this topic is old, but I have had mixed results among operating systems using BufferedReader when trying to slurp up content from the streams provided by Process (i.e. capturing output of an external command). Once I changed my code to use Scanner instead, as noted in a separate answer, things started behaving consistently and as expected.
@Reuben But Scanner depends ultimately on something else for its input, which may well be synchronized.
In currently latest JDK6 release/build (b27), the Scanner has a smaller buffer (1024 chars) as opposed to the BufferedReader (8192 chars), but it's more than sufficient.
As to the choice, use the Scanner if you want to parse the file, use the BufferedReader if you want to read the file line by line. Also see the introductory text of their aforelinked API documentations.
- Parsing = interpreting the given input as tokens (parts). It's able to give back you specific parts directly as int, string, decimal, etc. See also all those nextXxx() methods in Scanner class.
- Reading = dumb streaming. It keeps giving back you all characters, which you in turn have to manually inspect if you'd like to match or compose something useful. But if you don't need to do that anyway, then reading is sufficient.
Nice one. Thanks for the buffer tip. Was looking for it all along as native reads are extremely expensive.
@Asif: parsing = interpreting the given input as tokens (parts). It's able to give back you specific parts directly as int, string, decimal, etc. See also all those nextXxx() methods in Scanner class. Reading = dumb streaming. It keeps giving back you all characters, which you in turn have to manually inspect if you'd like to match or compose something useful. But if you don't need to do that anyway, then reading is sufficient.
@BalusC Ok I already used, readInt(); readFloat(); etc. Now got what is the mean of parsing. and BalusC can you give little time to me just 10minutes in chat room, I want to ask little about buffered, how it works.
Scanner ’s buffer will be expanded as needed for the pattern matching. So if you want a larger buffer, you only need to invoke, e.g. findWithinHorizon("\\z", 8192) , on it and afterwards, it will use a buffer with a capacity of 8192 chars (or the entire file if it is smaller than that).
A BufferedReader is a simple class meant to efficiently read from the underling stream. Generally, each read request made of a Reader like a FileReader causes a corresponding read request to be made to underlying stream. Each invocation of read() or readLine() could cause bytes to be read from the file, converted into characters, and then returned, which can be very inefficient. Efficiency is improved appreciably if a Reader is warped in a BufferedReader.
BufferedReader is synchronized, so read operations on a BufferedReader can safely be done from multiple threads.
A scanner on the other hand has a lot more cheese built into it; it can do all that a BufferedReader can do and at the same level of efficiency as well. However, in addition a Scanner can parse the underlying stream for primitive types and strings using regular expressions. It can also tokenize the underlying stream with the delimiter of your choice. It can also do forward scanning of the underlying stream disregarding the delimiter!
A scanner however is not thread safe, it has to be externally synchronized.
The choice of using a BufferedReader or a Scanner depends on the code you are writing, if you are writing a simple log reader Buffered reader is adequate. However if you are writing an XML parser Scanner is the more natural choice.
Even while reading the input, if want to accept user input line by line and say just add it to a file, a BufferedReader is good enough. On the other hand if you want to accept user input as a command with multiple options, and then intend to perform different operations based on the command and options specified, a Scanner will suit better.
Все эти вещи мы можем назвать одним словом — процесс обмена данными между программой и внешним миром. Хотя это уже не одно слово.
Сам процесс обмена данными можно разделить на два типа: получение данных и отправка данных. Например, вы считываете данные с клавиатуры с помощью объекта Scanner — это получение данных. И выводите данные на экран с помощью команды System.out.println() — это отправка данных.
Для описания процесса обмена данными в программировании используется термин поток. Откуда вообще взялось такое название?
В реальной жизни им может быть поток воды или поток людей (людской поток). В программировании же под потоком подразумевают поток данных.
Потоки — это универсальный инструмент. Они позволяют программе получать данные откуда угодно (входящие потоки) и отправляют данные куда угодно (исходящие потоки). Делятся на два вида:
Чтобы потоки можно было «потрогать руками», разработчики Java написали два класса: InputStream и OutputStream .
У класса InputStream есть метод read() , который позволяет читать из него данные. А у класса OutputStream есть метод write() , который позволяет записывать в него данные. У них есть и другие методы, но об этом после.
Байтовые потоки
Что же это за данные и в каком виде их можно читать? Другими словами, какие типы данных поддерживаются этими классами?
О, это универсальные классы, и поэтому они поддерживают самый распространённый тип данных — byte . В OutputStream можно записывать байты (и массивы байт), а из объекта InputStream можно читать байты (или массивы байт). Все — никакие другие типы данных они не поддерживают.
Поэтому такие потоки еще называют байтовыми потоками .
Особенность потоков в том, что данные из них можно читать (писать) только последовательно. Вы не можете прочитать данные из середины потока, не прочитав все данные перед ними.
Именно так работает чтение с клавиатуры через класс Scanner : вы читаете данные с клавиатуры последовательно: строка за строкой. Прочитали строку, прочитали следующую строку, прочитали следующую строку и т.д. Поэтому метод чтения строки и называется nextLine() (дословно — «следующая срока»).
Запись данных в поток OutputStream тоже происходит последовательно. Хороший пример — вывод на экран. Вы выводите строку, за ней еще одну и еще одну. Это последовательный вывод. Вы не можете вывести 1-ю строку, затем 10-ю, а затем вторую. Все данные записываются в поток вывода только последовательно.
Символьные потоки
Недавно вы изучали, что строки — второй по популярности тип данных, и это действительно так. Очень много информации передается в виде символов и целых строк. Компьютер отлично бы передавал все в виде байт, но люди не настолько идеальны.
Java-программисты учли этот факт и написали еще два класса: Reader и Writer . Класс Reader — это аналог класса InputStream , только его метод read() читает не байты, а символы — char . Класс Writer соответствует классу OutputStream , и так же, как и класс Reader , работает с символами ( char ), а не байтами.
Если сравнить эти четыре класса, мы получим такую картину:
Байты (byte) | Символы (char) |
---|---|
Чтение данных | |
Запись данных |
Практическое применение
Сами классы InputStream , OutputStream , Reader и Writer в явном виде никто не использует: они не присоединены ни к каким внешним объектам, из которых можно читать данные (или в которые можно писать данные). Однако у этих четырех классов много классов-наследников, которые умеют очень многое.
2. Класс InputStream
Класс InputStream интересен тем, что является классом-родителем для сотен классов-наследников. В нем самом нет никаких данных, однако у него есть методы, которые есть у всех его классов-наследников.
Объекты-потоки вообще редко хранят в себе данные. Поток — это инструмент чтения/записи данных, но не хранения. Хотя бывают и исключения.
Методы класса InputStream и всех его классов-наследников:
Методы | Описание |
---|---|
Читает один байт из потока | |
Читает массив байт из потока | |
Читает все байты из потока | |
Пропускает n байт в потоке (читает и выкидывает) | |
Проверяет, сколько байт еще осталось в потоке | |
Закрывает поток |
Вкратце пройдемся по этим методам:
Метод read()
Метод read() читает один байт из потока и возвращает его. Вас может сбить тип результата — int , однако так было сделано, потому что тип int — это стандарт всех целых чисел. Три первые байта типа int будут равны нулю.
Метод read(byte[] buffer)
Это вторая модификация метода read() . Он позволяет считать из InputStream сразу массив байт. Массив для сохранения байт нужно передать в качестве параметра. Метод возвращает число — количество реально прочитанных байт.
Допустим у вас буфер на 10 килобайт, и вы читаете данные из файла с помощью класса FileInputStream . Если файл содержит всего 2 килобайта, все данные будут помещены в массив-буфер, а метод вернет число 2048 (2 килобайта).
Метод readAllBytes()
Очень хороший метод. Просто считывает все данные из InputStream , пока они не закончатся, и возвращает их в виде единого массива байт. Очень удобен для чтения небольших файлов. Большие файлы могут физически не поместиться в память, и метод кинет исключение.
Метод skip(long n)
Этот метод позволяет пропустить n первых байт из объекта InputStream . Поскольку данные читаются строго последовательно, этот метод просто вычитывает n первых байт из потока и выбрасывает их.
Возвращает число байт, которые были реально пропущены (если поток закончился раньше, чем прокрутили n байт).
Метод int available()
Метод возвращает количество байт, которое еще осталось в потоке
Метод void close()
Метод close() закрывает поток данных и освобождает связанные с ним внешние ресурсы. После закрытия потока данные из него читать больше нельзя.
Давайте напишем пример программы, которая копирует очень большой файл. Его нельзя весь считать в память с помощью метода readAllBytes() . Пример:
InputStream для чтения из файла
OutputStream для записи в файл
Буфер, в который будем считывать данные
Пока данные есть в потоке
В этом примере мы использовали два класса: FileInputStream — наследник InputStream для чтения данных из файла, и класс FileOutputStream — наследник OutputStream для записи данных в файл. О втором классе расскажем немного позднее.
Еще один интересный момент — это переменная real . Когда из файла будет читаться последний блок данных, легко может оказаться, что его длина меньше 64Кб. Поэтому в output нужно тоже записать не весь буфер, а только его часть: первые real байт. Именно это и делается в методе write() .
Вчера завершился Региональный этап Всероссийской олимпиады школьников. Я участвовал в нем и выбрал для этого язык Java. Основной причиной, почему я решил писать олимпиаду именно на Java заключался в том, что на тот момент я довольно хорошо ее знал и понимал то, как в ней реализовано большинство основных структур данных и функций. Также IntellijIDEA очень сильно способствовала плодотворному кодингу, в ситуациях, когда время является решающим фактором. Да, среды разработки от JetBrains есть и для многих других языков, но среди этих языков нет тех, что обычно используются в спортивном программировании, не считая Python, но использовать здесь его я побаивался из-за того, что этот язык известен прожорливостью.
Однако наш друг, носящий имя индонезийского острова, оказался в некоторых ситуациях еще медленнее, чем прожорливый змей.
Не буду сильно вникать в условия задачи, в решении которой я столкнулся с тем, что программа не успевает справится с задачей за предоставленное время, но отмечу один факт: то решение, которое я написал, являлось эталонным (то есть судьи в пакете с тестами предоставили идентичное решение, но на C), не имело бесконечных циклов и прочего, а его сложность была O(n).
И по итогу можно с точностью сказать, что виновником являлся Scanner и его функция nextInt() .
А теперь более подробно разберемся с тем, как же эта функция работает.
Сама функция состоит всего из одной строчки return nextInt(defaultRadix); .
А вот то, что творится уже внутри этой функции нам гораздо интереснее.
Первым делом идет проверка if ((typeCache != null) && (typeCache instanceof Integer)
&& this.radix == radix) и здесь очень важно понять, чем же является typeCache и откуда он берется. И тут все вполне просто. Он является ничем иным, как строкой нашей консоли, записанной в форме Object и если этот объект (читать как строка, которую мы ввели) является инстансом Integer , то Scanner делает вывод о том, что введенная строка это и есть искомое число и возвращает его.
Тут все хорошо и сложность этой операции О(1). Отсюда можно заключить, что вводя в строчку только одно число мы практически не тратим время на преобразование ввода в число.
Значит едем дальше.
А вот тут-то и появляется виновник торжества.
Если в строке, которую получил Scanner не int или же если там несколько таковых, то вызывается вот такая строка кода:
А под ней скрыто вот что:
До этого я не видел смысла вставлять полный код, но теперь, когда мы дошли до сути, думаю самое время разобраться подробно.
Первые три строчки это просто защита от дурака.
А дальше, как нам подсказывают комментарии тех, кто писал этот код идет проверка «а мы случаем не нашли уже такой паттерн?», но в нашем случае эта проверка всегда будет возвращать ложь, поскольку мы на прошлом этапе уже проверили, что полученная нами строка не int.
И что мы видим в конце? Понимая, что быстрых способов поиска больше нет, Scanner сдается и запускает бесконечный цикл который завершится только, если перебором будет найдено что-то, что нам подходит.
А какая у нас сложность у такого перебора? Там вроде бы используется конечно метод двух указателей или что-то на него похожее, но это в любом случае не спасает от множества проверок.
Итог: в случае, когда вам нужно, чтобы программа действительно быстро считала целые числа из консоли, не доверяйте это дело Scanner.nextInt() . Даже банальное Scanner.nextLine и разбиение String в String[] и превращение каждого из членов данного массива в int окажется значительно быстрее.
кто-нибудь знает, есть ли разница в производительности между двумя способами чтения входного файла ниже? Спасибо.
1) чтение файла со сканером и файлом
2) чтение файла с помощью InputStreamReader и FileInputStream
первый момент заключается в том, что ни из этих образцов кода прочитайте файл. Это может показаться глупым или неправильным, но это правда. На самом деле они открывают файл для чтения. И с точки зрения того, что они на самом деле делают, вероятно, нет большой разницы в их соответствующей эффективности.
когда дело доходит до фактического чтения файла, лучший подход к использованию будет зависеть от того, что содержит файл, в какой форме должны быть данные для ваших алгоритмов в памяти, так далее. Это определит, лучше ли использовать Scanner или raw Reader С точки зрения производительности и главное С точки зрения обеспечения надежности и ремонтопригодности вашего кода.
наконец, есть вероятность, что это не будет иметь существенного значения для общей производительности вашего кода. Я говорю о том, что вы преждевременно оптимизируете свое приложение. Вам лучше игнорировать производительность сейчас и выбрать версию, которая сделает остальной код проще. Когда приложение работает, профилируйте его с некоторыми репрезентативными входными данными. Профилирование покажет вам время, потраченное на чтение файла, в абсолютном выражении и относительно остальной части приложения. Это скажет вам, является ли это стоит чтобы попытаться оптимизировать чтение файлов.
единственный совет по производительности, который я бы дал, - это чтение символов из небуферизованного входного потока или считывателя неэффективный. Если файл должен быть прочитан таким образом, вы должны добавить BufferedReader в стек.
с точки зрения производительности, сканер, безусловно, медленнее, по крайней мере из моего опыта. Он создан для анализа, а не для чтения огромных блоков данных. InputStreamReader, с достаточно большим буфером, может выполнять наравне с BufferedReader, который, как я помню, в несколько раз быстрее, чем сканер для чтения из списка словарей. вот сравнение между BufferedReader и InputStreamReader. Помните, что BufferedReader в несколько раз быстрее сканера.
разница, и принципал, я думаю, заключается в том, что с BufferedReader/InputStreamReader вы можете прочитать весь документ символ за символом, если хотите. Со сканером это невозможно. Это означает, что с помощью InputStreamReader вы можете больше контролировать содержимое документа. ;)
Читайте также: