Najszybszy sposób na podzielenie rozdzielanego łańcucha w Javie

Buduję komparator, który umożliwia sortowanie wielu kolumn na ograniczonym łańcuchu. Obecnie używam metody split z klasy String jako preferowanego sposobu dzielenia surowego ciągu na tokeny.

Czy to jest najlepszy sposób na konwersję surowego ciągu znaków na tablicę ciągu znaków? Będę sortować miliony wierszy, więc myślę, że podejście ma znaczenie.

Wydaje się, że działa dobrze i jest bardzo łatwy, ale nie ma pewności, czy w Javie jest szybszy sposób.

Oto jak działa sortowanie w moim Komparatorze:

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

Po analizie porównawczej różnych podejść, wierzcie lub nie, metoda podziału była najszybsza przy użyciu najnowszej wersji Java. Mój ukończony komparator możesz pobrać tutaj: https://sourceforge.net/projects/multicolumnrowcomparator/

Napisałem dla tego szybki i brudny test porównawczy. Porównuje 7 różnych metod, z których niektóre wymagają szczególnej wiedzy na temat dzielonych danych.

Dla podstawowego podziału ogólnego, Guava Splitter jest 3,5 razy szybszy niż String # split () i polecam go użyć. Stringtokenizer jest nieco szybszy, a dzielenie się za pomocą indexOf jest dwa razy szybsze niż ponownie.

Kod i więcej informacji można znaleźć na stronie http://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

Jak pisze @Tom, podejście typu indexOf jest szybsze niż String.split(), ponieważ to ostatnie zajmuje się wyrażeniami regularnymi i ma dla nich wiele dodatkowych kosztów.

Jednak jedna zmiana algorytmu, która może dać super przyspieszenie. Zakładając, że ten komparator będzie używany do sortowania ~ 100 000 ciągów, nie pisz Comparator<String>. Ponieważ w trakcie sortowania ten sam Ciąg prawdopodobnie będzie porównywany wiele razy, więc podzielisz go wiele razy itp.

Podziel wszystkie ciągi raz na String [] i Comparator<String[]>posortuj String []. Następnie możesz połączyć je wszystkie razem.

Możesz też użyć mapy do buforowania ciągu -> Ciąg [] lub odwrotnie. np. (szkicowy) Pamiętaj też, że wymieniasz pamięć na szybkość, mam nadzieję, że masz dużo pamięci 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
}

Według tych testów , StringTokenizer jest szybszy do dzielenia ciągów, ale nie zwraca tablicy, co czyni go mniej wygodnym.

Jeśli chcesz posortować miliony wierszy, polecam użycie RDBMS.

Jest to metoda, której używam do analizowania dużych (1 GB +) plików rozdzielanych tabulatorami. Ma znacznie mniejszy narzut niż String.split(), ale jest ograniczony do charogranicznika. Jeśli ktoś ma szybszą metodę, chciałbym ją zobaczyć. Można to również zrobić na CharSequencea CharSequence.subSequence, ale to wymaga wykonania CharSequence.indexOf(char)(patrz metody pakietu String.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)jeśli zainteresowany).

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