Cara tercepat untuk memisahkan String yang dibatasi di Jawa

Saya sedang membangun Comparator yang menyediakan kemampuan mengurutkan multi-kolom pada String yang dibatasi. Saat ini saya menggunakan metode split dari kelas String sebagai pilihan pilihan saya untuk memisahkan String mentah menjadi token.

Apakah ini cara berkinerja terbaik untuk mengubah String mentah menjadi array String? Saya akan menyortir jutaan baris jadi saya pikir pendekatan itu penting.

Tampaknya berjalan dengan baik dan sangat mudah, tetapi tidak yakin apakah ada cara yang lebih cepat di java.

Berikut ini cara kerja sortir di Comparator saya:

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

Setelah membandingkan berbagai pendekatan, percaya atau tidak, metode split adalah yang tercepat menggunakan versi terbaru java. Anda dapat mengunduh komparator lengkap saya di sini: https://sourceforge.net/projects/multicolumnrowcomparator/

Saya telah menulis tes benchmark cepat dan kotor untuk ini. Ini membandingkan 7 metode yang berbeda, beberapa di antaranya memerlukan pengetahuan khusus tentang data yang dipecah.

Untuk pemisahan tujuan umum dasar, Guava Splitter 3.5x lebih cepat dari String # split () dan saya akan merekomendasikan menggunakannya. Stringtokenizer sedikit lebih cepat dari itu dan membelah diri Anda dengan indexOf dua kali lebih cepat lagi.

Untuk kodenya dan info lebih lanjut lihat http://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

Seperti @Tom menulis, pendekatan tipe indexOf lebih cepat daripada String.split(), karena yang terakhir berurusan dengan ekspresi reguler dan memiliki banyak overhead tambahan untuk mereka.

Namun, satu perubahan algoritma yang mungkin memberi Anda speedup super. Dengan asumsi bahwa Pembanding ini akan digunakan untuk mengurutkan ~ 100.000 String Anda, jangan menulis Comparator<String>. Karena, dalam proses pengurutan Anda, String yang sama kemungkinan akan dibandingkan beberapa kali, jadi Anda akan membaginya beberapa kali, dll ...

Membagi semua Strings sekali dalam String [] s, dan memiliki Comparator<String[]>semacam String []. Kemudian, pada akhirnya, Anda bisa menggabungkan semuanya.

Atau, Anda juga bisa menggunakan Peta untuk menyimpan String -> String [] atau sebaliknya. misalnya (samar) Juga perhatikan, Anda berdagang memori untuk kecepatan, harap Anda memiliki RAM lotsa

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
}

Menurut tolok ukur ini , StringTokenizer lebih cepat untuk memisahkan string tetapi tidak mengembalikan array yang membuatnya kurang nyaman.

Jika Anda perlu mengurutkan jutaan baris, saya sarankan menggunakan RDBMS.

Ini adalah metode yang saya gunakan untuk mem-parsing file-file besar yang dibatasi tab (1GB +). Ini memiliki overhead jauh lebih sedikit daripada String.split(), tetapi terbatas charsebagai pembatas. Jika ada yang memiliki metode yang lebih cepat, saya ingin melihatnya. Ini juga dapat dilakukan berulang CharSequencedan CharSequence.subSequence, tetapi itu membutuhkan implementasi CharSequence.indexOf(char)(rujuk ke metode paket String.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)jika tertarik).

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