Гарантируется ли запись данных в файл при вызове flush java
С потоками ввода мы только что разобрались. Настало время поговорить о потоках вывода.
Класс OutputStream является классом-родителем для всех классов, которые поддерживают байтовый вывод. Это абстрактный класс, который сам ничего не делает: для этого у него есть классы-наследники на все случаи жизни.
Сложновато звучит. Если попроще, этот класс оперирует байтами, а не, например, символами или другими типами данных. А то, что он абстрактный, значит, что мы обычно используем не его, а один из его классов-наследников. Например, FileOutputStream и ему подобные.
Но вернемся к классу OutputStream . У этого класса есть методы, которые обязаны реализовывать все его классы-наследники. Вот основные из них:
Методы | Описание |
---|---|
Записывает один байт (не int ) в поток. | |
Записывает массив байт в поток | |
Записывает часть массива байт в поток | |
Записывает в поток все данные, которые хранятся в буфере | |
Закрывает поток |
При создании объекта класса-наследника InputStream обычно указывается объект-источник, из которого InputStream читает данные. При создании объекта класса-наследника OutputStream также обычно указывается целевой объект или целевой поток, в который будут записываться данные.
Вкратце пройдемся по всем методам класса OutputStream :
Метод write(int b)
Этот метод записывает в поток вывода один байт (не int ). Переданное значение приводится к типу байт, три первые байта отбрасываются.
Метод write(byte[] buffer)
Записывает в поток вывода переданный массив байтов. Все.
Метод write(byte[] buffer, int offset, int length)
Записывает в поток вывода часть переданного массива байтов. Переменная offset задает номер первого элемента массива, length — длина записываемого фрагмента.
Метод flush()
Метод flush() используется, чтобы принудительно записать в целевой поток данные, которые могут кэшироваться в текущем потоке. Актуально при использовании буферизации и/или нескольких объектах потоков, организованных в цепочку.
Метод close()
Записывает в целевой объект все незаписанные данные. Метод close() можно не вызывать, если вы используете try -with-resources.
Пример — копирование файла
InputStream для чтения из файла
OutputStream для записи в файл
Буфер, в который мы будем считывать данные
Пока данные есть в потоке
2. Класс Writer
Класс Writer — это полный аналог класса OutputStream , и снова только с одним отличием: он работает с символами, char , вместо байт.
Это абстрактный класс: объекты класса Writer создать нельзя. Его основная цель — быть единым классом-родителем для сотен классов-наследников и задать для них общие методы работы с символьными потоками.
Методы класса Writer (и всех его классов-наследников):
Методы | Описание |
---|---|
Записывает один символ (не int ) в поток. | |
Записывает массив символов в поток | |
Записывает часть массива символов в поток | |
Записывает строку в поток | |
Записывает часть строки в поток | |
Записывает в поток все данные, которые хранятся в буфере | |
Закрывает поток |
Методы очень похожи на методы класса OutputStream , только работают с символами вместо байт.
Краткое описание методов:
Метод write(int b)
Этот метод записывает в поток вывода один символ char (не int ). Переданное значение приводится к типу char , два первых байта отбрасываются.
Метод write(char[] buffer)
Записывает в поток вывода переданный массив символов.
Метод write(char[] buffer, int offset, int length)
Записывает в поток вывода часть переданного массива символов. Переменная offset задает номер первого элемента массива, length — длина записываемого фрагмента.
Метод write(String str)
Записывает в поток вывода переданную строку.
Метод write(String str, int offset, int length)
Записывает в поток вывода часть переданной строки: строку преобразуют в массив символов. Переменная offset задает номер первого элемента массива, length — длина записываемого фрагмента.
Метод flush()
Метод flush() используется, чтобы принудительно записать в целевой поток данные, которые могут кэшироваться в текущем потоке. Актуально при использовании буферизации и/или нескольких объектах потоков, организованных в цепочку.
Метод close()
Записывает в целевой объект все незаписанные данные. Метод close() можно не вызывать, если вы используете try -with-resources.
Пример программы, которая копирует текстовый файл:
Reader для чтения из файла
Writer для записи в файл
Буфер, в который будем считывать данные
Пока данные есть в потоке
Класс StringWriter
Есть еще один интересный класс-наследник от класса Writer — это StringWriter . В нем находится изменяемая строка — объект StringBuffer . И каждый раз, когда вы что-то «пишете» в объект StringWriter , текст просто добавляется во внутренний буфер.
В данном случае класс StringWriter — это, по сути, обертка над классом StringBuffer , однако класс StringWriter — это наследник класса-потока Writer , и он может использоваться в цепочках из объектов-потоков. Довольно полезное свойство на практике.
В Java flush() метод используется в потоках. Но я не понимаю, для чего вообще нужен этот метод?
подскажите несколько предложений.
Из документации о flush методе:
Очищает выходной поток и заставляет записывать все буферизованные выходные байты. Общий контракт сброса заключается в том, что его вызов указывает на то, что, если какие-либо ранее записанные байты были буферизованы реализацией выходного потока, такие байты должны быть немедленно записаны в их предполагаемое место назначения.
Буферизация в основном выполняется для повышения производительности ввода-вывода. Подробнее об этом можно прочитать в этой статье: Настройка производительности ввода-вывода Java .
+1 Спасибо. Я не мог понять, почему мои байты не были отправлены, и это потому, что мне пришлось очистить свои буферы.
Используется ли метод сброса только с буферизованными потоками? есть ли какие-либо преимущества от использования его с другими потоками (например, с выходным потоком)?
Может быть, слова «промывка» не должно быть в его определении. Рекурсивные определения - плохая идея для понимания новых вещей. Я знаю, что вы не писали определение.
Когда мы даем любую команду, потоки этой команды сохраняются в области памяти, называемой буфером (временная область памяти) на нашем компьютере. Когда вся временная область памяти заполнена, мы используем flush (), которая очищает все потоки данных и полностью их выполняет, а также дает новое пространство для новых потоков во временном расположении буфера. -Надеюсь, ты поймешь
Только в случае BufferedOutputStream , BufferedWriter , ObjectOutputStream, и PrintXXX классы. flush() Метод любого другого потока или Writer ничего не делает.
@ mr5 Это плакат, который должен подтвердить свои заявления, а не я, но все, что я сказал, четко изложено в Javadoc
flush() Явный вызов a не требуется BufferedWriter , если вы являетесь close() писателем. close() сам выполняет сброс.
Обратите внимание на close() вызовы flush() , поэтому оба вызова избыточны при использовании FileWriter без буфера.
Когда вы записываете данные в поток, они записываются не сразу, а буферизируются. Поэтому используйте, flush() когда вам нужно быть уверенным, что все ваши данные из буфера записаны.
Мы должны быть уверены, что все записи завершены, прежде чем мы закроем поток, и поэтому flush() вызывается в файловой / буферизованной записи close() .
Но если у вас есть требование, чтобы все ваши записи сохранялись в любое время перед закрытием потока, используйте flush() .
Вызов флеша непосредственно перед закрытием избыточен, верно? это то же самое, что просто позвонить близко.
@BimanTripathy Я могу сказать это со 100% уверенностью. Это гарантируется Javadoc от FilterOutputStream и FilterWriter .
Если буфер заполнен, все строки, которые буферизированы в нем, будут сохранены на диск. Буферы используются, чтобы избежать больших сделок! и накладные расходы.
В классе BufferedWriter, который помещается в java libs, есть одна строка вроде:
В Java у меня есть текст из текстового поля в строковой переменной с именем «текст».
Как я могу сохранить содержимое переменной «text» в файл?
Если вы просто выводите текст, а не какие-либо двоичные данные, сработает следующее:
Затем запишите свою строку, как и в любой выходной поток:
Вам понадобится обработка исключений, как всегда. Обязательно позвоните, out.close() когда закончите писать.
Если вы используете Java 7 или более позднюю версию, вы можете использовать « оператор try-with-resources », который автоматически закроет ваш файл, PrintStream когда вы закончите с ним (то есть выйдите из блока), примерно так:
Вам все равно нужно будет явно бросить, java.io.FileNotFoundException как и раньше.
@Justin, вы также можете передать абсолютный путь (например, «/tmp/filename.txt») в конструктор FileOutputStream, чтобы сохранить файл в любом месте
Кстати, это можно упростить, используя удобные конструкторы, которые PrintStream имеет с 1.5. Этого будет достаточно: PrintStream out = new PrintStream ("filename.txt");
Вы хотите использовать try <> catch () <> finally <>, где в finally <> вы закрываете файл, если он не равен нулю.
Apache Commons IO содержит несколько отличных методов для этого, в частности FileUtils содержит следующий метод:
который позволяет записывать текст в файл одним вызовом метода:
Вы также можете рассмотреть возможность указания кодировки для файла.
Просто небольшая поправка, второй фрагмент должен выглядеть следующим образом: FileUtils.writeStringToFile (new File ("test.txt"), "Hello File");
Теперь функция устарела, вы должны добавить кодировку по умолчанию -> FileUtils.writeStringToFile(new File("test.txt"), "Hello File", forName("UTF-8"));
@ XP1 Я знаю, это большое улучшение. Я использовал Lombok для этого в Java 6: просто иди @Cleanup new FileOutputStream(. ) и готово.
Большие файлы записываются в фоновом режиме (другой поток) и требуют времени для записи. Вызов flush () гарантирует, что все было записано на следующей строке, синхронизируя операцию. Но это необязательно , но хорошая практика, если вы обрабатываете большие файлы, такие как журналы.
Обратите внимание, что out.close () уже очищает поток, что означает, что нет необходимости вызывать out.flush ().
В Java 7 вы можете сделать это:
Обратите внимание, что StandardOpenOption.CREATE не является значением по умолчанию, а StandardOpenOption.CREATE и StandardOpenOption.TRUNCATE_EXISTING является значением по умолчанию. Чтобы использовать значение по умолчанию, просто удалите третий параметр.
Пожалуйста, смотрите комментарий Тинус Тейт! Как происходит редактирование этого примера? Интересно, сколько тысяч людей взяли этот пример «как есть» только для того, чтобы обнаружить, что они получают неожиданные результаты, когда перезаписывают файл более короткой строкой. Как указывает Tinus, TRUNCATE_EXISTING имеет решающее значение, если вы не полностью понимаете и не имеете реальной причины не желать обрезать существующий файл при перезаписи более короткой строкой.
Просто сделал что-то похожее в моем проекте. Использование FileWriter упростит часть вашей работы. И здесь вы можете найти хороший учебник .
Удаляя все try / catch и упрощая его, я также могу сделать это в одну строку, просто выполнив: (new BufferedWriter (new FileWriter (filename))). Write (str);
Проигнорируйте троллей . они всегда критикуют, не предлагая их собственного решения. Спасибо, что спасли меня от написания собственного кода / загрузки дополнительной библиотеки и введения зависимости .
Кажется, что .close() не выдает (по крайней мере, в Java 7?), Является ли последний trycatch возможно избыточным?
Проглатывание подобных исключений усложнит вам жизнь, когда действительно произойдут исключения. По крайней мере, вы должны отбросить их: throw new RuntimeException(e);
Используйте FileUtils.writeStringToFile() от Apache Commons IO . Не нужно изобретать это колесо.
Я не мог не согласиться больше. Эти библиотеки есть, поэтому мы не вносим тонких ошибок в такое простое решение.
Нет, очевидно нет. Я только не согласен с тем, что ваше решение, возможно, не первое, что я бросил бы на кого-то, кто является начинающим Java-программистом. Вы же не говорите, что никогда не писали ничего подобного?
У меня есть, да, но это до того, как я нашел обыкновенные. С тех пор, как я нашел это, я никогда не писал такого рода вещи вручную, даже в одноклассном проекте. Если бы я знал об этом с первого дня, я бы использовал это с первого дня.
Точно, но вы опытный разработчик. В вашей биографии говорится, что вы - пользователь JBOSS / Spring, но, конечно, вы не смогли бы участвовать ни в одном из своих первых попыток "Hello, World". Я не согласен с правильным использованием библиотек. Я говорю о том, что люди, пытающиеся использовать язык впервые, должны постараться узнать его в самом низу, даже если это означает делать то, что они откажутся позже, когда будут иметь опыт и будут лучше знать.
Я реализовал это без общего достояния и получил менее очевидное исключение. Затем я реализовал это с помощью общих ресурсов, и он сказал мне, что именно не так. Мораль истории: зачем жить в темные века, если не нужно?
Вы можете использовать модифицированный код ниже, чтобы написать свой файл из любого класса или функции, обрабатывающей текст. Интересно, почему миру нужен новый текстовый редактор .
В Java 11 java.nio.file.Files класс был продлен на два новых служебных методов , чтобы записать строку в файл. Первый метод (см. JavaDoc здесь ) использует кодировку UTF-8 по умолчанию:
И второй метод (см. JavaDoc здесь ) позволяет указать отдельную кодировку:
Оба метода имеют необязательный параметр Varargs для настройки параметров обработки файлов (см. JavaDoc здесь ). В следующем примере будет создан несуществующий файл или добавлена строка к существующему:
Я предпочитаю полагаться на библиотеки, когда это возможно, для такого рода операций. Это снижает вероятность того, что я случайно пропущу важный шаг (например, ошибку, сделанную выше). Некоторые библиотеки предложены выше, но мой фаворит для такого рода вещей - Google Guava . У Guava есть класс Files, который отлично подходит для этой задачи:
Используйте Apache Commons IO api. Это просто
Использовать API как
В случае, если вам нужно создать текстовый файл на основе одной строки:
Files.write (path, byte []) будет использовать кодировку UTF-8. String.getBytes () использует кодировку платформы по умолчанию. Так что это потенциальная проблема. Используйте string.getBytes (StandardCharsets.UTF_8)!
Используйте это, это очень читабельно:
Вы можете вставить этот метод в ваши классы. Если вы используете этот метод в классе с методом main, измените этот класс на статический, добавив ключевое слово static. В любом случае вам нужно будет импортировать java.io. *, чтобы он работал, иначе File, FileWriter и BufferedWriter не будут распознаны.
Вы могли бы сделать это:
Использование Java 7 :
Слово мудрому - это создаст новый файл, если его там нет, но перезапишет символы существующего файла, если он там есть. Если новые данные меньше, это будет означать, что вы, вероятно, создаете поврежденный файл. Спроси меня, откуда я знаю!
Просто используйте, Files.write(targetPath, bytes); чтобы перезаписать файл тогда. Это будет работать как ожидалось.
Если вам нужно только вставить один блок текста в файл, это будет перезаписывать его каждый раз.
Этот пример позволяет пользователю выбрать файл с помощью средства выбора файлов.
@Eric Leschinski: спасибо за то, что вы сделали мой ответ более профессиональным (я также предположил, что именно этого и хотел ОП, поскольку именно этого и хочет большинство людей, просто
После того, как первоначальный вопрос получен, а ОП удовлетворен и ушел в прошлое, подобные страницы служат лишь полезным артефактом для людей, которые попадают сюда из поиска Google. Я попал на эту страницу, чтобы создать мини-текстовый аппендер к файлу. Так что лучше говорить со всей аудиторией, а не с ОП после того, как ОП продолжится.
Лучше закрыть писатель / выходной поток в блоке finally, на случай, если что-то случится
close () никогда не может быть вызван. Пожалуйста, улучшите свой ответ, добавив правильную обработку ошибок.
Я думаю, что лучше всего использовать Files.write(Path path, Iterable lines, OpenOption. options) :
Записать строки текста в файл. Каждая строка представляет собой последовательность символов и записывается в файл последовательно, каждая строка завершается разделителем строк платформы, как определено системным свойством line.separator. Символы кодируются в байты с использованием указанной кодировки.
Параметр options указывает, как файл создается или открывается. Если параметры отсутствуют, этот метод работает так, как если бы присутствовали параметры CREATE, TRUNCATE_EXISTING и WRITE. Другими словами, он открывает файл для записи, создает файл, если он не существует, или изначально обрезает существующий обычный файл до размера 0. Метод гарантирует, что файл будет закрыт, когда все строки были записаны ( или ошибка ввода-вывода или другое исключение во время выполнения). Если возникает ошибка ввода-вывода, это может произойти после того, как файл был создан или усечен, или после того, как в файл были записаны некоторые байты.
Пожалуйста, обратите внимание. Я вижу, что люди уже ответили с помощью встроенного в Java Files.write , но что особенного в моем ответе, который, кажется, никто не упоминает, это перегруженная версия метода, который принимает Iterable CharSequence (т.е. String) вместо byte[] массива, поэтому text.getBytes() не требуется , который немного чище, я думаю.
у меня есть несколько вопросов в приведенном выше примере.
- когда использовать метод flush и почему мы ее используем?
- что делает метод close нести счет здесь?
- myObj2 = (John) ois.readObject(); . пожалуйста, исправьте меня, если я ошибаюсь, Я читаю объект file и сохраняю в другой объект и типизирую объект file.
- каковы альтернативы сериализации или сохранения данных в Java. Я не хочу, чтобы данные в файл байт поток.
когда использовать метод flush и почему мы ее используем?
он смывает все, что еще буферизовано OutputStream . Подробное описание доступно в JavaDoc.
что делает метод close нести счет здесь?
Я не уверен, что вы подразумеваете под 'нести результат, но close метод окончательно закрывает ресурсы (входной сигнал или выход), он выпускает например ручки файла. Ты всегда должен звонить. закрыть в finally блок для очистки всех ссылок, которые может иметь ОС.
myObj2 = (John) ois.readObject (); . пожалуйста, поправьте меня, если я ошибаюсь, я читаю объект file и сохраняю в другой объект и типизация объекта file.
каковы альтернативы сериализации или сохранения данных в Ява. Я не хочу, чтобы данные в файл как поток байтов.
у вас есть несколько вариантов. Для клиентского приложения вы можете использовать XML, JSON или облегченную базу данных, такую как SQLlite. На стороне сервера вы также можете взглянуть на более надежные базы данных (например, MySQL).
- когда использовать метод flush и почему мы ее используем?
это используется, когда должна быть синхронная отправка
- myObj2 = (John) ois.readObject(); пожалуйста, поправьте меня, если я ошибаюсь, Я читаю файл объект и хранение в другой объект и типизация объекта file.
неправильно! Вы читаете некоторые данные из потока typecast его в Джон (который будет бросать, если объект read не был Джоном)
- каковы альтернативы сериализации или сохранения данных в Java. Я не хочу, чтобы данные в файл как поток байтов.
вы можете написать его как текст (напишите поля как текст на строке) и предоставить метод для разбора его на объект
есть несколько вопросов в приведенном выше примере.
когда использовать метод flush и почему мы ее используем?
вам обычно не нужно flush() и OutputStream , он не потеряет никаких данных, если вы правильно close() его в конце концов. Иногда вы хотите связаться с базовым приемником данных (например, network Socket местные File или еще OutputStream ), что вы хотите, чтобы любые данные, записанные в поток, были сброшены / обработаны, но согласно the flush() API doc, это не гарантируется произойдет.
что делает метод close нести счет здесь?
я действительно не понимаю эту часть, но close() закрытие OutputStream и заставляет его записывать любые данные, которые он все еще буферизовал-поэтому нет необходимости вызывать flush() до close() . Ан OutputStream невозможно записать после того, как он был закрытый.
myObj2 = (John) ois.readObject(); . пожалуйста, исправьте меня, если я ошибаюсь, Я читаю объект file и сохраняю в другой объект и типизирую объект file.
неправильно, Вы читаете из ObjectInputStream ois , не имеет значения, откуда у него есть данные (в вашем случае это действительно происходит из файла, но в вашем коде нет "файлового объекта").
ObjectInputStream смогите реконструировать все данные ранее написанные / сериализованные by ObjectOutputStream -- так в этом случае вы де-сериализовать ранее сериализованный объект типа John . Поскольку сериализация работает только на некоторых типах Java (примитивы и реализаторы Serializable ), он не знает о твоем конкретном классе John . Но вы знаете, вы ранее serizalized в John объект, так что вы можете безопасно бросить из Object to John и назначьте его локальной переменной.
какие альтернативы Сериализация и сохранение данных в Java. Я не хочу, чтобы данные в файл как поток байтов.
вы можете изучить другие подходы сериализации/маршалинга, такие как кинокомпании xStream, JSON или сверните свой собственный (сложный, только сделайте это, если у вас есть веская причина). Большинство из них окажутся более сложными, чем встроенная сериализация, поэтому убедитесь, что у вас есть веская причина не просто написать "itno-файл как байтовый поток".
1) чтобы убедиться, что все возможные буферизованные байты записаны. Вижу Ява.Ио.Клиенту OutputStream.врезная().
2) не уверен, что вы имеете в виду, но вызовы close () должны быть помещены в блок finally, чтобы гарантировать, что ресурс закрыт. Быстрый Google показывает - статьи.
3) Вы не читаете объект file. Вы читаете ранее сериализованный объект Java из файла. Надеюсь, этот объект будет типа John, иначе вы получите Исключение ClassCastException. Это будет тип John, как вы ранее называли " oos.writeObject (myObj)", где myObj имеет тип John.
4) Google для сериализации Java-объектов. Существует множество библиотек для сериализации объектов Java в двоичные файлы, xml, json и т. д. Сам JDK поставляется с одним под названием XMLEncoder.
- вы используете flush () чтобы очистить внутренние буферы(если они есть) и принудительно записать (т. е. очистить) все ожидающие данные в назначение потока.
- закрыть() метод используется для закрытия потока, после вызова вы больше не можете использовать поток.
- нет. Вы читаете "объект John из файла". Объект типа John должен был быть предварительно сериализован в файл.
- есть многие альтернативы сериализации Java, такие как кинокомпании xStream. См. этот ответ так для Альтернативы для сериализации.
функция Flush заключается в том, чтобы явно попросить Java-программу записать что-то на диск, что означает выполнение ввода-вывода. Скажем, если мы используем bufferedOutputStream, когда мы пишем ("что-то"), он сохраняется в буфере, но еще не на диске. Когда вы вызываете flush, он будет записывать материалы в буфер на диск. Обычно вам не нужно вызывать флеш самостоятельно, потому что для этого требуется IO и снизить скорость. Поток будет автоматически промыть, когда буфер заполнен. Если вы не хотите, содержимое обновляется на диск, вы можете использовать flush.
извините, не понял ваш вопрос? какой счет?
это то, что делает сериализация, она позволяет хранить некоторый объект в вашей файловой системе и возвращать его. Вы читаете поток байтов и преобразуете его обратно в объект.
есть много способов (xml, база данных, txt-файл), напишите свой собственный формат для хранения данных в локальном файле или в базе данных. Позвольте мне привести ваш пример, Джон. Он имеет имя и атрибуты отдела. Вы можете написать вывод формата, который принимает экземпляр John, и сделать следующее.
клиенту OutputStream.написать ("класс John\n"); клиенту OutputStream.write ("toString:"+instance+ " \n"); клиенту OutputStream.close();
затем он сохранит как локальный txt-файл, который вы можете открыть и прочитать.
мне нужно написать (добавить) огромную строку в плоский файл с помощью java nio. Кодировка ISO-8859-1.
В настоящее время мы пишем, как показано ниже. Есть ли лучше способ сделать то же самое ?
EDIT: пробовал оба варианта. Ниже приведены результаты.
использование ByteBuffer и канала: взял 4402 ms
использование буферизованного писателя: взял 563 ms
Я не думаю, что вы сможете получить строгий ответ без сравнительного анализа программного обеспечения. NIO может значительно ускорить работу приложения при правильных условиях, но также может замедлить работу. Вот некоторые моменты:
- вам действительно нужны строки? Если вы храните и получаете байты из базы данных, вы можете избежать затрат на распределение строк и кодирование.
- вам действительно нужно rewind и flip ? Похоже, вы создаете новый буфер для каждой строки и просто запись ее в канал. (Если вы идете по пути NIO, эталонные стратегии, которые повторно используют буферы вместо упаковки / отбрасывания, я думаю, что они будут лучше).
- имейте в виду, что wrap и allocateDirect может производить совершенно разные буферы. Тест Как понять компромиссы. При прямом распределении обязательно используйте один и тот же буфер для достижения наилучшей производительности.
- и самое главное is: обязательно сравните NIO с BufferedOutputStream и/или BufferedWritter подходы (используйте промежуточное byte[] или char[] буфер с разумным размером также). Я видел много, много, много люди обнаруживают, что НИО не серебряная пуля.
и вот интересный тест о копировании файлов с использованием различных стратегий. Я знаю, что это другая проблема, но я думаю, что большинство фактов и выводов автора также применяются к вашей проблеме.
обновление:
так как @EJP подсказал мне, что прямые буферы не будут эффективны для этой проблемы, я сам проверил его и закончил с хорошим решением NIO, используя файлы, сопоставленные с nemory. В моем Macbook работает OS X Lion это бьет BufferedOutputStream с солидным отрывом. но имейте в виду, что это может быть OS / Hardware / VM specific:
Я признаю, что я немного обманул, рассчитав общий размер для добавления (около 26 Мб) заранее. Это может оказаться невозможным для нескольких реальных сценариев. Тем не менее, вы всегда можете использовать "достаточно большой размер добавления для операций, а затем усечь файл.
есть строка решение, используя Java nio:
Я не сравнивал это решение с другими, но использование встроенной реализации для файла open-write-close должно быть быстрым, а код довольно небольшим.
BufferedWriter вокруг FileWriter почти наверняка будет быстрее, чем любая схема NIO, которую вы можете придумать. Ваш код, конечно, не является оптимальным, с новым ByteBuffer на запись, а затем делает бессмысленные операции над ним, когда он собирается выйти за рамки, но в любом случае ваш вопрос основан на неправильном представлении. NIO вообще не "разгружает объем памяти в ОС", если вы не используете FileChannel.transferTo/From(), который вы не можете в этом случае.
NB не используйте PrintWriter, как предложено в комментариях, так как это поглощает исключения. PW действительно только для консолей и файлов журналов, где вам все равно.
вот короткий и простой способ. Он создает файл и записывает данные относительно вашего проекта Код:
Читайте также:
- Oracle создание файла паролей
- Какое количество android устройств можно защитить при оформлении подписки на dr web премиум
- Ga m56s s3 греется чипсет
- Если части субд располагаются на разных компьютерах то такую субд называют
- Ао еэтп огрн 1097746299353 выпустила на вас электронную подпись что это значит