RandomAccessFile verständnis Problem

[Restor]

Hallo
Lese zwar öfter ein paar beiträge in dem Forum und hab mich heute dazu entschlossen mich zu registrieren weil ich seit Tagen ein problem bezüglich RandomAccessFile habe. (Ich lerne für meine prüfung ob ich in die 3te klasse aufsteigen darf).

Die aufgabenstellung ist das wir Datensätze bestehend aus einigen variablen mit RAF abspeichern sollen.
Wir haben es so gelernt das wir zuerst den platzverbrauch der variablen berechnen:
Das sieht bei mir so aus :
Es sind 2 int variablen vorhanden für die benötige ich 8 Bytes.
Und es sind 3 String variablen mit jeweils 20 zeichen vorhanden das macht nochmal 120 Bytes ( +10 sollten umlaute enthalten sein)

Das ergibt 138 bytes, bin mir nicht sicher ob das so stimmt^^

Dadurch erleichtern wir uns die arbeit in den nächsten Methoden um einiges
zb.: zeigerpositionieren mithilfe von "(satznummer-1) * datensatzlänge"

Hab das ganze dann ausprogrammiert und nach ewigen fehlermeldungen das etwas mit raf.readUTF(); nicht funktioniert habe ich versucht mir die länge der Datei zurückgeben zu lassen.
Als rückgabe erhielt ich 74 Bytes. Hab dann dementsprechend alles geändert und auf einmal funktionierts.

Die nun alles Entscheidende frage ist warum handelt es sich um 74 Bytes (pro datensatz) ?

Wenn ich bei meiner prüfung gefragt werde warum 74 gibt das einen rießen punkteabzug.

---------------------------------

Wieso sind in meiner txt Datei wenn ich diese per hand öffne seltsame zeichen und striche vorhanden ?
Wenn ich sie mit RAF auslese bekomme ich trotzdem eine einwandfrei lesbare antwort

---------------------------------

Wie muss ich es angehen wenn ich zeilenumbrüche in meiner Datei anzeigen will ? (\n)
Quellcode folgt

Meine Main methode

package RAF;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;

public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		File dateipfad = new File("D:\\Zwischenspeicher\\dokument.txt");
		
		RandomAccess raf = new RandomAccess(dateipfad, 74);       // Länge eines Datensatzes
		
		raf.putRecord(0);
		raf.putRecord(1);
		raf.putRecord(2);

		
		System.out.println(raf.getRecord(1));
		
		raf.delRecord(1);
		
		System.out.println(raf.getRecord(1));
		
		
		
		
		

	}

}

package RAF;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Record {
	
	String vorname;
	String nachname;
	int alter;
	int anzahlFinger;
	String farbe;
	
	public Record(String vorname, String nachname, int alter, int anzahlFinger, String farbe){            // Konstruktor
		this.vorname = vorname;
		this.nachname = nachname;
		this.alter = alter;
		this.anzahlFinger = anzahlFinger;
		this.farbe = farbe;
	}
	
	public Record() {                              // Konstruktor
		// TODO Auto-generated constructor stub
	}

	public void read(RandomAccessFile raf) throws IOException{
		vorname = raf.readUTF();
		nachname = raf.readUTF();
		alter = raf.readInt();
		anzahlFinger = raf.readInt();
		farbe = raf.readUTF();
		
	}
	
	public String toString(){
		return vorname + " " + nachname + " " + alter + " " + anzahlFinger + " " + farbe;
	}
	
	
	public void write(RandomAccessFile raf) throws IOException{                     // Schreibt sie in die RAF datei
		raf.writeUTF(vorname);
		raf.writeUTF(nachname);
		raf.writeInt(alter);
		raf.writeInt(anzahlFinger);
		raf.writeUTF(farbe);
	}
	
	public void createStdin(BufferedReader inp) throws IOException{                    // Liest von der Konsole und korrigiert die Länge
		String eingabe = inp.readLine();
		String[] eingabeAufgeteilt;
		eingabeAufgeteilt = eingabe.split(" ");
		
		vorname = fillAndCut(eingabeAufgeteilt[0]);
		nachname = fillAndCut(eingabeAufgeteilt[1]);
		alter = Integer.parseInt(eingabeAufgeteilt[2]);
		anzahlFinger = Integer.parseInt(eingabeAufgeteilt[3]);
		farbe = fillAndCut(eingabeAufgeteilt[4]);
	}
	
	public String fillAndCut(String data){           // Das zurechtschreiben der Strings funktioniert einwandfrei deshalb schreibe ich hierzu keine Kommentare :)
		if ( data.length() < 20){
			while(data.length() < 20){
				data = data + " ";
			}
		} else if (data.length() > 20){
			char[] letters = data.toCharArray();
			data = "";
			for (int counter = 0; counter < 20; counter++){
				data = data + letters[counter];
			}
		}
		return data;
	}
	
}

