คอฟฟี่เบรค #241. วิธีแปลงสตริงเป็นอาร์เรย์ - คำแนะนำโดยละเอียด

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

วิธีการแปลงสตริงให้เป็นอาร์เรย์โดยใช้เมธอด toCharArray()

เมธอดtoCharArray()เป็นฟังก์ชัน Java ในตัวที่ให้คุณแปลงสตริงเป็นอาร์เรย์ของอักขระ และแปลงอักขระแต่ละตัวของสตริงให้เป็นองค์ประกอบของอาร์เรย์ได้ วิธีการ นี้ มีอยู่ใน คลาส String

ไวยากรณ์และการใช้เมธอด toCharArray():

public class StringToArrayExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        // Преобразовать строку в массив символов
        char[] charArray = str.toCharArray();

        // Распечатать элементы массива
        for (char c : charArray) {
            System.out.println(c);
        }
    }
}

คำอธิบายของขั้นตอน:

1. ประกาศตัวแปรสตริงstrและกำหนดสตริงที่ต้องการ
2. ใช้ เมธอด toCharArray()บนสตริงstrเพื่อแปลงเป็นอาร์เรย์อักขระ วิธีนี้จะแยกสตริงออกเป็นอักขระแต่ละตัวและส่งกลับอาร์เรย์ที่มีอักขระเหล่านั้น
3. เก็บอาร์เรย์อักขระผลลัพธ์ไว้ในตัวแปรcharArray
4. วนซ้ำcharArrayโดยใช้for-each loop เพื่อพิมพ์อักขระแต่ละตัวแยกกัน

บทสรุป:

ข้อดีของการใช้ toCharArray():

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

ข้อเสียของการใช้ toCharArray():

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

วิธีการแยกสตริงโดยใช้เมธอด split()

วิธีการsplit()ใน Java เป็นวิธีที่สะดวกในการแยกสตริงออกเป็นอาร์เรย์ของสตริงย่อยตามตัวคั่นที่กำหนด วิธีการ นี้ มีอยู่ใน คลาส String

ไวยากรณ์และการใช้วิธีแยก ():

String[] split(String delimiter)

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

string = "Hello,World,How,Are,You?"
delimiter = ","

split_string = string.split(delimiter)
print(split_string)

คำอธิบายของขั้นตอน:

1. เรากำหนดตัวแปรสตริงที่เรียกว่าstring มีข้อความที่เราต้องการแยกว่า “Hello, World, How, Are, You?”
2. เราระบุตัวคั่นด้วยเครื่องหมายจุลภาค ( , ) ที่เราต้องการใช้เพื่อแยกสตริงและกำหนดให้กับ ตัวแปร ตัวคั่น
3. จากนั้นเราใช้ เมธอด split() กับ ตัวแปรสตริง โดยส่ง ผ่านตัวคั่นเป็นอาร์กิวเมนต์ สิ่งนี้จะแยกสตริงออกเป็นสตริงย่อยทุกที่ที่พบตัวคั่น
4. เมธอดsplit() ส่ง คืนรายการสตริงย่อยซึ่งเรากำหนดให้กับ ตัวแปร split_string
5. ในที่สุด เราก็พิมพ์ รายการ split_stringเพื่อดูผลลัพธ์

บทสรุป:

ข้อดีของการใช้ split():

• สะดวกและใช้งานง่าย
• ช่วยให้คุณสามารถแยกสตริงตามตัวคั่นที่ระบุ
• รองรับนิพจน์ทั่วไปเป็นตัวคั่น โดยมีตัวเลือกตัวคั่นที่ยืดหยุ่น

ข้อเสียของการใช้ split():

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

วิธีแปลงสตริงเป็นอาร์เรย์โดยใช้ StringTokenizer

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

ไวยากรณ์และการใช้ StringTokenizer:

หากต้องการใช้StringTokenizerคุณต้องสร้างอินสแตนซ์ของ คลาส StringTokenizer ก่อน โดยส่งสตริงและตัวคั่นเป็นพารามิเตอร์:

