RandomAccessFile - Bestimmte Filesize begrenzen

[Iron Monkey]

Hi an alle!

Ich habe eine Klasse, mit der ich die Möglichkeit habe, die Anzahl der ersten Zeilen löschen zu können, z.B.

ich möchte die ersten 5 Zeilen löschen. Siehe unten den Source-Code:

Mein Wunsch ist, wie kann die Anzahl der Zeilen ermitteln, wenn ich die txt-Datei auf 50 MB begrenzen möchte und meine txt-Datei ist z.B. 160 MB groß? Ich will die Anzahl der Zeilen nicht selber bestimmen, sondern es soll ja durch die Datei-Größe berechnet werden oder habt ihr vielleicht eine andere Idee! Die Text-Datei sieht so aus:

04.10.2010 08:13:43 User[ 1943 ] CommandoGroup[ 0x0003 ] Commando[ 0x0015 ]
04.10.2010 08:13:45 User[ 1943 ] CommandoGroup[ 0x000B ] Commando[ 0x018F ]
04.10.2010 08:13:45 User[ 1943 ] CommandoGroup[ 0x000B ] Commando[ 0x018C ]

Nach dem Löschen darf es nicht so aussehen, sondern entweder komplette Zeile oder gar nichts löschen:

doGroup[ 0x0003 ] Commando[ 0x0015 ]
04.10.2010 08:13:45 User[ 1943 ] CommandoGroup[ 0x000B ] Commando[ 0x018F ]
04.10.2010 08:13:45 User[ 1943 ] CommandoGroup[ 0x000B ] Commando[ 0x018C ]

Man kann ja per Schleife jede Zeile durchgehen und nach der Schleife mit randomAccessFile.getFilePointer() die Größe ermitteln! Da komme ich irgendwie nicht weiter!

package File;

import java.io.*;

public class FileContentDelete {

