Geschwindigkeitsproblem durch regulären Ausdruck?

[Micha]

Hallo,

ich lese Dateien ein und prüfe die einzelnen Zeilen mit zwei regulären Ausdrücken.

Eine Zeile kann folgenden Aufbau haben:

<String><String><Double><Double><Double><Double>

wobei der letzte Double-Wert optional ist (und nun wohl das Problem ist).

Meine Strategie war nun, prüfe die Zeile auf den vollständigen Inhalt, wenn dies fehlschlägt, prüfe, ob der optionale Wert nicht dabei ist.

  
  
// Strecke mit Standardabweichung  
String withRMSRegExp = new String("(\\S+).+?(\\S+).+?(-{0,1}\\d+\\.\\d+).+?(-{0,1}\\d+\\.\\d+).+?(-{0,1}\\d+\\.\\d+).+?(-{0,1}\\d+\\.\\d+)(.*)");  
  
// Strecke ohne Standardabweichung  
String withOutRMSRegExp = new String("(\\S+).+?(\\S+).+?(-{0,1}\\d+\\.\\d+).+?(-{0,1}\\d+\\.\\d+).+?(-{0,1}\\d+\\.\\d+)(.*)");  
  
// Pruefe String auf Vollstaendigkeit  
if (str.matches( withRMSRegExp )){  
  Pattern p = Pattern.compile( withRMSRegExp );  
  Matcher matcher = p.matcher( str );  
  
  if (matcher.find() && matcher.groupCount() == 7){  
    try {  
      String piId = matcher.group(1);  
      String pkId = matcher.group(2);  
      double hi = Double.parseDouble(matcher.group(3));  
      double hk = Double.parseDouble(matcher.group(4));  
      double sd = Double.parseDouble(matcher.group(5));  
      double err= Double.parseDouble(matcher.group(6));  
    }  
    catch(NumberFormatException err) {  
    // keine Strecke; uninteressant, was es sonst  
    // sein koennte, da in jedem Fall unbrauchbar  
    }  
  }  
}  
  
// pruefe ohne opt. Parameter  
else if (str.matches( withOutRMSRegExp )){  
  Pattern p = Pattern.compile( withOutRMSRegExp );  
  Matcher matcher = p.matcher( str );  
  
  if (matcher.find() && matcher.groupCount() == 6){  
    // try-catch wie oben  
  }  
}  

Ich lese nun eine Datei mit 150 Zeilen ein. Alle Zeilen entsprechen dem Typ 2 (ohne opt. Parameter) Das ging eigentlich recht fix. Mit meiner "tollen" Prüfung dauert es aber nun ewig. Ich habe dann mal nur den zweiten Ausdruck stehen lassen, was die Zeit spürbar reduziert.

Meine Frage ist nun, sind reguläre Ausdrücke hier eher ungeeignet oder was bremst den Code so aus?

Ich hatte vorher die str.matches() Bedingungen nicht drin, da ich noch annahm, dass die Bedingung if (matcher.find() && matcher.groupCount() == <int>) zeitintensiver wäre. Scheint aber nicht so zu sein. Eine der beiden Bedingungen ist daher sicher überflüssig. Lässt sich sagen, welche die etwas flottere ist oder gibts andere Optimierungsmöglichkeiten zB mein Prüfausdruck?

Mit freundlichem Gruß
Micha