StringTokenizer tokenizer = new StringTokenizer(inputString, delimiter);

รหัสตัวอย่าง:

import java.util.StringTokenizer;

public class StringToArrayExample {
    public static void main(String[] args) {
        String inputString = "Hello,World,How,Are,You?";

        // Creation an object StringTokenizer с разделителем ","
        StringTokenizer tokenizer = new StringTokenizer(inputString, ",");

        int tokenCount = tokenizer.countTokens();
        String[] stringArray = new String[tokenCount];

        // Преобразование каждого токена в элементы массива
        for (int i = 0; i < tokenCount; i++) {
            stringArray[i] = tokenizer.nextToken();
        }

        // Печать выходного массива
        for (String element : stringArray) {
            System.out.println(element);
        }
    }
}

คำอธิบายของขั้นตอน:

1. รหัสเริ่มต้นด้วยการสร้าง วัตถุ StringTokenizerชื่อtokenizerจากสตริงอินพุตและคั่นด้วย " , "
2. วิธีการcountTokens()ใช้เพื่อรับจำนวนโทเค็นทั้งหมดที่มีอยู่ในสตริงอินพุต ค่านี้ถูกจัดเก็บไว้ในตัวแปรtokenCount
3. stringArrayที่ถูกเรียก ถูกสร้าง ขึ้นโดยมีขนาดเท่ากับtokenCount
4. เมธอดnextToken()ถูกใช้ในลูปเพื่อวนซ้ำแต่ละโทเค็นและกำหนดดัชนีที่เกี่ยวข้องในstringArray
5. สุดท้ายfor loop ใช้เพื่อพิมพ์แต่ละองค์ประกอบในไฟล์stringArray

บทสรุป:

แอปพลิเคชัน StringTokenizer

StringTokenizerมีประโยชน์ในหลายสถานการณ์ รวมถึง:

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

ข้อดีของการใช้ StringTokenizer:

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

ข้อเสียของการใช้ StringTokenizer:

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

วิธีแปลงอักขระแต่ละตัวของสตริงเป็นองค์ประกอบอาร์เรย์ด้วยตนเอง

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

string = "Hello, World!"
array = []

for char in string:
    array.append(char)

print(array)

คำอธิบายของขั้นตอน:

1. เรากำหนดสตริงตัวแปรสตริงที่มีค่า"Hello, World!" .
2. เราเริ่มต้นรายการว่างที่เรียกว่าarray
3. เราใช้for loop เพื่อวนซ้ำแต่ละอักขระในstring
4. ภายในลูป เราใช้เมธอดappend()เพื่อผนวกอักขระ แต่ละตัว เข้ากับอาร์เรย์
5. หลังจากการวนซ้ำเสร็จสิ้น เราจะพิมพ์อาร์เรย์เพื่อดูผลลัพธ์

บทสรุป:

ข้อดีของการแปลงด้วยตนเอง:

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

ข้อเสียของการแปลงด้วยตนเอง:

• ต้องใช้โค้ดและการประมวลผลด้วยตนเองมากขึ้นเมื่อเทียบกับวิธีการในตัว เช่นtoCharArray()หรือsplit( )
• อาจมีประสิทธิภาพน้อยกว่าสำหรับสตริงขนาดใหญ่เนื่องจากกระบวนการวนซ้ำด้วยตนเอง
• เพิ่มความเสี่ยงของข้อผิดพลาดหากนำไปใช้อย่างไม่ถูกต้อง

บันทึก. คุณควรเลือกวิธีการแปลงด้วยตนเองถ้าคุณต้องการดำเนินการพิเศษในระหว่างกระบวนการแปลง มิฉะนั้น แนะนำให้ใช้วิธีการในตัว เช่น toCharArray()หรือ split() เพื่อความเรียบง่ายและ มี

เปรียบเทียบวิธีการต่างๆ

toCharArray():

• วิธีที่ง่ายและชัดเจน
• ส่งกลับอาร์เรย์อักขระที่แสดงถึงสตริง
• เหมาะสำหรับการแปลงทั่วไปโดยไม่มีข้อกำหนดพิเศษ

