ก่อน Java 8เมื่อเราแยกสตริงว่างเช่น

String[] tokens = "abc".split("");

กลไกการแยกจะแยกในสถานที่ที่มีเครื่องหมาย |

|a|b|c|

เนื่องจาก""มีพื้นที่ว่างก่อนและหลังอักขระแต่ละตัว ดังนั้นผลลัพธ์มันจะสร้างอาร์เรย์นี้ในตอนแรก

["", "a", "b", "c", ""]

และต่อมาจะลบสตริงว่างต่อท้าย (เนื่องจากเราไม่ได้ระบุค่าลบให้กับlimitอาร์กิวเมนต์อย่างชัดเจน) ดังนั้นในที่สุดก็จะคืนค่า

["", "a", "b", "c"]

ในกลไกการแบ่งJava 8ดูเหมือนจะเปลี่ยนไป ทีนี้เมื่อเราใช้

"abc".split("")

เราจะได้["a", "b", "c"]อาร์เรย์แทน["", "a", "b", "c"]ดังนั้นดูเหมือนว่าสตริงว่างเมื่อเริ่มต้นจะถูกลบออกไปด้วย แต่ทฤษฎีนี้ล้มเหลวเพราะตัวอย่างเช่น

"abc".split("a")

["", "bc"]ส่งกลับอาร์เรย์กับสตริงที่ว่างเปล่าในช่วงเริ่มต้น

ใครช่วยอธิบายได้ว่าเกิดอะไรขึ้นที่นี่และกฎของการแยกเปลี่ยนไปอย่างไรใน Java 8

พฤติกรรมของString.split(ที่เรียกPattern.split) เปลี่ยนไประหว่าง Java 7 และ Java 8

เอกสารประกอบ

เมื่อเปรียบเทียบระหว่างเอกสารของPattern.splitในJava 7และJava 8เราสังเกตว่ามีการเพิ่มประโยคต่อไปนี้:

เมื่อมีการจับคู่ความกว้างบวกที่จุดเริ่มต้นของลำดับการป้อนข้อมูลแล้วสตริงย่อยชั้นนำที่ว่างเปล่าจะถูกรวมไว้ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์ การจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้น แต่จะไม่สร้างสตริงย่อยชั้นนำที่ว่างเปล่า

ประโยคเดียวกันถูกเพิ่มไปยังString.splitในJava 8เมื่อเทียบกับJava 7

การใช้งานอ้างอิง

ให้เราเปรียบเทียบรหัสของPattern.splitการใช้การอ้างอิงใน Java 7 และ Java 8 รหัสถูกดึงมาจาก grepcode สำหรับเวอร์ชัน 7u40-b43 และ 8-b132

Java 7

public String[] split(CharSequence input, int limit) {
    int index = 0;
    boolean matchLimited = limit > 0;
    ArrayList<String> matchList = new ArrayList<>();
    Matcher m = matcher(input);

    // Add segments before each match found
    while(m.find()) {
        if (!matchLimited || matchList.size() < limit - 1) {
            String match = input.subSequence(index, m.start()).toString();
            matchList.add(match);
            index = m.end();
        } else if (matchList.size() == limit - 1) { // last one
            String match = input.subSequence(index,
                                             input.length()).toString();
            matchList.add(match);
            index = m.end();
        }
    }

    // If no match was found, return this
    if (index == 0)
        return new String[] {input.toString()};

    // Add remaining segment
    if (!matchLimited || matchList.size() < limit)
        matchList.add(input.subSequence(index, input.length()).toString());

    // Construct result
    int resultSize = matchList.size();
    if (limit == 0)
        while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
            resultSize--;
    String[] result = new String[resultSize];
    return matchList.subList(0, resultSize).toArray(result);
}

จาวา 8

public String[] split(CharSequence input, int limit) {
    int index = 0;
    boolean matchLimited = limit > 0;
    ArrayList<String> matchList = new ArrayList<>();
    Matcher m = matcher(input);

    // Add segments before each match found
    while(m.find()) {
        if (!matchLimited || matchList.size() < limit - 1) {
            if (index == 0 && index == m.start() && m.start() == m.end()) {
                // no empty leading substring included for zero-width match
                // at the beginning of the input char sequence.
                continue;
            }
            String match = input.subSequence(index, m.start()).toString();
            matchList.add(match);
            index = m.end();
        } else if (matchList.size() == limit - 1) { // last one
            String match = input.subSequence(index,
                                             input.length()).toString();
            matchList.add(match);
            index = m.end();
        }
    }

    // If no match was found, return this
    if (index == 0)
        return new String[] {input.toString()};

    // Add remaining segment
    if (!matchLimited || matchList.size() < limit)
        matchList.add(input.subSequence(index, input.length()).toString());

    // Construct result
    int resultSize = matchList.size();
    if (limit == 0)
        while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
            resultSize--;
    String[] result = new String[resultSize];
    return matchList.subList(0, resultSize).toArray(result);
}

