วิธีการ Java String.split()

พูดคุยเกี่ยวกับ เมธอด String.split ของ Java : มันทำอะไรและทำไมมันถึงจำเป็น ไม่ยากที่จะเดาว่ามันแยกสตริง Java แต่ในทางปฏิบัติแล้วทำงานอย่างไร มาเจาะลึกการทำงานของวิธีการและหารือเกี่ยวกับรายละเอียดที่ไม่ชัดเจน ในขณะเดียวกัน เราจะได้เรียนรู้ว่าสตริงมีวิธีการแยก จริง ๆ กี่วิธี ไปกันเถอะ!

คำอธิบายและลายเซ็นสำหรับ String.split ของ Java

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

String[] split(String regex)

สองสิ่งที่ชัดเจนจากลายเซ็น:

1. เมธอดส่งคืนอาร์เรย์ของสตริง
2. เมธอดมีพารามิเตอร์อินพุตสตริงที่เรียกว่าregex

ให้เราวิเคราะห์แต่ละรายการแยกกันเมื่อเราแจกแจงรายละเอียดที่ให้ไว้ข้างต้น

1. เมธอดส่งคืนอาร์เรย์ของสตริง

   การประกาศประกอบด้วยคำต่อไปนี้: "ใน Java วิธี การแยกจะแยกสตริงออกเป็นสตริงย่อย" เมธอดรวบรวมสตริงย่อยเหล่านี้เป็นอาร์เรย์ที่กลายเป็นค่าส่งคืน

2. เมธอดมีพารามิเตอร์อินพุตสตริงที่เรียกว่าregex

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

การแบ่งของ Java ในทางปฏิบัติ

ตอนนี้เรามาเข้าใกล้ประเด็นมากขึ้น ลองจินตนาการว่าเรามีคำศัพท์ ตัวอย่างเช่น: เราต้องแยกสตริงเป็นคำ เราเห็นว่าคำในสตริงนี้แยกออกจากกันด้วยช่องว่าง ในกรณีนี้ อักขระเว้นวรรคเป็นตัวเลือกที่สมบูรณ์แบบสำหรับตัวคั่นของเรา รหัสสำหรับการแก้ปัญหาของเราจะมีลักษณะดังนี้:

public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

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

ตัวคั่นนำ

