{"id":8804,"date":"2019-12-04T09:00:00","date_gmt":"2019-12-04T08:00:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=8804"},"modified":"2024-11-29T15:47:33","modified_gmt":"2024-11-29T14:47:33","slug":"dateien-schnell-einfach-schreiben","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/dateien-schnell-einfach-schreiben\/","title":{"rendered":"Dateien schnell und einfach schreiben (Java Datei Tutorial)"},"content":{"rendered":"\n<p>Nachdem es im ersten Teil der Serie um das <a href=\"\/de\/java\/dateien-einfach-schnell-lesen\/\">Lesen von Dateien in Java<\/a> ging, stelle ich dir in diesem zweiten Teil die korrespondierenden Methoden zum Schreiben von kleinen und gro\u00dfen Dateien vor. <\/p>\n\n\n\n<p>Im einzelnen geht es um folgende Fragen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Wie schreibt man am einfachsten einen String (oder eine Liste von Strings) in eine Textdatei?<\/li>\n\n\n\n<li>Wie schreibt man ein Byte-Array in eine Bin\u00e4rdatei?<\/li>\n\n\n\n<li>Wie schreibt man beim Verarbeiten von gro\u00dfen Datenmengen diese direkt in Dateien (ohne zun\u00e4chst den kompletten Inhalt der Datei im Speicher aufbauen zu m\u00fcssen)?<\/li>\n\n\n\n<li>Wann verwendet man&nbsp;<code>FileWriter<\/code>,&nbsp;<code>FileOutputStream<\/code>,&nbsp;<code>OutputStreamReader<\/code>,&nbsp;<code>BufferedOutputStream<\/code>&nbsp;und&nbsp;<code>BufferedWriter<\/code>?<\/li>\n\n\n\n<li>Wann verwendet man&nbsp;<code>Files.newOutputStream()<\/code>&nbsp;und&nbsp;<code>Files.newBufferedWriter()<\/code>? <\/li>\n<\/ul>\n\n\n\n<p>Bereits im ersten Teil angesprochen habe ich das Thema Betriebssystem-Unabh\u00e4ngigkeit, d. h. <a href=\"\/de\/java\/dateien-einfach-schnell-lesen\/#Betriebssystem-Unabhaengigkeit\">was bei Zeichenkodierungen, Zeilenumbr\u00fcche und Pfadnamen zu beachten ist<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-schreibt-man-in-java-am-einfachsten-in-eine-datei\">Wie schreibt man in Java am einfachsten in eine Datei?<\/h2>\n\n\n\n<p>Bis einschlie\u00dflich Java 6 gab es keine einfache M\u00f6glichkeit Dateien zu schreiben. Man musste einen <code>FileOutputStream<\/code> oder einen <code>FileWriter<\/code> \u00f6ffnen, diesen ggf. noch mit einem <code>BufferedOutputStream<\/code> oder <code>BufferedWriter<\/code> wrappen, in diesen schreiben, und anschlie\u00dfend - auch im Fehlerfall - alle Streams wieder schlie\u00dfen.<\/p>\n\n\n\n<p>In Java 7 kam mit der \"NIO.2 File API\" (NIO steht f\u00fcr New I\/O) die Utility-Klasse <code>java.nio.file.Files<\/code> hinzu. Diese  enth\u00e4lt  Methoden, mit denen ein Byte-Array, ein String oder eine Liste von Strings mit einem einzigen Kommando in eine Datei geschrieben werden kann.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-eines-byte-arrays-in-eine-binaerdatei\">Schreiben eines Byte-Arrays in eine Bin\u00e4rdatei<\/h3>\n\n\n\n<p>Ein Byte-Array l\u00e4sst sich mit folgendem Kommando in eine Datei schreiben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">byte<\/span>&#091;] bytes = ...;\nFiles.write(Path.of(fileName), bytes);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Methode erwartet an erster Stelle ein <code>Path<\/code>-Objekt. Dieses beschreibt einen Datei- oder Verzeichnisnamen und bietet Hilfsmethoden zur Konstruktion solcher. Im Beispiel wird die statische \u2013 seit <a href=\"\/de\/java\/java-11-features\/#Pathof\">Java 11<\/a> verf\u00fcgbare \u2013 Methode <code>Path.of()<\/code> verwendet, um ein <code>Path<\/code>-Objekt aus einem Dateinamen zu erstellen. Vor Java 11 kannst du stattdessen <code>Paths.get()<\/code> verwenden. Intern rufen beide Methoden <code>FileSystems.getDefault().getPath()<\/code> auf.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-eines-strings-in-eine-textdatei\">Schreiben eines Strings in eine Textdatei<\/h3>\n\n\n\n<p>Ebenso einfach l\u00e4sst sich \u2013 allerdings erst seit Java 11 \u2013 ein String in eine Datei schreiben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\nString text = ...;\nFiles.writeString(Path.of(fileName), text);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-einer-liste-von-strings-in-eine-textdatei\">Schreiben einer Liste von Strings in eine Textdatei<\/h3>\n\n\n\n<p>Oft schreibt man nicht einen einzelnen String in eine Textdatei, sondern mehrere in Form von Zeilen. Mit folgendem Kommando schreibst du eine String-Liste (bzw. genauer gesagt ein <code>Iterable&lt;? extends CharSequence&gt;<\/code> in eine Textdatei:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\nList&lt;String&gt; lines = ...;\nFiles.write(Path.of(fileName), lines);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-von-einem-string-stream-in-eine-textdatei\">Schreiben von einem String-Stream in eine Textdatei<\/h3>\n\n\n\n<p>Es gibt keine 1:1-Entsprechung der Stream-erzeugenden Methode <code>Files.lines()<\/code>, also keine Methode, die direkt aus einem String-Stream in eine Datei schreibt. Mit einem kleinen Workaround ist es dennoch m\u00f6glich:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\nStream&lt;String&gt; lines = ...;\nFiles.write(Path.of(fileName), (Iterable&lt;String&gt;) lines::iterator);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Was wird hier gemacht? Die <code>Files.write()<\/code>-Methode, die hier verwendet wird, ist dieselbe wie im vorherigen Beispiel, also die, die eine <code>Iterable&lt;String&gt;<\/code> entgegennimmt. Ein Java 8-Stream selbst ist kein <code>Iterable<\/code>, da man \u00fcber diesen nicht mehrfach iterieren kann, sondern nur ein einziges Mal. Daher kann man den Stream selbst nicht als Parameter \u00fcbergeben.<\/p>\n\n\n\n<p><code>Iterable<\/code> ist allerdings ein funktionales Interface, dessen einzige Methode <code>iterator()<\/code> einen <code>Iterator<\/code> zur\u00fcckliefert. Daher k\u00f6nnen wir hier als <code>Iterable<\/code> eine Methodenreferenz auf <code>lines.iterator()<\/code> \u00fcbergeben (welche ja auch einen <code>Iterator<\/code> zur\u00fcckliefert). Dies funktioniert, da wir annehmen k\u00f6nnen, dass <code>Files.write()<\/code> die referenzierte <code>iterator()<\/code>-Methode nur ein einziges Mal aufruft. W\u00fcrde die <code>iterator()<\/code>-Methode ein zweites mal aufgerufen werden, w\u00fcrde der Stream das mit einer <code>IllegalStateException<\/code> mit der Nachricht \"stream has already been operated upon or closed\" quittieren.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"dateien-schreiben-mit-java-nio-file-files-zusammenfassung\">Dateien schreiben mit java.nio.file.Files \u2013 Zusammenfassung<\/h3>\n\n\n\n<p>Im diesem Kapitel hast du die Utility-Methoden der <code>java.nio.file.Files<\/code>-Klasse kennengelernt. Diese sind geeignet f\u00fcr all diejenigen Use Cases, bei denen die zu schreibenden Daten komplett im Arbeitsspeicher liegen. <\/p>\n\n\n\n<p>Werden die Daten jedoch nach und nach generiert, solltest du diese auch nach und nach in eine Datei schreiben. Du solltest sie nicht erst im Arbeitsspeicher \"sammeln\" und anschlie\u00dfend mit einer der zuvor gezeigten Methoden in einem Rutsch in eine Datei schreiben. Es sei denn, die Menge der Daten ist nur wenige Kilobyte, dann ist das auch in Ordnung.<\/p>\n\n\n\n<p>Besser arbeitest du in einem solchen Fall aber (direkt oder indirekt) mit einem <code>FileOutputStream<\/code>. Wie das funktioniert, erf\u00e4hrst du im folgenden Kapitel.<\/p>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"1427197203\" src=\"https:\/\/happycoders.kit.com\/1427197203\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-schreibt-man-anfallende-daten-in-eine-datei-ohne-deren-inhalt-erst-komplett-im-arbeitsspeicher-aufbauen-zu-muessen\">Wie schreibt man anfallende Daten in eine Datei, ohne deren Inhalt erst komplett im Arbeitsspeicher aufbauen zu m\u00fcssen?<\/h2>\n\n\n\n<p>Um Daten nach und nach in eine Datei zu schreiben, verwendet man einen <code>FileOutputStream<\/code> (oder damit verwandte Klassen). Diese waren bereits vor Java 7 verf\u00fcgbar und haben das Schreiben von kleinen Dateien unn\u00f6tig kompliziert gemacht. Im folgenden stelle ich die verschiedenen M\u00f6glichkeiten vor.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-einzelner-bytes-mit-dem-fileoutputstream\">Schreiben einzelner Bytes mit dem FileOutputStream<\/h3>\n\n\n\n<p>Die zentrale Klasse ist der <code>FileOutputStream<\/code>, dieser schreibt Daten Byte f\u00fcr Byte in eine Datei. Das folgende Beispiel zeigt, wie Bytes, die von der imagin\u00e4ren Methode <code>process()<\/code> zur\u00fcckgeliefert werden, nach und nach in eine Datei geschrieben werden (solange bis die Methode -1 zur\u00fcckliefert):<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileOutputStream out = <span class=\"hljs-keyword\">new<\/span> FileOutputStream(fileName)) {\n  <span class=\"hljs-keyword\">int<\/span> b;\n  <span class=\"hljs-keyword\">while<\/span> ((b = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    out.write(b);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Das Schreiben einzelner Bytes ist eine teure Funktionalit\u00e4t. Das Schreiben von 100.000.000 Bytes in eine Testdatei dauert auf diese Weise auf meinem System etwa 230 Sekunden, das sind nur wenig mehr als 0,4 MB pro Sekunde.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-von-byte-arrays-mit-dem-fileoutputstream\">Schreiben von Byte-Arrays mit dem FileOutputStream<\/h3>\n\n\n\n<p>Mit dem <code>FileOutputStream<\/code> k\u00f6nnen auch Byte-Arrays geschrieben werden. In folgendem Beispiel liefert die Methode <code>process()<\/code> Byte-Arrays anstatt einzelner Bytes zur\u00fcck (und <code>null<\/code>, wenn keine weiteren Daten folgen):<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileOutputStream out = <span class=\"hljs-keyword\">new<\/span> FileOutputStream(fileName)) {\n  <span class=\"hljs-keyword\">byte<\/span>&#091;] bytes;\n  <span class=\"hljs-keyword\">while<\/span> ((bytes = process()) != <span class=\"hljs-keyword\">null<\/span>) {\n    out.write(bytes);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Diese Methode ist um ein Vielfaches schneller. Schreibt man 10.000.000 mal 10 Bytes (insgesamt die gleiche Menge), ben\u00f6tigt man daf\u00fcr lediglich 24 Sekunden, also etwas mehr als ein Zehntel der vorherigen Zeit. Schreibt man 1.000.000 mal 100 Bytes, sind es nur noch 2,6 Sekunden, was wiederum etwas mehr als ein Hundertstel der vorherigen Zeit ist.<\/p>\n\n\n\n<p>Relevant ist hier in erster Linie die Anzahl der Schreibvorg\u00e4nge, nicht die tats\u00e4chliche Menge der Daten. Dies liegt daran, dass die Daten blockweise auf den Datentr\u00e4ger geschrieben werden. Dies gilt nat\u00fcrlich nur bis zu einer gewissen Puffergr\u00f6\u00dfe. Ein mal zehn Gigabyte zu schreiben ist nicht mehr schneller als zehn mal ein Gigabyte zu schreiben. Der optimale Wert f\u00fcr die Puffergr\u00f6\u00dfe h\u00e4ngt von der Hardware als auch der Formatierung des Datentr\u00e4gers ab. Ich habe mit einem kleinen Testprogramm die Schreibgeschwindigkeit in Abh\u00e4ngigkeit von der Puffergr\u00f6\u00dfe gemessen:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-large\"><img decoding=\"async\" width=\"777\" height=\"479\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size.png\" alt=\"FileOutputStream \u2013 Schreibgeschwindigkeit in Abh\u00e4ngigkeit von der Puffergr\u00f6\u00dfe\" class=\"wp-image-8988\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size.png 777w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-224x138.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-336x207.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-504x311.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-672x414.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-400x247.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/FileOutputStream-write-speed-vs-buffer-size-600x370.png 600w\" sizes=\"(max-width: 777px) 100vw, 777px\" \/><figcaption class=\"wp-element-caption\">FileOutputStream \u2013 Schreibgeschwindigkeit in Abh\u00e4ngigkeit von der Puffergr\u00f6\u00dfe<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Auf meinem System betr\u00e4gt die optimale Puffergr\u00f6\u00dfe 8 KB. Hierbei werden etwa 1.050 MB pro Sekunde erreicht. 8 KB ist auch auf den meisten anderen System die optimale Gr\u00f6\u00dfe, weshalb Java diesen Wert als Standard nimmt, wie wir im \u00fcbern\u00e4chsten Abschnitt sehen werden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-von-binaerdaten-mit-dem-nio-2-outputstream\">Schreiben von Bin\u00e4rdaten mit dem NIO.2 OutputStream<\/h3>\n\n\n\n<p>In Java 7 kam mit <code>Files.newOutputStream()<\/code> eine weitere Methode hinzu, um einen <code>OutputStream<\/code> zu erzeugen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (OutputStream out = Files.newOutputStream(Path.of(fileName))) {\n  <span class=\"hljs-keyword\">int<\/span> b;\n  <span class=\"hljs-keyword\">while<\/span> ((b = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    out.write(b);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Diese Methode liefert einen <code>ChannelOutputStream<\/code> anstatt eines <code>FileOutputStreams<\/code>. Von der Geschwindkeit gibt es sowohl beim Schreiben einzelner Bytes als auch beim Schreiben von Byte-Bl\u00f6cken auf meinem System keinen relevanten Unterschied gegen\u00fcber <code>new FileOutputStream()<\/code>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schneller-schreiben-mit-dem-bufferedoutputstream\">Schneller schreiben mit dem BufferedOutputStream<\/h3>\n\n\n\n<p>Wir haben zuvor festgestellt, dass das Schreiben von Bl\u00f6cken schneller ist als das Schreiben einzelner Bytes. Diese Tatsache macht sich der <code>BufferedOutputStream<\/code> zunutze, in dem er die zu schreibenden Bytes zun\u00e4chst in einem Puffer zwischenspeichert und diesen erst beim Erreichen einer bestimmten Gr\u00f6\u00dfe auf den Datentr\u00e4ger schreibt. Dieser Puffer ist standardm\u00e4\u00dfig 8 KB gro\u00df, also genau die Gr\u00f6\u00dfe, die zu einer optimalen Schreibgeschwindigkeit f\u00fchrt.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileOutputStream out = <span class=\"hljs-keyword\">new<\/span> FileOutputStream(fileName);\n     BufferedOutputStream bout = <span class=\"hljs-keyword\">new<\/span> BufferedOutputStream(out)) {\n  <span class=\"hljs-keyword\">int<\/span> b;\n  <span class=\"hljs-keyword\">while<\/span> ((b = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    bout.write(b);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Mit dem <code>BufferedOutputStream<\/code> ben\u00f6tigt mein System f\u00fcr das Schreiben von 100.000.000 einzelnen Bytes knapp 250 ms. Das sind etwa 400 MB pro Sekunde. Die 1.050 MB\/s aus dem vorherigen Test werden hier aufgrund des Overheads durch das Zwischenspeichern nicht erreicht.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"byte-arrays-schreiben-mit-dem-bufferedoutputstream\">Byte-Arrays schreiben mit dem BufferedOutputStream<\/h3>\n\n\n\n<p>Ebenso wie der <code>FileOutputStream<\/code> kann auch der <code>BufferedOutputStream<\/code> nicht nur einzelne Bytes, sondern auch Byte-Bl\u00f6cke schreiben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileOutputStream out = <span class=\"hljs-keyword\">new<\/span> FileOutputStream(fileName);\n     BufferedOutputStream bout = <span class=\"hljs-keyword\">new<\/span> BufferedOutputStream(out)) {\n  <span class=\"hljs-keyword\">byte<\/span>&#091;] bytes;\n  <span class=\"hljs-keyword\">while<\/span> ((bytes = process()) != <span class=\"hljs-keyword\">null<\/span>) {\n    bout.write(bytes);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Diese Methode vereint die Vorteile des Schreibens von Byte-Arrays mit der eines Puffers und liefert quasi immer optimale Schreibgeschwindigkeiten. Beim Schreiben von Bin\u00e4rdaten empfehle ich immer diese Methode zu verwenden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"schreiben-von-textdateien-mit-dem-filewriter\">Schreiben von Textdateien mit dem FileWriter<\/h3>\n\n\n\n<p>Um Texte in eine Datei zu schreiben, m\u00fcssen diese in Bin\u00e4rdaten umgewandelt werden. Das \u00fcbernimmt der <code>OutputStreamWriter<\/code>, den du wie folgt um den <code>FileOutputStream<\/code> legst. Die <code>process()<\/code>-Methode produziert in folgendem Beispiel einzelne Characters.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileOutputStream out = <span class=\"hljs-keyword\">new<\/span> FileOutputStream(fileName);\n     OutputStreamWriter writer = <span class=\"hljs-keyword\">new<\/span> OutputStreamWriter(out)) {\n  <span class=\"hljs-keyword\">int<\/span> c;\n  <span class=\"hljs-keyword\">while<\/span> ((c = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    writer.write(c);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Komfortabler geht es mit dem <code>FileWriter<\/code>. Dieser kombiniert <code>FileOutputStream<\/code> und <code>OutputStreamWriter<\/code>. Der folgende Code ist \u00e4quivalent zu dem vorherigen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-12\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileWriter writer = <span class=\"hljs-keyword\">new<\/span> FileWriter(fileName)) {\n  <span class=\"hljs-keyword\">int<\/span> c;\n  <span class=\"hljs-keyword\">while<\/span> ((c = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    writer.write(c);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-12\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Der <code>OutputStreamWriter<\/code> verwendet intern auch einen 8 KB gro\u00dfen Puffer, so dass das Schreiben von 100.000.000 Zeichen in eine Textdatei etwa 2,5 Sekunden dauert.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"textdateien-schneller-schreiben-mit-dem-bufferedwriter\">Textdateien schneller schreiben mit dem BufferedWriter<\/h3>\n\n\n\n<p>Weiter beschleunigen kannst du das Schreiben mit dem <code>BufferedWriter<\/code>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-13\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (FileWriter writer = <span class=\"hljs-keyword\">new<\/span> FileWriter(fileName);\n     BufferedWriter bufferedWriter = <span class=\"hljs-keyword\">new<\/span> BufferedWriter(writer)) {\n  <span class=\"hljs-keyword\">int<\/span> c;\n  <span class=\"hljs-keyword\">while<\/span> ((c = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    bufferedWriter.write(c);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-13\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Der <code>BufferedWriter<\/code> f\u00fchrt einen weiteren 8 KB-Puffer f\u00fcr Zeichen hinzu, welche dann in einem Rutsch kodiert werden, sobald der Puffer geschrieben wird (anstatt Zeichen f\u00fcr Zeichen). Damit reduziert sich die Zeit f\u00fcr das Schreiben von 100.000.000 Zeichen auf ca. 370 ms.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"textdateien-schneller-schreiben-mit-dem-nio-2-bufferedwriter\">Textdateien schneller schreiben mit dem NIO.2 BufferedWriter<\/h3>\n\n\n\n<p> In Java 7 kam mit <code>Files.newBufferedWriter()<\/code> eine neue Methode hinzu, um einen <code>BufferedWriter<\/code> zu erzeugen: <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-14\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String fileName = ...;\n<span class=\"hljs-keyword\">try<\/span> (BufferedWriter bufferedWriter = Files.newBufferedWriter(Path.of(fileName))) {\n  <span class=\"hljs-keyword\">int<\/span> c;\n  <span class=\"hljs-keyword\">while<\/span> ((c = process()) != -<span class=\"hljs-number\">1<\/span>) {\n    bufferedWriter.write(c);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-14\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Schreibgeschwindigkeit entspricht auf meinem System der des \"klassisch\" erstellten <code>BufferedWriters<\/code>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"uebersicht-performance-dateien-schreiben\">\u00dcbersicht Performance Dateien schreiben<\/h3>\n\n\n\n<p>Im folgenden Diagramm siehst du noch einmal zusammengefasst, wie lange die vorgestellten Methoden ben\u00f6tigen, um 100.000.000 Bytes bzw. Zeichen in eine Bin\u00e4r- bzw. Textdatei zu schreiben:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-large\"><img decoding=\"async\" width=\"658\" height=\"599\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2.png\" alt=\" Vergleich der Zeiten zum Schreiben von 100 Millionen Bytes \/ Zeichen in eine Datei\" class=\"wp-image-8885\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2.png 658w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2-224x204.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2-336x306.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2-504x459.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2-400x364.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-v2-600x546.png 600w\" sizes=\"(max-width: 658px) 100vw, 658px\" \/><figcaption class=\"wp-element-caption\">Vergleich der Zeiten zum Schreiben von 100 Millionen Bytes \/ Zeichen in eine Datei<\/figcaption><\/figure>\n<\/div>\n\n\n<p>Aufgrund des gro\u00dfen Abstands von ungepuffertem zu gepuffertem Schreiben heben sich die gepufferten Methoden hier kaum ab. Das folgende Diagram zeigt daher als Ausschnitt nur die Methoden, die einen Puffer verwenden:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-large\"><img decoding=\"async\" width=\"602\" height=\"501\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered.png\" alt=\"Vergleich der Zeiten zum Schreiben von 100 Millionen Bytes \/ Zeichen in eine Datei (buffered)\" class=\"wp-image-8887\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered.png 602w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered-224x186.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered-336x280.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered-504x419.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered-400x333.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Writing-files-in-Java-performance-comparison-buffered-600x499.png 600w\" sizes=\"(max-width: 602px) 100vw, 602px\" \/><figcaption class=\"wp-element-caption\">Vergleich der Zeiten zum Schreiben von 100 Millionen Bytes \/ Zeichen in eine Datei (buffered)<\/figcaption><\/figure>\n<\/div>\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"uebersicht-fileoutputstream-filewriter-outputstreamwriter-bufferedoutputstream-bufferedwriter\">\u00dcbersicht FileOutputStream, FileWriter, OutputStreamWriter, BufferedOutputStream, BufferedWriter<\/h3>\n\n\n\n<p>Das folgende Diagramm zeigt noch einmal zusammengefasst den Zusammenhang der vorgestellten Klassen zum Schreiben von Bin\u00e4r- und Textdateien aus dem <code>java.io<\/code>-Paket:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-full is-resized\"><img decoding=\"async\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/Java-FileOutputStream-FileWriter-OutputStreamWriter-BufferedOutputStream-BufferedWriter-de.svg\" alt=\"Diagramm mit Java-Klassen zum Schreiben in Dateien\" class=\"wp-image-8907\" style=\"width:720px;height:444px\"\/><\/figure>\n<\/div>\n\n\n<p>Durchgezogene Linien stehen f\u00fcr Bin\u00e4rdaten, gestrichtelte f\u00fcr Textdaten. <code>FileWriter<\/code> kombiniert <code>FileOutputStream<\/code> und <code>OutputStreamWriter<\/code>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zeichenkodierungen\">Zeichenkodierungen<\/h2>\n\n\n\n<p>Das Thema Zeichenkodierung und die Probleme, die damit einhergehen, wurden <a href=\"\/de\/java\/dateien-einfach-schnell-lesen\/#Zeichenkodierung\">im vorherigen Artikel<\/a> ausf\u00fchrlich besprochen.<\/p>\n\n\n\n<p>Im Folgenden beschr\u00e4nke ich mich daher auf diejenigen Aspekte, die f\u00fcr das Schreiben von Textdateien mit Java relevant sind.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"welche-zeichenkodierung-verwendet-java-standardmaessig-zum-schreiben-von-textdateien\">Welche Zeichenkodierung verwendet Java standardm\u00e4\u00dfig zum Schreiben von Textdateien?<\/h3>\n\n\n\n<p>Gibt man beim Schreiben einer Textdatei keine Zeichenkodierung an, verwendet Java eine Standard-Codierung. Doch aufgepasst: Welche das ist, h\u00e4ngt zum einen von der verwendeten Methode ab, zum anderen von der eingesetzten Java-Version.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die Klassen <code>FileWriter<\/code> und <code>OutputStreamWriter<\/code> verwenden intern <code>StreamEncoder.forOutputStreamWriter()<\/code>. Wird diese Methode ohne Zeichenkodierung aufgerufen, verwendet sie <code>Charset.defaultCharset()<\/code>. Diese Methode wiederum liest die Zeichenkodierung aus der System-Property \"file.encoding\". Ist diese nicht angegeben, wird bis Java 5 standardm\u00e4\u00dfig ISO-8859-1 verwendet und seit Java 6 UTF-8.<\/li>\n\n\n\n<li>Die Methoden <code>Files.writeString()<\/code>, <code>Files.write()<\/code> und <code>Files.newBufferedWriter()<\/code> verwenden alle grunds\u00e4tzlich UTF-8 als Standardkodierung, ohne die o. g. System Property zu lesen.<\/li>\n<\/ul>\n\n\n\n<p>Aufgrund dieser Inkonsistenzen sollte man immer die Zeichenkodierung mit angeben. Ich empfehle grunds\u00e4tzlich UTF-8 zu verwenden. Diese Kodierung wird laut <a rel=\"noopener\" href=\"https:\/\/de.wikipedia.org\/wiki\/UTF-8\" target=\"_blank\">Wikipedia<\/a> auf 94,3 % aller Webseiten verwendet und kann von daher als De-facto-Standard angesehen werden. Eine Ausnahme besteht nat\u00fcrlich, wenn mit alten Dateien gearbeitet werden muss, die in einer anderen Kodierung geschrieben wurden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-gibt-man-die-zeichenkodierung-beim-schreiben-einer-textdatei-an\">Wie gibt man die Zeichenkodierung beim Schreiben einer Textdatei an?<\/h3>\n\n\n\n<p>Im Folgenden findest du f\u00fcr alle bisher besprochenen Methoden ein Beispiel mit Angabe von UTF-8 als Zeichenkodierung:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>Files.<em>writeString<\/em>(path, string, StandardCharsets.<strong><em>UTF_8<\/em><\/strong>)<\/code><\/li>\n\n\n\n<li><code>Files.<em>write<\/em>(path, lines, StandardCharsets.<strong><em>UTF_8<\/em><\/strong>)<\/code><\/li>\n\n\n\n<li><code><strong>new&nbsp;<\/strong>FileWriter(file, StandardCharsets.<strong><em>UTF_8<\/em><\/strong>)<\/code>&nbsp;\/\/ diese Methode gibt es erst seit Java 11<\/li>\n\n\n\n<li><code><strong>new&nbsp;<\/strong>InputStreamWriter(outputStream, StandardCharsets.<strong><em>UTF_8<\/em><\/strong>)<\/code><\/li>\n\n\n\n<li><code>Files.<em>newBufferedWriter<\/em>(path, StandardCharsets.<strong><em>UTF_8<\/em><\/strong>)<\/code><\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zusammenfassung-und-ausblick\">Zusammenfassung und Ausblick<\/h2>\n\n\n\n<p>Dieser Artikel hat verschiedene Methoden gezeigt, wie du in Java Byte-Arrays und Strings in Bin\u00e4r- und Textdateien schreiben kannst.<\/p>\n\n\n\n<p>Im dritten Teil der Serie lernst du, <a href=\"\/de\/java\/dateinamen-verzeichnisnamen-file-path-paths\/\">wie man die Klassen <code>File<\/code>, <code>Path<\/code> und <code>Paths<\/code> nutzt, um Datei- und Verzeichnispfade zu konstruieren<\/a>.<\/p>\n\n\n\n<p>In weiteren Artikeln dieser Serie werde ich zeigen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Verzeichnisoperationen\"><span style=\"font-size: 1rem;\">Wie liest man den Inhalt eines Verzeichnisse ein?<\/span><\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Wie_verschiebt_man_eine_Datei_in_Java\">Wie kopiert, verschiebt und l\u00f6scht man Dateien, und wie setzt man Links?<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Eine_temporaere_Datei_erstellen\">Wie erstellt man tempor\u00e4re Dateien?<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/strukturierte-daten-schreiben-lesen-dataoutputstream-datainputstream\/\">Wie verwendet man <code>DataOutputStream<\/code> und <code>DataInputStream<\/code>, um strukturierte Daten zu schreiben und zu lesen?<\/a><\/li>\n<\/ul>\n\n\n\n<p>Im weiteren Verlauf der Serie werden dann fortgeschritteren Themen behandelt:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die in Java 1.4 eingef\u00fchrten <a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/\">NIO-Channels und Buffer<\/a>, um insbesondere das Arbeiten mit gro\u00dfen Dateien zu beschleunigen<\/li>\n\n\n\n<li><a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/#Memory-mapped_Files_Wie_man_einen_Teil_einer_Datei_in_den_Speicher_mappt\">Memory-mapped I\/O<\/a> f\u00fcr rasend schnellen Dateizugriff ohne Streams<\/li>\n\n\n\n<li><a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/#File_Locking_Sperren_von_Dateibereichen\">File Locking<\/a>, um parallel \u2013 also aus mehreren Threads oder Prozessen \u2013 konfliktfrei auf dieselben Dateien zuzugreifen <\/li>\n<\/ul>\n\n\n\n<p>M\u00f6chtest du informiert werden, wenn weitere Artikel ver\u00f6ffentlicht werden? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden. Wenn dir der Artikel gefallen hat, freue ich mich auch, wenn du ihn \u00fcber einen der Buttons am Ende teilst.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Dieser zweite Teil stellt Methoden zum Schreiben von kleinen und gro\u00dfen Text- und Bin\u00e4rdateien in Java vor.<\/p>\n<p>Nachdem du diesen Artikel gelesen hast, wirst du genau wissen, wann du FileWriter, FileOutputStream, OutputStreamReader, BufferedOutputStream und BufferedWriter verwenden solltest.<\/p>\n","protected":false},"author":1,"featured_media":34419,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"none","_seopress_titles_title":"","_seopress_titles_desc":"Wie schreibt man komfortabel und schnell Text- und Bin\u00e4rdateien in Java? Wann verwendet man FileWriter, wann FileOutputStream?","_seopress_robots_index":"","_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":16582,"_post_count":0,"footnotes":""},"categories":[64],"tags":[166],"class_list":["post-8804","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-dateien"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2019\/12\/java-write-file.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":0,"uagb_excerpt":"Dieser zweite Teil stellt Methoden zum Schreiben von kleinen und gro\u00dfen Text- und Bin\u00e4rdateien in Java vor. Nachdem du diesen Artikel gelesen hast, wirst du genau wissen, wann du FileWriter, FileOutputStream, OutputStreamReader, BufferedOutputStream und BufferedWriter verwenden solltest.","public_identification_id":"45f21eea9c6c41e58fc438ff44e1a322","private_identification_id":"cf903ef531934570924fa360b0eeeca4","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8804","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=8804"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8804\/revisions"}],"predecessor-version":[{"id":41967,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8804\/revisions\/41967"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/34419"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=8804"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=8804"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=8804"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}