Methoden Verarbeitung von Größen Dateien

[lenny89]

Moin,

ich habe mir ein Programm geschrieben dass eine vorher ausgewallte Datei Zeilen weise einliest und die werte Verändert.
Das einlese von Dateien in der Größe von 0-3 MB beschied auch recht zügig.
Problem gibt es wenn Dateien größer (z.b. 20 MB) sind
dabei dauert das so extrem lange.
Das liegt wohl daran das ich die eingelesene und Veränderte Zeile in einer Variable speicher!?
Meine Frage bekommt man das auch irgendwie schneller hin?
kann ich die Datei schon schreiben/verändern beim einlesen ohne zwischenspeichern?

Code:

tempValue = "";
		  value = "";
		  glFD.setPBSizeMax((int)f.length());
		  glFD.clearPBSizeValue();
		  InputFile= new BufferedReader (new InputStreamReader(new FileInputStream(f.getAbsoluteFile())));           
          {
		    while((tempValue = InputFile.readLine()) != null) 
		   {
		      glFD.setPBSizeValue(tempValue.length());;
			  tempValue = tempValue.replaceAll("[A-Mn-z1-9]", "");
			  tempValue = tempValue.replaceAll("[N-Za-m._-]", "");
			  value = value + tempValue + "\r\n";
			}
			BufferedWriter f1= new BufferedWriter(new FileWriter(f));
			f1.write(value);
			f1.close();
			InputFile.close();
			glFD.setPBFileValue(1);

Danke im Voraus
lenny

 

[Beni]

Benutz die Klasse StringBuilder anstelle von

value = value + tempValue + "\r\n";

. Hintergrund: mit dem aktuellen Code kopierst du jedesmal alles was eingelesen wurde wenn du eine neuen Zeile hinten dran haengst. StringBuilder bietet Methoden wie "append" und "toString", welche dir hier helfen werden.

 

[lenny89]

ja danke werde ich mal ausprobieren.
geht die klasse den auch beim einlesen von Hexwerten?(einlesen von z.b. Bilder, Mp3,...)

 

[Michael...]

Eventuell kann man das ganze bei großen Dateien beschleunigen, wenn Du die Zeilen sofort wieder in ein zweite Datei schreibst (statt sie im Speicher zu halten) und anschließend umkopierst.

ja danke werde ich mal ausprobieren.
geht die klasse den auch beim einlesen von Hexwerten?(einlesen von z.b. Bilder, Mp3,...)

Ja, Hexwerte sind ja auch nichts anderes als Text und Zahlen.
Für Binäre Daten funktionieren Reader und Writer nicht, hier muss man dann direkt mit Streams z.B. DataIntput/DataOutputStream arbeiten.

 

[Bernd Hohmann]

Das liegt wohl daran das ich die eingelesene und Veränderte Zeile in einer Variable speicher!? Meine Frage bekommt man das auch irgendwie schneller hin? Kann ich die Datei schon schreiben/verändern beim einlesen ohne zwischenspeichern?

Ja.

Dein Problem ist, dass (im Prinzip) bei jedem Anhängen der bestehende String in einen neuen String + etwas Luft fürs Anhängen umkopiert werden muss. Je größer der String, umso langsamer wird es.

Da nützt auch der Umstieg auf einen StringBuilder nichts, Operationen wie strA=strA+strB setzt der Compiler und spätestens die Runtime sowieso in eine ähnliche Konstruktion wie den StringBuilder um.

Du kannst aber problemlos Zeilenweise lesen und das über einen PrintWriter Zeilenweise wegschreiben in eine andere Datei wegschreiben, das sollte Dein Problem lösen.

Bermd

 

[timbeau]

Ich finds komisch, dass das so lange dauern soll. Der StringBuilder ist auf jeden Fall deutlich schneller als die Konkatenation von Strings. Hatten wir vor kurzem hier im Forum aber habs grade mal selber und hoffentlich halbwegs aussagekräftig getestet:

public static void main(String[] args) {
		String s = "";
		StringBuilder sb = new StringBuilder();
		
		
		/* warmlaufen */
		for (int i = 0; i < 10000; i++) {
			s = s + "a";
			sb.append("a");
		}
		
		/* reset */
		s = "";
		sb.setLength(0);
		
		long start = System.currentTimeMillis();
		/* Test */
		for (int i = 0; i < 100000; i++) {
			s = s + "a";
		}
		long stop = System.currentTimeMillis();
		
		System.out.println(stop - start);
		
		start = System.currentTimeMillis();
		/* Test */
		for (int i = 0; i < 100000; i++) {
			sb.append("a");
		}
		stop = System.currentTimeMillis();
		
		System.out.println(stop - start);
	}

Ergibt:
~10000 (String)
und
~10 (StringBuilder)

 

[Bernd Hohmann]

Der StringBuilder ist auf jeden Fall deutlich schneller als die Konkatenation von Strings. Hatten wir vor kurzem hier im Forum aber habs grade mal selber und hoffentlich halbwegs aussagekräftig getestet

Das ist ja witzig... Ich war bis jetzt der festen Überzeugung dass der Java Compiler das ordentlich optimiert (dh vor der Schleife einen StringBuilder aufmacht und innerhalb der Schleifer nur .append(...) aufruft und erst am Ende das .toString() ausführt.

War das nicht mal so oder hatte ich da eine Halluzination?

Bernd

 

[Ark]

War das nicht mal so oder hatte ich da eine Halluzination?

Du hattest eine Halluzination.

Der Compiler macht aus der Verkettung zweier String-Konstanten mittels + sofort eine entsprechende String-Konstante, die dann so auch in der class-Datei wieder auftaucht. Für eine Verkettung von Variablen (Strings) und (variablen/konstanten) Strings im Quelltext mit Hilfe des +-Operators erzeugt er Bytecode äquivalent zu [c]new StringBuilder().append(ersterString).append(zweiterString).toString()[/c] (oder so ähnlich, vor JDK 1.5 StringBuffer statt StringBuilder). Die [c]append()[/c]-Kette reißt ab, sobald die +-Kette im Quelltext abreißt.

Ark

 

[maki]

Schon mal einen Profiler wie zB. VisualVM probiert?

Alles andere ist nurgeraten/spekuliert wenn es um Performanceoptimierungen geht.

Spekuliert:
Vielleicht werden soviele Strings erzeugt dass der GC ständig läuft weil der Heap zu klein ist...

 

[mla.rue]

value = value + tempValue + "\r\n";

Je grösser die Variable wird, desto langsamer wird die ganze Sache (Value muss aus dem Speicher gelesen werden, X hinzugefügt und neuer Speicher zugewiesen werden, da ja grösser geworden). Benutz eine Liste oder Array pro Zeile und wenn die Datei wieder schreiben willst, gehst es Index für Index durch.

damit gehts natürlich auch

filewriter.writeLine(n, value);