Il modo più veloce per dividere una stringa delimitata in Java

Ho scritto un test benchmark rapido e sporco per questo. Confronta 7 diversi metodi, alcuni dei quali richiedono una conoscenza specifica dei dati che vengono suddivisi.

Per la suddivisione di base per scopi generici, Guava Splitter è 3,5 volte più veloce di String # split () e consiglio di utilizzarlo. Stringtokenizer è leggermente più veloce di quello e dividersi con indexOf è due volte più veloce di nuovo.

Per il codice e maggiori informazioni vedi link

Come scrive @Tom, un approccio di tipo indexOf è più veloce di String.split() , poiché quest'ultimo si occupa di espressioni regolari e ha un sacco di overhead aggiuntivo per loro.

Tuttavia, una modifica dell'algoritmo potrebbe darti una super velocità. Supponendo che questo comparatore sarà usato per ordinare le tue ~ 100.000 stringhe, non scrivere Comparator<String> . Perché, nel corso del tuo ordinamento, la stessa stringa verrà probabilmente confrontata con più volte, quindi dividerla più volte, ecc ...

Dividi tutte le stringhe una volta in String [] se disponi di Comparator<String[]> per ordinare la stringa []. Quindi, alla fine, puoi combinarli tutti insieme.

In alternativa, potresti anche utilizzare una mappa per memorizzare nella cache String - > String [] o viceversa. per esempio. (abbozzato) Nota anche, stai scambiando memoria per velocità, spero tu abbia un sacco di RAM

HashMap<String, String[]> cache = new HashMap();

int compare(String s1, String s2) {
   String[] cached1 = cache.get(s1);
   if (cached1  == null) {
      cached1 = mySuperSplitter(s1):
      cache.put(s1, cached1);
   }
   String[] cached2 = cache.get(s2);
   if (cached2  == null) {
      cached2 = mySuperSplitter(s2):
      cache.put(s2, cached2);
   }

   return compareAsArrays(cached1, cached2);  // real comparison done here
}

Secondo questo benchmark , StringTokenizer è più veloce per dividere le stringhe ma non restituisce un array che lo rende meno conveniente.

Se devi ordinare milioni di righe, ti consigliamo di utilizzare un RDBMS.

Questo è il metodo che utilizzo per analizzare file di grandi dimensioni (1GB +) delimitati da tabulazioni. Ha un sovraccarico molto inferiore a String.split() , ma è limitato a char come delimitatore. Se qualcuno ha un metodo più veloce, mi piacerebbe vederlo. Questo può anche essere fatto su CharSequence e CharSequence.subSequence , ma ciò richiede l'implementazione di CharSequence.indexOf(char) (fare riferimento al metodo del pacchetto String.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) se interessati)

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;
}