	public FileContentDelete()
	{
        RandomAccessFile randomAccessFile = null;

		try
		{
			randomAccessFile = new RandomAccessFile( "Protokoll.txt", "rw" );

			if( randomAccessFile.length() == 0 )
				return;
			
			int numberOfLinesToBeSkipped = 5;
			
			for (int i = 0; i < numberOfLinesToBeSkipped; i++)
			    System.out.println("Skipping: " + randomAccessFile.readLine());


			long sourcePosition 		= randomAccessFile.getFilePointer();
			long originalLengthInBytes 	= randomAccessFile.length();
			long maxLength 				= originalLengthInBytes - sourcePosition;
			long destinationPosition 	= 0;

			byte[] buffer = new byte[65535];
			
			moveContent( randomAccessFile, sourcePosition, destinationPosition, maxLength, buffer );
			
			randomAccessFile.setLength( maxLength );
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		finally
		{
			if( randomAccessFile != null )
			{
				try
				{
					randomAccessFile.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}

				randomAccessFile = null;
			}
		}
	}

	public static void main(String[] args) {
		new FileContentDelete();
	}
	
	private static void moveContent( RandomAccessFile randomAccessFile, long sourcePosition, long destinationPosition, long lengthInBytes, byte[] buffer )
	{
        int currentByteCount = 0;
        int bytesRead = 0;
        int bytesWritten = 0;
 
        long currentSourcePosition = sourcePosition;
        long currentDestinationPosition = destinationPosition;
 
        try
        {
			randomAccessFile.seek(currentSourcePosition);
			
	        do
	        {
	            randomAccessFile.seek( currentSourcePosition );
	            currentByteCount = randomAccessFile.read( buffer );
	            bytesRead += currentByteCount;

	            if (bytesRead > lengthInBytes)
	                currentByteCount = ((int) lengthInBytes) - bytesWritten;

	            bytesWritten += currentByteCount;

	            randomAccessFile.seek( currentDestinationPosition );
	            randomAccessFile.write( buffer, 0, currentByteCount );

	            currentSourcePosition += currentByteCount;
	            currentDestinationPosition += currentByteCount;
	            randomAccessFile.seek( currentSourcePosition );
	        }
	        while (bytesWritten < lengthInBytes);
		}
        catch (IOException e) {
			e.printStackTrace();
		}
    }
}

Gruß
Iron Monkey

 

[Sneek]

Hm, also ich hab gerade mal probiert, wenn deine Zeilen immer die Form haben, wächst die echte Dateigröße pro Zeile immer um ungefähr 75-79 Bytes, also könntest du da ungefähr ausrechnen, wann 50 MB erreicht werden. Ist es wichtig, dass die Datei genau 50 MB groß ist?

Ein Problem könnte evt. sein, dass die größe auf dem Datenträger ja alle 4KB wächst, ich weiss nicht welchen Wert Java auslesen kann, die tatsächliche Größe oder die Größe auf dem Datenträger, müsstest du mal probieren.

lg

 

[Iron Monkey]

Hm, also ich hab gerade mal probiert, wenn deine Zeilen immer die Form haben, wächst die echte Dateigröße pro Zeile immer um ungefähr 75-79 Bytes, also könntest du da ungefähr ausrechnen, wann 50 MB erreicht werden. Ist es wichtig, dass die Datei genau 50 MB groß ist?

Ein Problem könnte evt. sein, dass die größe auf dem Datenträger ja alle 4KB wächst, ich weiss nicht welchen Wert Java auslesen kann, die tatsächliche Größe oder die Größe auf dem Datenträger, müsstest du mal probieren.

lg

Also, es muss nicht genau 50 MB groß sein, aber gut, die Textlänge jeder Zeile ist nicht immer gleich! Der Inhalt der Datei soll nur nicht die Grenze überschreiten, d.h. wenn der Inhalt ca. 49 MB groß ist, dann ist es ja super! Java kann die tatsächliche Größe auslesen. Das kann man bei randomAccessFile.length(); sehen.

Der Text wird ständig zeilenweise in die txt-Datei geschrieben, ich will auch nicht lesen ( Das interessiert mich nicht! ) und die Dateigröße wächst ja immer größer. Deswegen muss ich die festgelegte Max-Datei-Größe prüfen und wenn sie überschritten wurde, dann soll der alte Text von oben gelöscht werden, da die Neuen immer am Ende gefüllt werden quasi LIFO -> Last In, First out

Hast du vielleicht eine Idee, wie ich das am besten und am effektivsten realisieren kann? Das Problem ist ja, dass die Datei wahnsinnig groß ist, um den Text zeilenweise zu löschen! Ich meine damit von der Performance her. Es muss ja schnell gehen, dass der Anwender nix von merkt!

Gruß
Iron Monkey

 

[Sneek]

Hm, was schnelles und effektives fällt mir nur ein wenn die Textzeilen ungefähr gleich lang sind, da könntest du ja aus Gesamtgröße, den 50 MB und den 75-79 Bytes eine ungefähre Schleifenzählvariable berechnen, die auch gleichzeitig die Anzahl der Zeilen ist die gelöscht werden müssen.

Aber so fällt mir nichts weiter ein, als alle paar Löschvorgängen zu testen, wie groß die Datei gerade ist....

 

[Iron Monkey]

Hm, was schnelles und effektives fällt mir nur ein wenn die Textzeilen ungefähr gleich lang sind, da könntest du ja aus Gesamtgröße, den 50 MB und den 75-79 Bytes eine ungefähre Schleifenzählvariable berechnen, die auch gleichzeitig die Anzahl der Zeilen ist die gelöscht werden müssen.

Aber so fällt mir nichts weiter ein, als alle paar Löschvorgängen zu testen, wie groß die Datei gerade ist....

OK danke für die Tipps bzw. Vorschläge! Dann muss ich mir was anderes einfallen lassen!

Gruß
Iron Monkey