package RAF;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;

public class RandomAccess{
	
		BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
		Record rec = new Record();
		RandomAccessFile randomAF;
		File datei;
		int rafSize;
		int anzahlZ = 0;
			
		public RandomAccess(File dateipfad, int size) throws FileNotFoundException{
			this.randomAF = new RandomAccessFile(dateipfad, "rw");
			this.datei = dateipfad;
			this.rafSize = size;
		}
		
		public void close() throws IOException{
			randomAF.close();
		}
		
		public void putRecord(int number) throws IOException{                      // Schreibt einen neuen Datensatz
			rec.createStdin(inp);

			if(number == -1){                                  // Am ende hinzufügen
				randomAF.seek(datei.length());
				rec.write(randomAF);
			} else if (number >= 0 && number <= datei.length()/rafSize) {         // Überschreiben
				randomAF.seek(number*rafSize);
				rec.write(randomAF);
			}
		}
		
		public Record getRecord(int number) throws IOException {            // Gibt einen Datensatz aus
			randomAF.seek(number*rafSize);
			rec.read(randomAF);
			return rec;					
		}
		
		public void delRecord(int number) throws IOException{             // Löscht den angegebenen Satz (Index) und überschreibt ihn mit dem Letzten dannach wir die datei verkürzt
			randomAF.seek(datei.length()-rafSize);
			
			rec.read(randomAF);
			randomAF.seek(number*rafSize);
			rec.write(randomAF);
			
			randomAF.setLength(datei.length()-rafSize);
			

		}	
}

Würde mich sehr freuen wenn sich jemand finden würde der mir hilft

 

[hüteüberhüte]

Mal eine Frage.. Warum machst du die Klasse nicht serializable? Das wäre viel einfacher als diese Byte-Geschichten. Und warum muss es unbedingt RandomAccessFile sein? Könnte es nicht auch FileInputStream sein? Damit haben wir damals hantiert, und es war von den Methoden her auch überschaubarer. Kannst du nochmal kurz alle beteiligten API-Klassen nennen?

 

[Restor]

Zuerst mal vielen dank für deine schnelle antwort :toll:

Bei diesem Beispiel ist der Weg das ziel.
Wir haben damals eben diese aufgabenstellung bekommen. Mit den angaben ein RandomAccessFile zu verwenden und mit diesen Byte rechnereien.

Deshalb versuche ich das zu lösen um für den Fall das diese aufgabenstellung bei meiner Praktischen arbeit gestellt wird ich weis wie ich das ganze mit RAF angehen muss

Was meinst du mit API Klassen posten ?

 

[Nardian]

HI,

Es sind 2 int variablen vorhanden für die benötige ich 8 Bytes.
Und es sind 3 String variablen mit jeweils 20 zeichen vorhanden das macht nochmal 120 Bytes ( +10 sollten umlaute enthalten sein)

Das ergibt 138 bytes, bin mir nicht sicher ob das so stimmt^^

