Der effizienteste Weg zum Aufteilen von Strings in Java

Question

Für diese Frage nehmen wir an, ich habe eine String, die Werte Two;.Three;.Four(and so on) enthält, aber Elemente sind durch ;. getrennt.

Jetzt weiß ich, es gibt Multiples Möglichkeiten, eine Zeichenfolge wie split() und StringTokenizer Aufspalten (wobei die schnelleren und funktionieren gut), aber meine Eingabedatei um 1GB und ich bin auf der Suche nach etwas, etwas effizienter als StringTokenizer.

Nach einiger Forschung, indexOf und substring sind ziemlich effizient, aber die Beispiele haben nur einzelne Trennzeichen oder Ergebnisse geben nur ein einzelnes Wort/Element zurück.

Beispielcode mit indexOf und substring:

String s = "quick,brown,fox,jumps,over,the,lazy,dog"; 
int from = s.indexOf(','); 
int to = s.indexOf(',', from+1); 
String brown = s.substring(from+1, to); 

Die oben genannten Arbeiten für den Druck brown aber wie ich indexOf und substring können Sie eine Linie mit mehreren Trennzeichen spalten und die alle Elemente, wie unten angezeigt.

Erwarteter Ausgang

Two 
Three 
Four 
....and so on 

Answer 1

StringTokenizer ist schneller als StringBuilder.

public static void main(String[] args) { 

    String str = "This is String , split by StringTokenizer, created by me"; 
    StringTokenizer st = new StringTokenizer(str); 

    System.out.println("---- Split by space ------"); 
    while (st.hasMoreElements()) { 
     System.out.println(st.nextElement()); 
    } 

    System.out.println("---- Split by comma ',' ------"); 
    StringTokenizer st2 = new StringTokenizer(str, ","); 

    while (st2.hasMoreElements()) { 
     System.out.println(st2.nextElement()); 
    } 
} 

Answer 2

Wenn Sie die ultimative Effizienz möchte ich Strings nicht verwenden, lassen Sie sie allein gespalten. Ich würde tun, was Compiler machen: Verarbeite die Datei auf einmal. Verwenden Sie eine BufferedReader mit einer großen Puffergröße, sagen Sie 128kb, und lesen Sie eine char zu einer Zeit, Akkumulation sie in sagen Sie eine StringBuilder bis Sie einen ; oder Leitungsabschluss erhalten.

Answer 3

Dies ist die Methode, die ich zum Aufteilen großer (1GB +) Tab-getrennte Dateien verwenden. Es ist auf einen char Begrenzer begrenzt, um Overhead von zusätzlichen Methodenaufrufen zu vermeiden (die durch die Laufzeit optimiert werden können), aber es kann leicht in String-delimited konvertiert werden. Ich wäre daran interessiert, wenn jemand eine schnellere Methode oder Verbesserungen für diese Methode entwickeln könnte.

public static String[] split(final String line, final char delimiter) 
{ 
    CharSequence[] temp = new CharSequence[(line.length()/2) + 1]; 
    int wordCount = 0; 
    int i = 0; 
    int j = line.indexOf(delimiter, 0); // first substring 

    while (j >= 0) 
    { 
     temp[wordCount++] = line.substring(i, j); 
     i = j + 1; 
     j = line.indexOf(delimiter, i); // rest of substrings 
    } 

    temp[wordCount++] = line.substring(i); // last substring 

    String[] result = new String[wordCount]; 
    System.arraycopy(temp, 0, result, 0, wordCount); 

    return result; 
}