วิธีการแยกใน Java: แบ่งสตริงออกเป็นส่วน ๆ

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

คำจำกัดความและลายเซ็นต์สำหรับ Java String.split

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

String[] split(String regex)

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

1. วิธีการส่งกลับอาร์เรย์ของสตริง
2. วิธีการใช้ สตริง regexเป็นพารามิเตอร์

ลองดูที่แต่ละสิ่งแยกกันในแง่ของคำจำกัดความที่ให้ไว้ข้างต้น

1. วิธีการส่งกลับอาร์เรย์ของสตริง

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

2. วิธีการใช้ สตริง regexเป็นพารามิเตอร์

   โปรดจำคำจำกัดความอีกครั้ง: “แยกสตริงออกเป็นสตริงย่อยโดยใช้ตัวคั่นที่ระบุโดยใช้นิพจน์ทั่วไป” พารามิเตอร์ regexที่ยอมรับคือรูปแบบนิพจน์ทั่วไปที่ใช้กับสตริงต้นทาง และตรงกับอักขระตัวคั่น (หรืออักขระผสมกัน) ในสตริงต้นทาง

แยกในทางปฏิบัติ

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

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

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

ตัวคั่นนำหน้า

มีความแตกต่างที่สำคัญอีกประการหนึ่ง หากสตริงต้นทางเริ่มต้นด้วยตัวคั่น องค์ประกอบแรกของอาร์เรย์ผลลัพธ์จะเป็นสตริงว่าง ในตัวอย่าง จะมีลักษณะดังนี้: สตริงต้นทาง: "ฉันรัก Java" ตัวคั่น: " " อาร์เรย์ผลลัพธ์: { "" , "I" , "love" , "Java" } แต่ถ้าสตริงต้นทางลงท้ายด้วยตัวคั่น และไม่เริ่มต้น ผลลัพธ์จะแตกต่างออกไป: สตริงแหล่งที่มา: ตัวคั่น "ฉันรัก 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) {
        // Notice the space at the end of the line
        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, ]

        Note that the last element of the array is
        an empty string, resulting from the space
        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) {
        // Notice the space at the end of the line
        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));
    }
}

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

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, 20.05; 2, tomatoes, 123.45; 3, hares, 0.50";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 144.0
    }

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

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

ผลลัพธ์

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

• อักขระตัวคั่นนำหน้า
• พี่ชายล้นหลามด้วยการโต้แย้งสองข้อ

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