mal davon abgesehn dass 8 + 3*20 immer noch 68 sind (mit den +10 pro string wären es immer noch 98 ^^) ist das die anzahl der bytes die du brauchst.
Das ist aber nicht der speicherplatz wieviel RAF braucht. Warum? Weil RAF Strings folgendermaßen speichert:
für jeden string speichert er sich zusätzlich 2 bytes, was als eine Zahl interpretiert wird. Über diese Zahl sagt JavaDoc folgendes aus:

This value is the number of bytes actually written out, not the length of the string. Following the length, each character of the string is output, in sequence, using the modified UTF-8 encoding for each character.

was heißt das nun für dein beispiel? Falls du keine umlaute verwendest, also alle Strings genau 20 chars lang sind:

2*4 bleiben für die beiden ints
3 * (20 für die chars + 2 bytes für die länge vom writeUTF) = 66


8 + 66 = 74


---
genau diese 2 bytes bei den strings (die die länge angeben für UTF) verursachen in der .txt datei diese seltsamen symbole / striche. Hat was mit ASCII / ANSI codierung zu tun, da die länge (in deinem fall 20) als ein zeichen gelesen wird, und der char-code 20 ist kein druckbares zeichen --> komisches symbol
---
Zeilenumbrüche sollten kein problem sein... versuch doch mal einfach nich von stdin zu lesen, sondern einen string direkt speichern zu wollen wo du ein \n speicherst. Das könnte allerdings problematisch mit der record-länge werden, da es möglich ist dass UTF \n in 2 zeichen konvertiert... probiers einfach aus, wenns kaputt geht, dann weißt du jetzt wieso
---

MfG

 

[tröööt]

Außerdem wird es mit "\n" problematisch da dies eigentlich nur unter Unix standard ist. Windows erwartet "\r\n" zur richtigen Darstellung eines Zeilenumbruches. MAC hatte mal "\r" ist aber mitlerweile glaube ich auch zu "\n" übergegangen.

 

[Spacerat]

1. RandomAccessFile ist für embedded DBs eindeutig die bessere Wahl, weil gleichzeitig Lese- und Schreibvorgänge möglich sind und obendrein ein Zeiger auf die augenblickliche Byteposition im File existiert (ermöglicht relative Datenspeicherung). Bei den FileStreams geht jeweils nur eine Richtung und das auch nur seriell.
2. Serializable ist nur für Netzwerke gut um Instanzinhalte zu synchronisieren. Es wird immer ein Overhead der Länge "FullQualifiedClassName + 8 Byte SUID" produziert. Es wird sogar davon abgeraten Konfigurationsdaten zu serialisieren, in Datenbanken hat es dann wohl erst recht nichts verloren.
3. Wie lang so ein Record ist, ist für die Speicherung selbst erstmal egal, zur not müssen sie halt "gepadded" (auf länge gebracht) werden. Wie kommst du eigentlich darauf, dass ein UTF-String in Java Anzahl-Zeichen * 2 + Anteilig Umlaute wie auch immer ist? Diese Annahme ist falsch. EIN UTF8 (Das von Java verwendete System) Zeichen kann pro Zeichen 1 bis 4 Bytes haben, je nach dem, welchen Inhalt jene Bytes haben, die im Stream nach einem mit grösserer Wertigkeit als 127 auftauchen. Um ganz sicher zu gehen, dass die Strings mit richtiger Länge gespeichert werden, muss man entweder ihr CharArray speichern, auf die Gefahr hin, dass evtl. UTF8-Informationen verloren gehen, dann berechnet sich deren Länge Anzahl-Zeichen * 2 + NULL-Termination oder du berechnest für jedes Zeichen rigoros 4 Bytes (NULL-Termination auch hier nicht vergessen) und verwendest zum Speichern ausschliesslich die "write(byte[] b, int off, int len)"-Methode damit du geschriebene Bytes zählen kannst. Damit bekommst du den Zeiger in die Datei, wo der nächste Record anfängt. Diese Zeiger solltest du dir merken und in evtl. einer weiteren Datei (der Index-Datei) speichern, dann hast du statt relativer Datenspeicherung, Index-Sequentielle Datenspeicherung, nicht zu verwechseln mit reiner sequentiellen Datenspeicherung.

 

