Maneira mais rápida de dividir uma String delimitada em Java

Estou construindo um comparador que fornece capacidade de classificação de várias colunas em uma String delimitada. Atualmente, estou usando o método split da classe String como minha escolha preferida para dividir a String bruta em tokens.

Essa é a melhor maneira de converter a String bruta em uma matriz String? Vou classificar milhões de linhas, então acho que a abordagem é importante.

Parece funcionar bem e é muito fácil, mas não tenho certeza se existe uma maneira mais rápida em java.

Aqui está como a classificação funciona no meu Comparador:

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

Depois de comparar as várias abordagens, acredite ou não, o método split foi o mais rápido usando a versão mais recente do java. Você pode fazer o download do meu comparador completo aqui: https://sourceforge.net/projects/multicolumnrowcomparator/

Eu escrevi um teste de benchmark rápido e sujo para isso. Ele compara 7 métodos diferentes, alguns dos quais requerem conhecimento específico dos dados que estão sendo divididos.

Para a divisão básica de uso geral, o Guava Splitter é 3,5x mais rápido que o String # split () e eu recomendo usá-lo. O stringtokenizer é um pouco mais rápido que isso e dividir-se com indexOf é duas vezes mais rápido do que isso.

Para obter o código e mais informações, consulte http://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

Como o @Tom escreve, uma abordagem do tipo indexOf é mais rápida que String.split(), uma vez que a última lida com expressões regulares e possui uma sobrecarga extra para elas.

No entanto, uma alteração no algoritmo pode fornecer uma super aceleração. Supondo que este comparador seja usado para classificar suas ~ 100.000 Strings, não escreva o Comparator<String>. Porque, no decorrer da sua classificação, a mesma String provavelmente será comparada várias vezes, então você a dividirá várias vezes, etc ...

Divida todas as Strings uma vez em String [] s e Comparator<String[]>classifique a String []. Então, no final, você pode combiná-los todos juntos.

Como alternativa, você também pode usar um mapa para armazenar em cache a String -> String [] ou vice-versa. Por exemplo, (esboçado) Observe também que você está trocando memória por velocidade, espero ter muita 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
}

De acordo com esses benchmarks , o StringTokenizer é mais rápido para dividir strings, mas não retorna uma matriz, o que o torna menos conveniente.

Se você precisar classificar milhões de linhas, recomendo usar um RDBMS.

Esse é o método que eu uso para analisar arquivos grandes (1GB +) delimitados por tabulação. Tem muito menos sobrecarga do que String.split(), mas é limitado a charum delimitador. Se alguém tiver um método mais rápido, eu gostaria de vê-lo. Isso também pode ser feito repetidamente CharSequencee CharSequence.subSequence, mas isso requer implementação CharSequence.indexOf(char)(consulte o método do pacote, String.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)se estiver interessado).

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