# In eine Textdatei schreiben/auslesen (RandomAccessFile)



## Tsa (2. Januar 2007)

Hallo und Frohes neues Jahr 
für die Schule haben wir ein kleines Projekt über die Ferien auf. An sich kein Problem und die Arbeit über das Thema war bei mir auch super, aber irgendwie häng ich gerade. Hier erstmal die Klasse, dann mein Problem. Ich hoffe die is ganz anständig formatiert, sollte aber ok sein:


```
import java.io.RandomAccessFile;
import java.io.IOException;

/**
 * Schreibt und liest in/aus Textdateien
 * 
 * @author (Jens Dallmann) 
 * @version (29.12.2006)
 */
public class Verarbeitung
{

    private static long pointer = 0;
   
    private final static String DATEINAME = "Daten.dat";    
    private final static int MAXLENGTH = 30;
    private final static int MAXSONGTITEL = 20;
    private final static String READ = "r";
    private final static String READWRITE = "rw";
    private final static char UMBRUCH = '\n';
    private final static long LAENGE_EINES_DATENSATZES = (MAXLENGTH) * (MAXSONGTITEL+2); //(Maximale Länge + UmbruchsChar) *  (Titel und Interpret)
    
    private static RandomAccessFile raf = null;
    
    /**
     * Fügt einen Datensatz hinzu
     * 
     * @param titel String
     * @param interpret String
     * @param songtitel Liste
     */
    public static void add(String titel, String interpret, Liste songtitel)
    {   
        try
        {
            raf = new RandomAccessFile(DATEINAME, READWRITE);
            
            pointer = raf.length();
            einfuegen(titel, interpret, songtitel);
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
    
    /**
     * Wechselt zum nächsten Datensatz und gibt diesen zurück
     * 
     * @return eineCD CD
     */
    public static CD next()
    {
        pointer = pointer + LAENGE_EINES_DATENSATZES;
        return returnThis();
    }
    
    /**
     * Wechselt zum vorherigen Datensatz und gibt diesen zurück
     * 
     * @return eineCD CD
     */
    public static CD back()
    {
        pointer = pointer - LAENGE_EINES_DATENSATZES;
        
        return returnThis();
    }
    
    /**
     * Wechselt zum ersten Datensatz und gibt diesen zurück
     * 
     * @return eineCD CD
     */
    public static CD begin()
    {
        pointer = 0;
        
        return returnThis();
    }
    
    /**
     * Wechselt zum letzten Datensatz und gibt diesen zurück
     * 
     * @return eineCD CD
     */
    public static CD end()
    {
        try
        {
            raf = new RandomAccessFile(DATEINAME, READ);
            
            pointer = raf.length() - LAENGE_EINES_DATENSATZES;
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
        
        return returnThis();
    }
    
    /**
     * Gibt den aktuellen Datensatz zurück
     * 
     * @return eineCD CD
     */
    public static CD returnThis()
    {
        CD eineCD = new CD();
        Liste eineListe = new Liste();
        
        try
        {
            raf = new RandomAccessFile("Daten.dat", READ);    
           
            eineCD.setTitel(naechstenStringLesen());
            eineCD.setInterpret(naechstenStringLesen());
            
            for(int i = 0; i < MAXSONGTITEL; i++)
            {
                eineListe.add(naechstenStringLesen());
            }
            
            eineCD.setSongtitel(eineListe);
            System.out.println(LAENGE_EINES_DATENSATZES);
            pointer = pointer - LAENGE_EINES_DATENSATZES;
            
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
        
        return eineCD;
    }
    
    /**
     * Ersetzt den aktuellen Datensatz
     * 
     * @return eineCD CD
     */
    public static void replace(String titel, String interpret, Liste songtitel)
    {
        try
        {
            raf = new RandomAccessFile(DATEINAME, READWRITE);
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
        
        einfuegen(titel, interpret, songtitel);
    }
    
    private static String naechstenStringLesen()
    {
        StringBuffer cache = new StringBuffer();
       
        try
        {
            raf = new RandomAccessFile(DATEINAME, READ);
            raf.seek(pointer);
        
            while(true)
            {                
                char c = raf.readChar();
                if(c == '\n')
                {
                    break;
                }
                cache.append(c);
                pointer += 2;
            }
        
            pointer += 2;
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
        return cache.toString().trim();
    }
    
    private static void einfuegen(String titel, String interpret, Liste songtitel)
    {
        long alterPointer = pointer;
        try
        {
            raf = new RandomAccessFile(DATEINAME,READWRITE);
            raf.seek(pointer);
                
            raf.writeChars(titel + UMBRUCH);
            pointer += MAXLENGTH + 2;
            raf.seek(pointer);
            
            raf.writeChars(interpret + UMBRUCH);
            pointer += MAXLENGTH + 2;
            raf.seek(pointer);
            
            for(int i = 0; i < songtitel.size(); i++)
            {
                raf.writeChars(((String) songtitel.get(i)) + UMBRUCH);
                pointer += MAXLENGTH + 2;
                raf.seek(pointer);
            }

            for(int i = songtitel.size(); i < MAXSONGTITEL; i++)
            {
                raf.writeChar(UMBRUCH);
                pointer += MAXLENGTH + 2;
                raf.seek(pointer);
            }
            
            pointer = alterPointer;
            raf.seek(pointer);
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
}
```

Das Problem ist jetzt das ich LAENGE_EINES_DATENSATZES natürlich auch Variabel halten will. Wenn ich jetzt 22*32 (22 Strings werden geschrieben mit der Laenge von 15, also einer Bytelänge von 30 + 2, wegen dem "Umbruch-Char", der ja auch 2 Byte lang ist.) ausrechne komme ich auf 704 Bytes/Datensatz. Allerdings werden nur 674 Bytes/Datensatz verwendet.
Sicher könnte ich jetzt einfach die 674 reinschreiben und fertig, aber will das schon variabel halten. Ich kann mir nicht erklären, wie man auf diese Zahl kommt. Hat von euch jemand eine Idee?


----------