[Restor]

mal davon abgesehn dass 8 + 3*20 immer noch 68 sind (mit den +10 pro string wären es immer noch 98 ^^) ist das die anzahl der bytes die du brauchst.

Ich komm auf 120 weil ich 3 (anzahl der Strings) * 20 (länge eines Strings) * 2 (weil ein zeichen 2 byte benötigt) = 120


Ich freue mich über eure antworten, ihr 3 habt mir wirklich sehr geholfen mit dem ansatz sollte ich jzt mein problem lösen können

 

[hüteüberhüte]

2. Serializable ist nur für Netzwerke gut um Instanzinhalte zu synchronisieren. [...]

Um nur mal ein Beispiel zu geben, wie schnell so etwas mit serializable von der Hand geht:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Record implements Serializable {

    String vorname;
    String nachname;
    int alter;
    int anzahlFinger;
    String farbe;

    public Record(String vorname, String nachname, int alter, int anzahlFinger, String farbe) {
        this.vorname = vorname;
        this.nachname = nachname;
        this.alter = alter;
        this.anzahlFinger = anzahlFinger;
        this.farbe = farbe;
    }

    public boolean writeToFile(String fileName) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(fileName));
            oos.writeObject(this);
            oos.flush();
            return true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
        return false;
    }

    public static Record readFromFile(String fileName) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(fileName));
            return (Record) ois.readObject();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
        return null;
    }

    @Override
    public String toString() {
        return "Record{" + "vorname=" + vorname + ", nachname=" + nachname + ", alter=" + alter + ", anzahlFinger=" + anzahlFinger + ", farbe=" + farbe + '}';
    }
}

public class Main {

    public static void main(String[] args) {
        final String fileName = "C:\\Users\\Thomas\\Desktop\\rec.ser";

        Record r1 = new Record("vorn", "nachn", 111, 22, "red");
        r1.writeToFile(fileName);

        Record r2 = Record.readFromFile(fileName);
        System.out.println("r2 = " + r2);
    }
}

r2 = Record{vorname=vorn, nachname=nachn, alter=111, anzahlFinger=22, farbe=red}

Die Einfachheit spricht wohl für sich und sollte auch alle Provinzprediger überzeugen.

 

[Nardian]

Ich glaub es war hier sehr vielen klar, dass Serializable auch eine Möglichkeit ist, jedoch nicht unbedingt die geeignetste...
RAF ist mMn auch nicht besonders "schön" (aber vermutlich immer noch besser als Serializable).
Paar Gründe gegen Serializable:
1. Datenmenge: der eine Record von dir, gespeichert mit Serializable verbraucht soviel wie 3 RAF Records.. und das wird bei mehreren Records nicht anders
2. Informationsmenge: oft (wie auch hier) ist es nicht notwengid das gesamte Java-Objekt (inklusive hashvalue, und andere eindeutige objekt-informationen) zu speichern, sondern die reinen Nutzdaten.

und ein anderer grund wird sohl sein:

Die aufgabenstellung ist das wir Datensätze bestehend aus einigen variablen mit RAF abspeichern sollen.

Versteh mich nicht falsch... ich will nich sagen dass du unrecht hast, klar es ist möglich mit serializable zu persistieren. Jedoch war das nicht ziel dieses threads und somit (mMn) hier fehl am platz.
Sorry, soll nich böse klingen

MfG

 

[hüte]

@Nardian: Na klar, wird dadurch 3-mal soviel Speicherplatz verbraucht. Aber ginge es nur um die Größe, könnte man die Daten auch zippen. Und sicher, es geht um RAF (die Aufgabestellung verlangt es so), aber zwischenzeitlich ist eine Diskussion über Serializable entflammt. Deshalb mein Beitrag. (Just my two cents)

 

[Spacerat]

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

