Java'da sınırlandırılmış bir Dizeyi bölmenin en hızlı yolu

Sınırlandırılmış bir dize üzerinde çok sütunlu sıralama yeteneği sağlayan bir karşılaştırıcı inşa ediyorum. Şu anda ham String belirteçleri bölme için tercih edilen seçim olarak String sınıfından split yöntemini kullanıyorum.

Bu, raw String'i bir String dizisine dönüştürmenin en iyi performans yolu mu? Milyonlarca satırı sıralayacağım, bu yüzden yaklaşımın önemli olduğunu düşünüyorum.

İyi çalışıyor gibi görünüyor ve çok kolay, ama java'da daha hızlı bir yol olup olmadığından emin değilim.

Benim karşılaştırıcıda sıralama şu şekilde çalışır:

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

İster inanın ister inanmayın çeşitli yaklaşımları karşılaştırdıktan sonra, split yöntemi java'nın en son sürümünü kullanan en hızlı yöntemdi. Tamamladığım karşılaştırıcıyı buradan indirebilirsiniz: https://sourceforge.net/projects/multicolumnrowcomparator/

Bunun için hızlı ve kirli bir kıyaslama testi yazdım. Bazıları bölünmekte olan veriler hakkında özel bilgi gerektiren 7 farklı yöntemi karşılaştırır.

Temel genel amaçlı bölme için, Guava Splitter String # split () 'den 3.5x daha hızlıdır ve bunu kullanmanızı tavsiye ederim. Stringtokenizer bundan biraz daha hızlıdır ve indexOf ile bölünmek tekrar iki kat daha hızlıdır.

Kod ve daha fazla bilgi için bkz. Http://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

@Tom'un yazdığı gibi, indexOf türü bir yaklaşım daha hızlıdır String.split(), çünkü ikincisi düzenli ifadelerle ilgilenir ve onlar için çok fazla ek yüke sahiptir.

Ancak, size süper bir hız kazandırabilecek bir algoritma değişikliği. Bu Karşılaştırıcının ~ 100.000 Dizginizi sıralamak için kullanılacağını varsayarak, yazmayın Comparator<String>. Çünkü, sıralamanız sırasında, aynı Dize muhtemelen birden çok kez karşılaştırılacaktır , bu yüzden birden çok kez bölebilirsiniz vb.

Tüm Dizeleri bir kez String [] s'ye bölün ve bir Comparator<String[]>String [] dizisine sahip olun . Sonra, sonunda, hepsini bir araya getirebilirsiniz.

Alternatif olarak, Dize -> Dize [] öğelerini önbelleğe almak için bir Harita da kullanabilirsiniz. örneğin (kabataslak) Ayrıca, hız için bellek ticareti yapıyorsunuz, umarım lotsa RAM'iniz var

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
}

Bu kıyaslamalara göre , StringTokenizer dizeleri bölmek için daha hızlıdır, ancak daha az kullanışlı hale getiren bir dizi döndürmez.

Milyonlarca satırı sıralamanız gerekiyorsa RDBMS kullanmanızı öneririm.

Sekmeyle ayrılmış büyük (1GB +) dosyaları ayrıştırmak için kullandığım yöntem budur. Daha az yükü vardır String.split(), ancak charsınırlayıcı olarak sınırlıdır . Birinin daha hızlı bir yöntemi varsa, görmek isterim. Bu aynı zamanda yapılabilir CharSequenceve CharSequence.subSequenceancak uygulanması gerekir CharSequence.indexOf(char)( String.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)ilgileniyorsa paket yöntemine bakın ).

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