Textfile lesen und schreiben - so viele Möglichkeiten

[mwildam]

Bei den ganzen Streams und Reader und Writer bin ich mittlerweile ein bißchen verwirrt und frage mich, wie man denn nun am besten eine Textdatei schreibt bzw. wieder einliest.

Dabei würde ich eher eine Variante bevorzugen, die auch bei größeren Datenmengen noch performant ist. Ich werde außerdem mal UTF-8 und mal ANSI-Ausgabe liefern müssen (bzw. entsprechende Eingaben lesen).

Ich habe da mal zB mit FileOutputStream und OutputStreamWriter gearbeitet und dabei festgestellt dass ich mich selber um richtige Startsequenz bei UTF-8-codierten Textfiles achten muss:

           char c1 = 239;
            char c2 = 187;
            char c3 = 191;
            String utf8Start = String.valueOf(c1) + String.valueOf(c2) + String.valueOf(c3);

Zumindest unter Windows wird von Notepad ein Textfile sonst nicht richtig als UTF-8 erkannt. Das darf ich natürlich nur schreiben, wenn es ein neues File ist. Wenn an eine bestehende Textdatei angehängt werden soll, dann darf ich das natürlich nicht so ausgeben.

Ich habe aber auch gesehen dass es eine Klasse DataOutputStream gibt, die würde eine Methode writeUTF anbieten. Fragt sich nur, ob das dann in allen Fällen richtig funktioniert - auch wenn ich zB Anhängen will an ein bestehendes File (habe das mit DataOutputStream noch nicht probiert). Die Klasse DataOutputStream muss man außerdem ja mit einem anderen Stream noch kombinieren, sonst tut das ja so nicht.

Ich sehe auf jeden Fall zig Möglichkeiten, wie ich es angehen könnte Textdateien zu lesen und zu schreiben - und wie erwartet zeigt mir Tante Google auch viele verschiedene Möglichkeiten. ???:L

 

[Guest]

Hey, du bist nicht alleine mit dem Problem!

Habe auch mit Dateien lesen/schreiben angefangen und mir gehts ganz genauso wie dir.
Wenn man sich durch die APIs wühlt steht meistens dabei
-dieser writer ist für char sequenzen gedacht
-dieser für bytes
-etc

naja kurz: die unmengen an writern und input/output streams verwirren, gibt es da vielleicht irgendwo eine nette übersicht oder ähnliches wo man sich schnell einen guten überblick verschaffen kann?

 

[SlaterB]

es gibt Lehrbücher wie
http://www.galileocomputing.de/open...13_001.htm#mj5c3809c0318cfba5c2be67ad74adea6b
richtig schön ist es da zumindest aber auch nicht..

 

[mwildam]

es gibt Lehrbücher wie
http://www.galileocomputing.de/open...13_001.htm#mj5c3809c0318cfba5c2be67ad74adea6b
richtig schön ist es da zumindest aber auch nicht..

Ich bin da genau bei dem Kapitel, habe aber zusätzlich auch im Internet ein bißchen gesucht. Aber schon in der Javainsel kommt raus, dass es viele Möglichkeiten gibt, hält sich aber zurück mit Empfehlungen, wie man es jetzt am besten wirklich machen sollte.

 

[mwildam]

Ich habe hier mal je zwei Beispiele - je ein einfacheres und ein etwas mühsameres, aber es wird ja empfohlen, gepuffert zu arbeiten - zumindest habe ich das in diversen Artikeln über Performance-Optimierung gelesen.

    private static String testSimpleFileRead2(String fileName)
    {
        StringBuilder contents = new StringBuilder();
        FileInputStream fis = null;
        InputStreamReader in = null;
        BufferedReader buf = null;
        {
            try
            {
                fis = new FileInputStream(fileName);
                in = new InputStreamReader(fis, "UTF-8");
                buf = new BufferedReader(in);
                String s;
                while ((s = buf.readLine()) != null)
                {
                    contents.append(s + System.getProperty("line.separator", "\n"));
                }
            }
            catch (UnsupportedEncodingException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            catch (FileNotFoundException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            catch (IOException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            finally
            {
                try
                {
                    buf.close();
                    in.close();
                    fis.close();
                }
                catch (IOException ex)
                {
                    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        return new String(contents);
    }


    private static void testSimpleFileWrite(String fileName, String content)
    {
        //Writes plain ANSI text

        Writer fw = null;

        try
        {
            fw = new FileWriter(fileName);
            fw.write(content);
        //fw.append('\n');
        }
        catch (IOException e)
        {
            //ignore or
            System.err.println("Error writing file");
        } finally
        {
            if (fw != null)
                try
                {
                    fw.close();
                }
                catch (IOException e)
                {
                //ignore
                }
        }
    }

    private static void testSimpleFileWrite2(String fileName, String content)
    {
        //Writes UTF-8 content
        FileOutputStream fos = null;
        OutputStreamWriter out = null;
        BufferedWriter buf = null;
        {
            try
            {
                fos = new FileOutputStream(fileName);
                out = new OutputStreamWriter(fos, "UTF-8");
                buf = new BufferedWriter(out);
                buf.write(content);
            }
            catch (UnsupportedEncodingException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            catch (FileNotFoundException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
            catch (IOException ex)
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } finally
            {
                try
                {
                    buf.close();
                    out.close();
                    fos.close();
                }
                catch (IOException ex)
                {
                    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    }

So, das Blöde ist jetzt zB, dass Notepad unter Windows das File noch immer als ANSI-File ansieht, wenn ich testSimpleFileWrite2 verwende - und da habe ich ja UTF-8 angegeben.

 

[mwildam]

Die Variante testSimpleFileWrite2 liefert ein für Notepad erkennbares UTF-8 nur dann, wenn auch wirklich Zeichen in dem Textfile vorkommen, die über den ANSI-Zeichensatz hinausgehen, also zB Umlaute.

Ich habe gesehen, dass die UTF-8-Header-Zeichen bei dieser Variante nicht mitgeschrieben werden.

Weil jetzt wieder mal Verwirrung in meinem Kopf herrscht, habe ich mal ein bisschen rumprobiert - auch unter Linux.

Ergebnis: OpenOffice schreibt die 3-Zeichen UTF-8-Header mit (unter Windows und Linux), gedit nicht, Notepad unter Windows tut es (wenn man ein neues entsprechendes File erstellt, aber auch wenn man ein UTF-8-Textfile ohne dem Header ändert und speichert).

Also tippe ich mal drauf, man sollte die 3 Zeichen lieber mitschreiben - tut aber keine der hier abgebildeten Varianten von sich aus.

Achtet da sonst keiner drauf oder wie? Bei den Beispielen, die ich so im Internetz gefunden habe (habe mir natürlich nicht wirklich alle angeschaut, aber ein paar halt), scheint da niemand drauf zu achten, obwohl ich aus meinen Tests schließe, dass die 3 Einleitungszeichen geschrieben werden sollten.