public final class IndexSequenziell {
	public static void main(String[] args) {
		try {
			RandomAccessFile raf = new RandomAccessFile("data.rel", "rw");

			Record r1 = new Record("vorn", "nachn", 111, 22, "red");
			System.out.println("r1 = " + r1);

			long pos = raf.getFilePointer(); // Position in Datei für Index sichern
			r1.write(raf);
			raf.seek(pos + Record.LENGTH); // auf naechsten Eintrag zeigen (padding)

			//...

			raf.seek(pos); // Position aus dem Index
			Record r2 = Record.read(raf);
			System.out.println("r2 = " + r2);
			raf.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class Record {
	public static final int LENGTH = 3 * 20 * 4 + 2 * 4 + 2 * 4;

	String vorname;
	String nachname;
	int alter;
	int anzahlFinger;
	String farbe;

	private Record() {
	}

	public Record(String vorname, String nachname, int alter, int anzahlFinger,
			String farbe) {
		if (vorname.length() > 20) {
			throw new IllegalArgumentException("vorname zu lang");
		}
		if (nachname.length() > 20) {
			throw new IllegalArgumentException("nachname zu lang");
		}
		if (farbe.length() > 20) {
			throw new IllegalArgumentException("farbe zu lang");
		}
		this.vorname = vorname;
		this.nachname = nachname;
		this.alter = alter;
		this.anzahlFinger = anzahlFinger;
		this.farbe = farbe;
	}

	static Record read(RandomAccessFile file) throws IOException {
		Record r = new Record();
		synchronized (file) {
			long pos = file.getFilePointer();
			r.vorname = file.readUTF();
			r.nachname = file.readUTF();
			r.alter = file.readInt();
			r.anzahlFinger = file.readInt();
			r.farbe = file.readUTF();
			if (file.getFilePointer() - pos > LENGTH) {
				throw new IOException("record ungueltig");
			}
			return r;
		}
	}

	void write(RandomAccessFile file) throws IOException {
		synchronized (file) {
			long pos = file.getFilePointer();
			file.writeUTF(vorname);
			file.writeUTF(nachname);
			file.writeInt(alter);
			file.writeInt(anzahlFinger);
			file.writeUTF(farbe);
			if (file.getFilePointer() - pos > LENGTH) {
				throw new IOException("record zu lang");
			}
		}
	}

	@Override
	public String toString() {
		return "Record{" + "vorname=" + vorname + ", nachname=" + nachname
				+ ", alter=" + alter + ", anzahlFinger=" + anzahlFinger
				+ ", farbe=" + farbe + '}';
	}
}

@hüteüberhüte: Provinzprediger überzeugt das vllt. aber zu denen zähle ich mich nicht. Um welchen Grad nun 11 Zeilen Unterschied einfacher sind, will ich gar nicht wissen (viel einfacher wäre es, bei beim nächsten "Provinzprediger" den Beitrag zu melden). Obwohl... sei froh, dass ich die Eingangsdatenüberprüfung, welche bei dir noch fehlt, bei mir mitgezählt habe. Ich mach mit RAF weiter und du kannst nehmen was du willst.
Aber BTT.: RAF ist nicht nur kürzer (zumindest was den Overhead angeht) sondern man muss auch nicht alle Daten im Speicher halten. Es genügt, wenn man ein Feld zu einem Suchindex macht. Das bedeutet, man hält nur den Inhalt dieses Feldes verbunden mit einem Dateizeiger in einer Map. Sortiert wird dann auch nicht mehr die Datei selber, sondern nur noch der jeweilige Suchindex. Der Zugriff auf die kompletten Datensätze findet ausschliesslich über die FilePointer statt.
Selbst wenn man so per FileIn- bzw. OutputStream Daten speichern würde (sprich, ohne Serializable), könnte man die Datensätze nur Seriell verwalten (es sei denn, man implementiert händisch irgendwelche Kapriolen, die RAF schon mitbringt). Das bedeutet nicht nur, das man die gesamte Datenbank im Speicher hätte, sondern auch dass das Auffinden von Daten um ein Vielfaches länger dauern würde, was ist bei grossen Datenmengen alles andere als vertretbar ist.