การเพิ่มโค้ดต่อไปนี้ใน Java 8 จะไม่รวมการจับคู่ความยาวเป็นศูนย์ที่จุดเริ่มต้นของสตริงอินพุตซึ่งจะอธิบายถึงพฤติกรรมข้างต้น

            if (index == 0 && index == m.start() && m.start() == m.end()) {
                // no empty leading substring included for zero-width match
                // at the beginning of the input char sequence.
                continue;
            }

การรักษาความเข้ากันได้

ติดตามพฤติกรรมใน Java 8 ขึ้นไป

เพื่อให้splitทำงานได้อย่างสม่ำเสมอในทุกเวอร์ชันและเข้ากันได้กับพฤติกรรมใน Java 8:

1. หาก regex ของคุณสามารถจับคู่สตริงที่มีความยาวเป็นศูนย์ได้ให้เพิ่ม(?!\A)ที่ส่วนท้ายของ regex และรวม regex ดั้งเดิมไว้ในกลุ่มที่ไม่ได้จับภาพ(?:...)(ถ้าจำเป็น)
2. หาก regex ของคุณไม่สามารถจับคู่สตริงที่มีความยาวเป็นศูนย์ได้คุณไม่จำเป็นต้องทำอะไรเลย
3. หากคุณไม่ทราบว่า regex สามารถจับคู่สตริงที่มีความยาวเป็นศูนย์ได้หรือไม่ให้ทำทั้งสองอย่างในขั้นตอนที่ 1

(?!\A) ตรวจสอบว่าสตริงไม่ได้สิ้นสุดที่จุดเริ่มต้นของสตริงซึ่งหมายความว่าการจับคู่เป็นการจับคู่ว่างที่จุดเริ่มต้นของสตริง

พฤติกรรมต่อไปนี้ใน Java 7 และก่อนหน้า

ไม่มีวิธีแก้ปัญหาทั่วไปที่จะทำให้splitเข้ากันได้กับ Java 7 และรุ่นก่อนหน้าโดยไม่ต้องแทนที่อินสแตนซ์ทั้งหมดsplitเพื่อชี้ไปที่การนำไปใช้งานที่คุณกำหนดเอง

สิ่งนี้ได้ระบุไว้ในเอกสารของsplit(String regex, limit).

เมื่อมีการจับคู่ความกว้างเชิงบวกที่จุดเริ่มต้นของสตริงนี้สตริงย่อยชั้นนำที่ว่างเปล่าจะรวมอยู่ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์ การจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้น แต่จะไม่สร้างสตริงย่อยชั้นนำที่ว่างเปล่า

ใน"abc".split("")คุณมีการจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้นดังนั้นสตริงย่อยว่างชั้นนำจึงไม่รวมอยู่ในอาร์เรย์ผลลัพธ์

อย่างไรก็ตามในส่วนย่อยที่สองของคุณเมื่อคุณแยก"a"คุณมีการจับคู่ความกว้างเชิงบวก (1 ในกรณีนี้) ดังนั้นสตริงย่อยนำหน้าว่างจึงรวมอยู่ตามที่คาดไว้

(ลบซอร์สโค้ดที่ไม่เกี่ยวข้องออก)

มีการเปลี่ยนแปลงเล็กน้อยในเอกสารสำหรับsplit()จาก Java 7 เป็น Java 8 โดยเฉพาะมีการเพิ่มคำสั่งต่อไปนี้:

เมื่อมีการจับคู่ความกว้างเชิงบวกที่จุดเริ่มต้นของสตริงนี้สตริงย่อยชั้นนำที่ว่างเปล่าจะรวมอยู่ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์ การจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้น แต่จะไม่สร้างสตริงย่อยชั้นนำที่ว่างเปล่า

^{(เน้นเหมือง)}

การแยกสตริงว่างจะสร้างการจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้นดังนั้นสตริงว่างจะไม่รวมอยู่ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์ตามที่ระบุไว้ข้างต้น ในทางตรงกันข้ามตัวอย่างที่สองของคุณที่แยกออก"a"จะสร้างการจับคู่ความกว้างบวกที่จุดเริ่มต้นของสตริงดังนั้นในความเป็นจริงสตริงว่างจะรวมอยู่ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์