นี่เป็นอีกหนึ่งความแตกต่างที่สำคัญ หากสตริงเดิมเริ่มต้นด้วยตัวคั่น องค์ประกอบแรกของอาร์เรย์ผลลัพธ์จะเป็นสตริงว่าง ตัวอย่างเช่น จะมีลักษณะดังนี้: สตริงต้นฉบับ: " I love Java" ตัวคั่น: " " อาร์เรย์ผลลัพธ์: { "", "I", "love", "Java" } แต่ถ้าสตริงดั้งเดิมลงท้ายด้วยตัวคั่นแทน กว่าเริ่มต้นด้วยหนึ่ง ผลลัพธ์จะแตกต่างออกไป: สตริงต้นฉบับ: "I love Java" ตัวคั่น: " " อาร์เรย์ผลลัพธ์: { "I", "love", "Java"

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

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

พี่น้องล้นมือ

คลาสStringมี วิธี การแยก อื่น ด้วยลายเซ็นต่อไปนี้:

String[] split(String regex, int limit)

เมธอดนี้มี พารามิเตอร์ จำกัด เพิ่มเติม ซึ่งจะกำหนดจำนวนครั้งที่ รูปแบบ regexจะถูกนำไปใช้กับสตริงเดิม ดูคำอธิบายด้านล่าง:

ขีด จำกัด > 0

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

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

ขีดจำกัด < 0

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

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

ขีด จำกัด = 0

เช่นเดียวกับกรณีที่ขีดจำกัด < 0 รูปแบบตัวคั่นจะถูกนำไปใช้กับสตริงมากที่สุดเท่าที่จะเป็นไปได้ อาร์เรย์สุดท้ายสามารถมีความยาวเท่าใดก็ได้ หากองค์ประกอบสุดท้ายเป็นสตริงว่าง องค์ประกอบเหล่านี้จะถูกละทิ้งจากอาร์เรย์สุดท้าย ตัวอย่าง:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

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

public String[] split(String regex) {
    return split(regex, 0);
}

ตัวอย่างต่างๆ

ในทางปฏิบัติในโลกแห่งความเป็นจริง บางครั้งมันเกิดขึ้นที่เรามีสตริงที่สร้างขึ้นตามกฎบางอย่าง สตริงดังกล่าวอาจเข้ามาในโปรแกรมของเราได้จากทุกที่:

• จากบริการของบุคคลที่สาม
• จากคำขอที่ส่งไปยังเซิร์ฟเวอร์ของเรา
• จากไฟล์คอนฟิกูเรชัน
• และอื่น ๆ

ในสถานการณ์เหล่านี้ โปรแกรมเมอร์มักจะรู้ "กฎของเกม" สมมติว่าโปรแกรมเมอร์รู้ว่าเขาหรือเธอกำลังจัดการกับข้อมูลผู้ใช้ที่จัดเก็บตามรูปแบบนี้: ลองใช้ค่าเฉพาะบางอย่างเป็นตัวอย่าง: สมมติว่างานของโปรแกรมเมอร์คือการเขียนเมธอดที่ส่งอีเมลถึงผู้ใช้ โปรแกรมเมอร์สามารถเข้าถึงข้อมูลผู้ใช้ซึ่งบันทึกในรูปแบบที่ระบุข้างต้น งานย่อยที่เราจะวิเคราะห์ต่อไปคือวิธีแยกที่อยู่อีเมลออกจากข้อมูลผู้ใช้ที่เหลือ นี่เป็นตัวอย่างหนึ่งที่ วิธี การแยกจะมีประโยชน์ ท้ายที่สุด หากเราดูที่เทมเพลตข้อมูลผู้ใช้ เราจะพบว่าการแยกที่อยู่อีเมลของผู้ใช้ออกจากส่วนที่เหลือทำได้ง่ายเหมือนกับการเรียกวิธีการแยกเพื่อแยกสตริง จากนั้นที่อยู่อีเมลจะอยู่ในองค์ประกอบสุดท้ายของอาร์เรย์ผลลัพธ์ ต่อไปนี้เป็นตัวอย่างของวิธีการที่รับสตริงที่มีข้อมูลผู้ใช้และส่งกลับที่อยู่อีเมลของผู้ใช้ เพื่อความง่าย สมมติว่าสตริงข้อมูลอยู่ในรูปแบบที่เราต้องการเสมอ:

public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}

สังเกตตัวคั่น: "\\|" . ในนิพจน์ทั่วไป "|" เป็นอักขระพิเศษที่มีความหมายพิเศษ ดังนั้นหากเราต้องการใช้อักขระธรรมดา (เช่น สิ่งที่เราต้องการหาในสตริงเดิม) เราจะต้องหลีกอักขระด้วยเครื่องหมายแบ็กสแลชสองตัว ลองพิจารณาตัวอย่างอื่น สมมติว่าเรามีข้อมูลการสั่งซื้อที่มีโครงสร้างดังนี้: หรือเราสามารถใช้ค่าเฉพาะบางอย่าง: งานของเราคือการคำนวณต้นทุนรวมของการสั่งซื้อ ที่นี่เราจะต้องใช้ วิธี การแยกหลายครั้ง ขั้นตอนแรกคือการแยกสตริงโดยใช้ ";" เป็นตัวคั่นเพื่อแยกออกเป็นส่วนๆ จากนั้นสตริงย่อยที่เป็นผลลัพธ์แต่ละรายการจะเก็บข้อมูลเกี่ยวกับผลิตภัณฑ์แยกต่างหาก ซึ่งเราสามารถดำเนินการได้ในภายหลัง จากนั้นสำหรับแต่ละผลิตภัณฑ์ เราจะแยกข้อมูลที่สอดคล้องกันโดยใช้สัญลักษณ์ "," เราจะนำองค์ประกอบที่มีดัชนีเฉพาะ (ดัชนีที่เก็บราคาสินค้า) จากอาร์เรย์สตริงที่เป็นผลลัพธ์ แปลงเป็นรูปแบบตัวเลข และรวมต้นทุนรวมของคำสั่งซื้อ ลองเขียนวิธีการที่จะคำนวณทั้งหมดนี้:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}

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

สรุป

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

• ตัวคั่นนำ;
• พี่น้องที่โอเวอร์โหลดด้วยสองพารามิเตอร์

นอกจากนี้เรายังพยายามสร้างแบบจำลองสถานการณ์ในชีวิตจริงที่เราใช้ วิธี แยกเพื่อแก้ปัญหาสมมุติฐาน แต่ค่อนข้างสมจริง