แยก():

• แยกสตริงออกเป็นอาร์เรย์ตามตัวคั่นที่ระบุ
• มีประโยชน์ถ้าคุณต้องการแยกสตริงออกเป็นสตริงย่อย
• ให้ความยืดหยุ่นในการเลือกเทมเพลตตัวคั่น

StringTokenizer:

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

การแปลงด้วยตนเอง:

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

ทำไมคุณต้องรู้วิธีแปลงสตริงเป็นอาร์เรย์ใน Java?

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

• การจัดการข้อมูล อาร์เรย์เป็นวิธีที่มีโครงสร้างในการจัดเก็บและจัดการข้อมูลใน Java ด้วยการแปลงสตริงเป็นอาร์เรย์ คุณสามารถเข้าถึงอักขระแต่ละตัวหรือสตริงย่อย แก้ไขข้อมูล และดำเนินการต่างๆ เช่น การเรียงลำดับ การค้นหา หรือการกรอง
• การดำเนินการอัลกอริทึม อัลกอริธึมและโครงสร้างข้อมูลจำนวนมากใน Java ต้องการอินพุตในรูปแบบของอาร์เรย์ ด้วยการแปลงสตริงเป็นอาร์เรย์ คุณจะสามารถใช้อัลกอริธึมเหล่านี้และดำเนินการต่างๆ เช่น การเรียงลำดับ การย้อนกลับ หรือการเรียกองค์ประกอบเฉพาะได้อย่างง่ายดาย
• การแยกวิเคราะห์และการวิเคราะห์ข้อความ สตริงมักจะมีข้อมูลที่มีโครงสร้างหรือคั่น เช่น CSV (Comma Separated Values) หรือ JSON (JavaScript Object Notation) การแปลงสตริงเป็นอาร์เรย์ทำให้คุณสามารถแยกย่อยและวิเคราะห์ข้อมูล เพื่อให้สามารถวิเคราะห์ ประมวลผล หรือแยกข้อมูลเฉพาะเพิ่มเติมได้
• การจัดการสตริง แม้ว่าสตริงจะมีวิธีการจัดการชุดของตัวเอง แต่อาร์เรย์ก็ให้ความยืดหยุ่นเพิ่มเติม การแปลงสตริงเป็นอาร์เรย์ทำให้คุณสามารถใช้การดำเนินการเฉพาะอาร์เรย์ เช่น การทำดัชนี การแบ่งส่วน หรือการต่อข้อมูล เพื่อจัดการข้อมูลได้อย่างมีประสิทธิภาพมากขึ้น หรือตรงตามข้อกำหนดการจัดรูปแบบบางอย่าง
• ความเข้ากันได้:ในบางสถานการณ์ คุณอาจต้องแปลงสตริงเป็นอาร์เรย์เพื่อโต้ตอบกับไลบรารีหรือ API ที่คาดหวังอินพุตแบบอาร์เรย์ ด้วยการดำเนินการแปลง คุณสามารถรวมข้อมูลสตริงของคุณเข้ากับส่วนประกอบภายนอกได้อย่างง่ายดาย รับประกันความเข้ากันได้และเปิดใช้งานการแลกเปลี่ยนข้อมูลได้อย่างราบรื่น

บทสรุป

ในบทความนี้ เราได้กล่าวถึงวิธีการต่างๆ ในการแปลงสตริงเป็นอาร์เรย์ใน Java คุณได้เรียนรู้เกี่ยวกับสี่วิธีที่แตกต่างกัน: การใช้ เมธอด toCharArray()การแยกสตริงโดยใช้ เมธอด split()การใช้StringTokenizerและการแปลงอักขระแต่ละตัวให้เป็นองค์ประกอบอาร์เรย์ด้วยตนเอง เราได้กล่าวถึงแต่ละวิธีอย่างละเอียด รวมถึงไวยากรณ์ การใช้งาน โค้ดตัวอย่าง ข้อดีและข้อเสีย