วิธีที่เร็วที่สุดในการแยกสตริงแบบมีตัวคั่นใน Java

ฉันกำลังสร้างเครื่องมือเปรียบเทียบที่ให้ความสามารถในการจัดเรียงหลายคอลัมน์ในสตริงแบบมีตัวคั่น ขณะนี้ฉันกำลังใช้วิธีการแยกจากคลาส String เป็นตัวเลือกที่ฉันต้องการสำหรับการแยกสตริงดิบเป็นโทเค็น

นี่เป็นวิธีที่มีประสิทธิภาพดีที่สุดในการแปลงสตริงดิบเป็นอาร์เรย์สตริงหรือไม่ ฉันจะเรียงลำดับแถวนับล้านดังนั้นฉันคิดว่าวิธีการที่สำคัญ

ดูเหมือนว่าจะทำงานได้ดีและง่ายมาก แต่ไม่แน่ใจว่ามีวิธีที่เร็วกว่าใน java

นี่คือวิธีการเรียงลำดับใน Comparator ของฉัน:

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

หลังจากทำการเปรียบเทียบวิธีการต่าง ๆ เชื่อหรือไม่วิธีการแยกเป็นวิธีที่เร็วที่สุดโดยใช้จาวารุ่นล่าสุด คุณสามารถดาวน์โหลดเครื่องมือเปรียบเทียบที่สมบูรณ์ได้ที่นี่: https://sourceforge.net/projects/multicolumnrowcomparator/

ฉันได้เขียนแบบทดสอบเกณฑ์มาตรฐานที่รวดเร็วและสกปรกสำหรับสิ่งนี้ มันเปรียบเทียบ 7 วิธีที่แตกต่างกันซึ่งบางอย่างต้องการความรู้เฉพาะของข้อมูลที่ถูกแบ่ง

สำหรับการแยกวัตถุประสงค์ทั่วไปขั้นพื้นฐาน Guava Splitter นั้นเร็วกว่าการแยกสตริง # 3.5 () และฉันขอแนะนำให้ใช้ Stringtokenizer เร็วกว่านั้นเล็กน้อยและแยกตัวเองด้วย indexOf เร็วขึ้นเป็นสองเท่า

สำหรับรหัสและข้อมูลเพิ่มเติมดูhttp://demeranville.com/battle-of-the-tokenizers-delimited-text-parser-performance/

ดังที่ @Tom เขียนวิธีการชนิด indexOf นั้นเร็วกว่าString.split()เนื่องจากหลังนั้นเกี่ยวข้องกับนิพจน์ทั่วไปและมีค่าใช้จ่ายเพิ่มเติมเป็นจำนวนมากสำหรับพวกเขา

อย่างไรก็ตามการเปลี่ยนแปลงอัลกอริทึมหนึ่งที่อาจทำให้คุณมีความเร็วมากขึ้น สมมติว่าเปรียบเทียบนี้จะถูกนำมาใช้ในการจัดเรียง ~ 100,000 Strings Comparator<String>ของคุณไม่ได้เขียน เพราะในการเรียงลำดับของคุณสตริงที่เหมือนกันอาจจะถูกเปรียบเทียบหลายครั้งดังนั้นคุณจะแยกมันหลายครั้ง ฯลฯ

แยกสตริงทั้งหมดหนึ่งครั้งเป็นสตริง [] s และComparator<String[]>เรียงลำดับสตริง [] จากนั้นในตอนท้ายคุณสามารถรวมทั้งหมดเข้าด้วยกัน

หรือคุณสามารถใช้แผนที่เพื่อแคชสตริง -> สตริง [] หรือในทางกลับกัน เช่น (ร่าง) นอกจากนี้ยังทราบว่าคุณกำลังซื้อขายหน่วยความจำสำหรับความเร็วหวังว่าคุณจะมี 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
}

ตามมาตรฐานนี้ StringTokenizer จะเร็วกว่าสำหรับการแยกสตริง แต่มันจะไม่ส่งกลับอาร์เรย์ซึ่งทำให้สะดวกน้อยลง

หากคุณต้องการเรียงลำดับแถวเป็นล้าน ๆ แถวฉันขอแนะนำให้ใช้ RDBMS

นี่เป็นวิธีที่ฉันใช้ในการแยกวิเคราะห์ไฟล์ที่มีตัวคั่นขนาดใหญ่ (1GB +) มันมีค่าใช้จ่ายน้อยกว่าString.split()มาก แต่ถูก จำกัด ให้charเป็นตัวคั่น หากใครมีวิธีที่เร็วกว่านี้ฉันอยากจะเห็นมัน สิ่งนี้สามารถทำได้CharSequenceและCharSequence.subSequenceต้องดำเนินการCharSequence.indexOf(char)(อ้างถึงวิธีการแพคเกจString.indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)ถ้าสนใจ)

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