Zeilenweise lesen aus einem Array

[Katjushka]

GEGEBEN: Eine Text-Datei 10MB mit den URLs und ihren Inhalten. Die sieht etwa so aus:

@@@ http://braeustueble.de/impressum.html


[br_Logo_web.gif]

Impressum

Gaststätte Bräustüble GbR
Postadresse
Schloßstraße 14
74831 Gundelsheim
Telefon
06269-8453
FAX
06269-45285
E-Mail
service@braeustueble.de
Vertretungsberechtigte Gesellschafter: Gisela Frank
Haftungshinweis: Trotz sorgfältiger inhaltlicher Kontrolle übernehmen wir
keine Haftung für die Inhalte externer Links. Für den Inhalt der verlinkten
Seiten sind ausschließlich deren Betreiber verantwortlich.
Kontakt

ZIEL: Firmennamen aus den URLs extrahieren
VORGANG: 1. Jede URL und ihre Inhalt wird in einen Array blocks[] eingelesen. Das Array enthält also in jeder Zelle
eine URL und ihre Inhalt
2. Das Array wird durchgelaufen, und in jeder "Zelle" wird nach dem RegEx gesucht. Bis jetzt habe ich es so
gemacht:

		 for(int i =0; i<blocks.length; i++){
		      Matcher matcher2 = pattern2.matcher(blocks[i]);
               while(matcher2.find()){
                  
                   String regexImage ="(\\[.*|\\s{2,}|\\*|@@@.*|www.*|.*\\|.*|ist.*|\\sin\\s.*|\\s.\\s|Verantwortlich für diese Seite|\\s.{4}\\s{2,}|Firmenname:?\\s*|Vereinsname:?|Name:?|\\d{3,}|Firma:?\\s|Verantwortlich für die Website:|Email.*|\\.\\W*|Info:.*|Mail:.*|\\sund.*|,.*|\\_*)";
                   Pattern patternImage= Pattern.compile(regexImage);
                   firmenname = matcher2.group();
                   
                   Matcher matcherImage =patternImage.matcher(firmenname);
                   firmenname = matcherImage.replaceAll("");
                  
                   if (firmenname.length() > 5){
                   firmenname="Firmenname: "+firmenname+"\n";    
                                 
                      try {
                           for (int n=0; n < firmenname.length(); n++){
                              schreibeStrom.write((byte)firmenname.charAt(n));
                            }
                        } catch (IOException ex) {
                            ex.printStackTrace();
                        }
                   }
               }

PROBLEM: Das Verarbeiten von "kleinen" URLs geht ziemlich flott, für die größeren Inhalte braucht das Programm
aber sehr lange.
LÖSUNG, DIE ICH MIR VORSTELLE: innerhalb der Zellen Zeilenweise einlesen, also etwas in der Art:

	for(int i =0; i<blocks.length; i++){
		 while((thisLine=reader.readLine())!=null){// oder so ähnlich
			TODO
		 }
		 }

Wie könnte ich so etwas implementieren?

Vielen Dank im Voraus.

 

[Katjushka]

Kann mir wirklich keiner helfen?
Jetzt hab ich das Programm laufen lassen, und es läuft 10 Stunden auf meinem PC.
Wenn keiner weiß, wie es mit dem zeilenweise Einlesen geht, habt ihr vielleicht andere Ideen, wie man die Laufzeit verbessern könnte?
Vielen Dank

 

[madboy]

zum Beschleunigen der Sache: mach erst mal das aus der Schleife raus:

                   String regexImage ="(\\[.*|\\s{2,}|\\*|@@@.*|www.*|.*\\|.*|ist.*|\\sin\\s.*|\\s.\\s|Verantwortlich für diese Seite|\\s.{4}\\s{2,}|Firmenname:?\\s*|Vereinsname:?|Name:?|\\d{3,}|Firma:?\\s|Verantwortlich für die Website:|Email.*|\\.\\W*|Info:.*|Mail:.*|\\sund.*|,.*|\\_*)";
                   Pattern patternImage= Pattern.compile(regexImage);

dann nimm einen StringBuilder anstatt

"Firmenname: "+firmenname+"\n";

for (int n=0; n < firmenname.length(); n++){
                              schreibeStrom.write((byte)firmenname.charAt(n));
                            }

Ist schreibeStrom was gepuffertes? Falls nicht: nimm was gepuffertes. Oder einen Writer. Dann kannst du Strings auf ein Mal schreiben anstatt jedes Byte extra.

Allgemein noch: wenn du es irgendwie einrichten kannst: lass den regex nicht über alles laufen. Das wird sehr langsam.
Treffe statt dessen eine "vorauswahl", z.B. mit IndexOf und matche die dann mit dem regex.

Ausserdem kannst du auch selber schauen, wo das Programm so lange braucht. Ein paar Ausgaben in der Art sollten dich auf die richtige Spur bringen:

long time = System.currentTimeMillis();
//vermuteter Übeltäterblock ;-)
System.out.println("time: " + (System.currentTimeMillis() - time))

Lies doch direkt von der Textdatei, anstatt erst in das Array. Dann kannst du sowas machen

while((thisLine=reader.readLine())!=null){// oder so ähnlich 
         TODO 
}

 

[Katjushka]

Das mit dem Writer klappt komischerweise nicht:

 writer = new FileWriter("123.txt");
            for(int i =200; i<250; i++){ 
             
                    Matcher matcher = pattern.matcher(blocks[i]);
                    while (matcher.find()){
                         aktuelleurl=(i+1)+matcher.group(2)+"\n"; 
       
                           System.out.println(aktuelleurl);
                        try {
                                writer.write(aktuelleurl);
                            } catch (IOException ex) {
                                ex.printStackTrace();
                            }
                      }
               }

bei solchem Code, bekommt man zwar keine Fehlermeldungen, aber die Ergebnisdatei bleibt leer Wenn ich das gleiche schreibe bloss mit:

                      try {
                               for (int n=0; n < aktuelleurl.length(); n++){
                                  schreibeStrom.write((byte)aktuelleurl.charAt(n));
                                }
                            } catch (IOException ex) {
                                ex.printStackTrace();
                            }

läuft das Programm, so wie ich will.
Was könnte der Grund sein?

 

[Wildcard]

Solange in deinem Code noch irgendein String + String steht brauchen wir über Performance eigentlich gar nicht weiter zu reden :wink:
Die nächste Sache ist das rausschreiben. Bei größeren Datenmengen ist hier der FileChannel am schnellsten.

 

[Katjushka]

Aber ein Writer akzeptiert keinen StringBuilder als Parameter, und toString funktioniert mit einem StringBuilder auch nicht.

 

[Wildcard]

und toString funktioniert mit einem StringBuilder auch nicht.

Natürlich funktioniert das.

 

[Katjushka]

"Zitat" von NetBeans

D:\InfoExtraktion\src\infoextraktion\MatcheZeile.java:100: toString() in java.lang.Object cannot be applied to (java.lang.StringBuilder)

 

[stev.glasow]

Wird (i+1)+matcher.group(2)+"\n" nicht eh vom compiler in str_buf.append(bla) optimiert?
Hast du mal nen Profiler darüber laufen lassen? Ich glaub dein regex ist übelst langsam diese .* fressen gut zeit soweit ich weiß, mach da mal nen .+? draus so weit das möglich ist.

toString() in java.lang.Object cannot be applied to (java.lang.StringBuilder)

öh?

 

[Katjushka]

Nicht vergessen, es ist ein "Anfängerfragen" Thread

Wird (i+1)+matcher.group(2)+"\n" nicht eh vom compiler in str_buf.append(bla) optimiert?

Sagt mir leider gar nichts.
Von einem Profiler höre ich zum ersten Mal in meinem Leben. Hab jetzt bei Google angegeben, scheint ein Programm zu sein, dass einen Code nach Laufzeiten und vielleicht Speicherbedarf kontrolliert, oder?

Das Zitat wurde für Wildcard gepostet, weil er gemeint hat, dass toString() für einen StringReader funktioniert.

 

[Wildcard]

toString kann man auf jedem Objekt aufrufen.
Du machst wohl was falsch.

 

[stev.glasow]

Nicht vergessen, es ist ein "Anfängerfragen" Thread

Wird (i+1)+matcher.group(2)+"\n" nicht eh vom compiler in str_buf.append(bla) optimiert?

Sagt mir leider gar nichts.

Damit wollte ich sagen dass es bei sowas

(i+1)+matcher.group(2)+"\n"

oder sowas

"Firmenname: "+firmenname+"\n";

eigentlich egal ist ob du da nun selber nen StringBuffer (bzw StringBuilder) verwendest, der compiler macht das in diesem fall intern sowieso schon (glaube ich).

Von einem Profiler höre ich zum ersten Mal in meinem Leben. Hab jetzt bei Google angegeben, scheint ein Programm zu sein, dass einen Code nach Laufzeiten und vielleicht Speicherbedarf kontrolliert, oder?

Jo, damit kann man relativ einfach performance kritische aufrufe herausfinden, aber versuch erstmal deinen regulären ausdruck wie beschrieben abzuändern.

Das Zitat wurde für Wildcard gepostet, weil er gemeint hat, dass toString() für einen StringReader funktioniert.

funktioniert auch. irgendwie machst du da was falsch. hier mal nen beispiel:

		  StringBuilder buf = new StringBuilder();
		  buf.append("das");
		  buf.append(' ');
		  buf.append("ist ");
		  buf.append("ein test");
		  String str = buf.toString();
		  System.out.println(str);

Ausgabe: das ist ein test

 

[Wildcard]

Ja, der Compiler baut das in StringBuilder/Buffer um (anders kann man Strings nicht verknüpfen). Das Problem ist, das er nicht in der Lage ist den Builder/Buffer in einer sinnvollen Größe zu initialisieren und die richtige Position zur Objekterzeugung zu finden.
In Schleifen führt das zu massiven Laufzeitproblemen.