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

Sto creando un comparatore che fornisce funzionalità di ordinamento multi-colonna su una stringa delimitata. Attualmente sto usando il metodo split dalla classe String come la mia scelta preferita per dividere la stringa grezza in token.

È il modo migliore per convertire la stringa grezza in un array di stringhe? Ordinerò milioni di righe, quindi penso che l'approccio sia importante.

Sembra funzionare bene ed è molto semplice, ma non sono sicuro che ci sia un modo più veloce in Java.

Ecco come funziona l'ordinamento nel mio comparatore:

public int compare(String a, String b) {

    String[] aValues = a.split(_delimiter, _columnComparators.length);
    String[] bValues = b.split(_delimiter, _columnComparators.length);
    int result = 0;

    for( int index : _sortColumnIndices ) {
        result = _columnComparators[index].compare(aValues[index], bValues[index]);
        if(result != 0){
            break;
        }
    }
    return result;
}

Dopo aver confrontato i vari approcci, che ci crediate o no, il metodo split è stato il più veloce usando l'ultima versione di java. Puoi scaricare il mio comparatore completo qui: https://sourceforge.net/projects/multicolumnrowcomparator/

Ho scritto un test benchmark veloce e sporco per questo. Confronta 7 diversi metodi, alcuni dei quali richiedono una conoscenza specifica dei dati da suddividere.

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

Per il codice e ulteriori informazioni consultare http://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

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

Tuttavia, una modifica dell'algoritmo che potrebbe darti un supervelocità. Supponendo che questo comparatore verrà utilizzato per ordinare le ~ 100.000 stringhe, non scrivere il Comparator<String>. Perché, nel corso del tuo ordinamento, la stessa stringa verrà probabilmente confrontata più volte, quindi la suddividerai più volte, ecc ...

Dividi tutte le stringhe una volta in String [] s, e Comparator<String[]>ordina una stringa []. Quindi, alla fine, puoi combinarli tutti insieme.

In alternativa, puoi anche utilizzare una mappa per memorizzare nella cache String -> String [] o viceversa. es. (impreciso) Nota anche che stai scambiando memoria per la velocità, spero che tu abbia molta 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 questi parametri , StringTokenizer è più veloce per dividere le stringhe ma non restituisce un array che lo rende meno conveniente.

Se hai bisogno di ordinare milioni di righe ti consiglio di usare un RDBMS.

Questo è il metodo che utilizzo per l'analisi di file di grandi dimensioni (1 GB +) delimitati da tabulazioni. Ha un sovraccarico molto inferiore rispetto a String.split(), ma è limitato a charcome delimitatore. Se qualcuno ha un metodo più veloce, mi piacerebbe vederlo. Questo può essere fatto anche su CharSequencee CharSequence.subSequence, ma ciò richiede l'implementazione 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;
}