© maxtkm/Shutterstock.com
อาร์เรย์ใน Java ก็เหมือนกับภาษาการเขียนโปรแกรมอื่นๆ เป็นเครื่องมือที่มีประโยชน์อย่างมากสำหรับโปรแกรมเมอร์ในการจัดการและประมวลผลข้อมูลจำนวนมากอย่างมีประสิทธิภาพ หากคุณเคยสงสัยว่าข้อมูลจำนวนมากถูกจัดระเบียบและประมวลผลอยู่เบื้องหลังอย่างไร อาร์เรย์น่าจะเป็นกุญแจไขไปสู่สิ่งนั้น
หากคุณเพิ่งเริ่มเป็น Java Developer ให้คิดให้รอบครอบ รอบ ๆ แนวคิดนามธรรมดังกล่าวอาจดูเหมือนเป็นเรื่องน่าปวดหัว ไม่ต้องกังวลไป เพราะไม่ต้องสงสัยเลยว่าสิ่งเหล่านี้เป็นส่วนสำคัญของการเขียนโปรแกรมใน Java และการเรียนรู้สิ่งเหล่านี้อย่างเชี่ยวชาญจะทำให้คุณเป็นโปรแกรมเมอร์ที่ดีขึ้นโดยรวม ไม่ต้องพูดถึงว่ามันเข้าใจไม่ยากจริงๆ
เมื่อจบบทความนี้ คุณจะมีความเข้าใจที่ชัดเจนเกี่ยวกับอาร์เรย์และพร้อมที่จะมีความเชี่ยวชาญในภาษาจาวา มาเริ่มด้วยการทำความเข้าใจแนวคิดของอาร์เรย์ในการเขียนโปรแกรมก่อน
อาร์เรย์คืออะไรกันแน่
อาร์เรย์คือชุดของรายการข้อมูลซึ่งเป็นประเภทเดียวกันทั้งหมดที่จัดเก็บไว้ใน บล็อกหน่วยความจำที่อยู่ติดกันภายใต้ชื่อตัวแปรเดียว ให้คิดว่าเป็นคอนเทนเนอร์ที่สามารถเก็บค่าประเภทเดียวกันได้หลายค่า เช่น จำนวนเต็ม สตริง หรือแม้แต่วัตถุอื่นๆ
แต่ละค่าในอาร์เรย์ถูกกำหนดดัชนีหรือคีย์เฉพาะ ซึ่งใช้ในการเข้าถึงและจัดการค่า คีย์ช่วยให้โปรแกรมเมอร์สามารถเข้าถึงค่าเฉพาะในอาร์เรย์ได้อย่างง่ายดายโดยไม่ต้องค้นหาผ่านคอลเลกชันทั้งหมด
ในรูปแบบพื้นฐานที่สุดใน Java อาร์เรย์เก็บค่าหลายค่าของประเภทข้อมูลเดียวกัน และองค์ประกอบในอาร์เรย์เข้าถึงได้โดยใช้ดัชนี — คีย์
ดัชนีของ องค์ประกอบแรกในอาร์เรย์จะเป็น 0 เสมอ และดัชนีขององค์ประกอบสุดท้ายคือความยาวของอาร์เรย์ลบด้วยหนึ่งเสมอ อาร์เรย์สามารถเป็นหนึ่งมิติหรือหลายมิติ และสามารถเก็บประเภทข้อมูลดั้งเดิมหรือวัตถุได้
วิธีประกาศ/เริ่มต้นอาร์เรย์ในภาษาจาวา
ในการประกาศอาร์เรย์ คุณต้องระบุประเภทข้อมูลขององค์ประกอบที่จะจัดเก็บไว้ในอาร์เรย์ก่อน ตัวอย่างเช่น ในการประกาศอาร์เรย์จำนวนเต็ม คุณจะใช้ไวยากรณ์ต่อไปนี้:
int[] ตัวเลข;
การประกาศอาร์เรย์จำนวนเต็มที่เรียกว่า “numbers” อย่างไรก็ตาม ในการเริ่มต้นหรือสร้างอินสแตนซ์ของอาร์เรย์ คุณต้องระบุประเภทและจำนวนขององค์ประกอบที่จะเก็บ:
numbers=new int[5];
สิ่งนี้จะเริ่มต้น”ตัวเลข”อาร์เรย์เก็บค่าจำนวนเต็มห้าค่า คุณยังสามารถเริ่มต้นอาร์เรย์ด้วยค่าโดยใช้ไวยากรณ์ต่อไปนี้หากรู้จักองค์ประกอบ:
int[] ตัวเลข={1, 2, 3, 4, 5};
นี่ เริ่มต้นอาร์เรย์”numbers”ด้วยค่า 1, 2, 3, 4 และ 5 คุณยังสามารถใช้การวนซ้ำเพื่อเริ่มต้นอาร์เรย์:
int[] numbers=new int[5];
for (int i=0; i numbers.length; i++) {
numbers[i]=i + 1;
}
เป็นการเริ่มต้นอาร์เรย์”numbers”ด้วยค่า 1, 2, 3, 4 และ 5 โปรดทราบว่าเวลาที่ซับซ้อนของวิธีการเริ่มต้นนี้คือ O(n)
การเข้าถึงและจัดการองค์ประกอบอาร์เรย์
อาร์เรย์ใน Java ช่วยให้คุณ เพื่อเข้าถึงและจัดการองค์ประกอบโดยใช้ดัชนี การสร้างดัชนีเริ่มต้นที่ 0 ซึ่งหมายความว่าองค์ประกอบแรกในอาร์เรย์มีดัชนีเป็น 0 องค์ประกอบที่สองมีดัชนีเป็น 1 เป็นต้น
หากต้องการเข้าถึงองค์ประกอบในอาร์เรย์ คุณสามารถใช้ เครื่องหมายวงเล็บเหลี่ยมเพื่อระบุดัชนี ตัวอย่างเช่น หากคุณมีอาร์เรย์ของจำนวนเต็มชื่อ”numbers”และต้องการเข้าถึงองค์ประกอบที่สามในอาร์เรย์ คุณควรเขียนว่า”numbers[2]”เนื่องจากการจัดทำดัชนีเริ่มต้นที่ 0 ดังนั้นองค์ประกอบที่สามจึงมีดัชนีเท่ากับ 2
คุณยังสามารถจัดการองค์ประกอบอาร์เรย์โดยใช้ดัชนี สมมติว่าคุณต้องการเปลี่ยนค่าขององค์ประกอบโดยกำหนดค่าใหม่ให้กับองค์ประกอบนั้นโดยใช้เครื่องหมายวงเล็บเหลี่ยม โดยใช้ตัวอย่างก่อนหน้าของเรา:
numbers[2]=10;
System.out.println(numbers[2]);//เอาต์พุต: 10
ก่อนอื่นเรากำหนดค่า 10 ให้กับองค์ประกอบที่สามในอาร์เรย์โดยใช้เครื่องหมายวงเล็บเหลี่ยม จากนั้นเราจะพิมพ์ค่าขององค์ประกอบที่สามออกมาเพื่อยืนยันว่าได้เปลี่ยนเป็น 10 แล้ว
เทคนิคการจัดการอาร์เรย์ทั่วไปอีกวิธีหนึ่งคือการเรียงลำดับ คุณสามารถจัดเรียงอาร์เรย์ใน Java โดยใช้วิธี “Arrays.sort()” นี่คือตัวอย่าง:
int[] ตัวเลข={5, 1, 3, 2, 4};
Arrays.sort(numbers);
System.out.println(Arrays.toString(ตัวเลข));//เอาต์พุต: [1, 2, 3, 4, 5]
ที่นี่ เรามีอาร์เรย์ของจำนวนเต็มชื่อ”numbers”ที่มีค่าไม่เรียงลำดับ เราใช้วิธี “Arrays.sort()” เพื่อเรียงลำดับองค์ประกอบจากน้อยไปหามาก จากนั้นเราจะพิมพ์อาร์เรย์ที่จัดเรียงโดยใช้เมธอด “Arrays.toString()”
อาร์เรย์หลายมิติ
จนถึงตอนนี้ เราได้พูดถึงอาร์เรย์หนึ่งมิติไปแล้ว ซึ่งได้แก่ อาร์เรย์ที่มีองค์ประกอบเพียงแถวเดียว อย่างไรก็ตาม Java ยังสนับสนุนอาร์เรย์หลายมิติ ซึ่งเป็นอาร์เรย์ที่มีองค์ประกอบหลายแถวและหลายคอลัมน์ อาร์เรย์หลายมิติมีประโยชน์ในการจัดเก็บและจัดการข้อมูลในรูปแบบตาราง
ในการประกาศอาร์เรย์หลายมิติใน Java คุณต้องระบุจำนวนแถวและคอลัมน์ที่จะมี เช่นเดียวกับ ชนิดข้อมูลขององค์ประกอบที่จะเก็บ ตัวอย่างเช่น หากต้องการประกาศอาร์เรย์จำนวนเต็มสองมิติที่มีสองแถวและสามคอลัมน์ คุณจะต้องใช้ไวยากรณ์ต่อไปนี้:
int[][] matrix=new int[2][3];
สิ่งนี้เริ่มต้นอาร์เรย์สองมิติที่เรียกว่า”เมทริกซ์”โดยมีสองแถวและสามคอลัมน์ แต่ละค่ามีค่าเป็นจำนวนเต็ม คุณยังสามารถเริ่มต้นอาร์เรย์หลายมิติด้วยค่าโดยใช้วงเล็บปีกกาที่ซ้อนกัน พิจารณาสิ่งต่อไปนี้:
int[][] matrix={{1, 2, 3}, {4, 5, 6}};
สิ่งนี้เริ่มต้นอาร์เรย์สองมิติ เรียกว่า “เมทริกซ์” ที่มีสองแถวและสามคอลัมน์ แต่ละค่ามีค่าเป็นจำนวนเต็ม แถวแรกมีค่า 1, 2 และ 3 ในขณะที่แถวที่สองมีค่า 4, 5 และ 6
หากต้องการเข้าถึงองค์ประกอบในอาร์เรย์หลายมิติ คุณต้องใช้แถวขององค์ประกอบนั้น และดัชนีคอลัมน์ ตัวอย่างเช่น หากต้องการเข้าถึงองค์ประกอบในแถวแรกและคอลัมน์ที่สองของอาร์เรย์ “เมทริกซ์” คุณจะต้องเขียน “เมทริกซ์[0][1]” เนื่องจากดัชนีแถวคือ 0 (แถวแรก) และดัชนีคอลัมน์คือ 1 (คอลัมน์ที่สอง)
Arrays vs ArrayLists ใน Java
Arrays และ ArrayLists มีความคล้ายคลึงกันบางประการ แต่ยังมีความแตกต่างที่สำคัญบางอย่างที่อาจส่งผลต่อเวลาและวิธีการใช้งานของคุณ มาดูการเปรียบเทียบระหว่างสองสิ่งนี้กัน
พูดง่ายๆ ก็คือ ArrayList เป็นอาร์เรย์ที่ปรับขนาดได้ซึ่งสามารถเปลี่ยนขนาดได้แบบไดนามิกระหว่างรันไทม์ ซึ่งแตกต่างจากอาร์เรย์แบบดั้งเดิมซึ่งมีความยาวคงที่ซึ่งไม่สามารถเปลี่ยนแปลงได้เมื่อสร้างขึ้นแล้ว
ตอนนี้ มาดูวิธีเริ่มต้น ArrayList:
หมายเลข ArrayList=new ArrayList>();
สิ่งนี้เริ่มต้น ArrayList ที่ว่างเปล่า เราสามารถเพิ่มองค์ประกอบใน ArrayList โดยใช้วิธี add():
numbers.add(1);
numbers.add(2);
numbers.add(3);
เรายังสามารถลบองค์ประกอบออกจาก ArrayList โดยใช้เมธอด remove():
numbers.remove(2);
ในตัวอย่างนี้ เรากำลังลบองค์ประกอบ ที่ดัชนี 2 ซึ่งเป็นหมายเลข 3 หลังจากการดำเนินการนี้ ArrayList จะมีองค์ประกอบที่ 1 และ 2
ประโยชน์ที่สำคัญที่สุดอย่างหนึ่งของการใช้ ArrayLists คือความยืดหยุ่น เนื่องจากสามารถขยายและย่อขนาดได้ตามต้องการ จึงเป็นตัวเลือกที่มีประสิทธิภาพมากกว่าเมื่อต้องจัดการกับข้อมูลจำนวนมาก ในทางตรงกันข้าม อาร์เรย์อาจมีข้อจำกัดมากกว่า เนื่องจากคุณต้องประกาศขนาดของอาร์เรย์ล่วงหน้า
ข้อแตกต่างที่สำคัญอีกประการหนึ่งระหว่างอาร์เรย์และ ArrayLists คือวิธีการนำไปใช้ใน Java อาร์เรย์เป็นชนิดข้อมูลพื้นฐาน หมายความว่าอาร์เรย์มีอยู่ในตัวภาษาเอง ในทางกลับกัน ArrayLists เป็นส่วนหนึ่งของ Java คอลเล็กชัน เฟรมเวิร์ก ซึ่งมีโครงสร้างข้อมูลและอัลกอริทึมที่มีประสิทธิภาพมากมายสำหรับจัดการคอลเลกชันของวัตถุ
อาร์เรย์ vs อาร์เรย์ลิสต์: ข้อดีและข้อเสีย
เนื่องจากความแตกต่างเหล่านี้ แต่ละรายการ โครงสร้างข้อมูลมีข้อดีและข้อเสียในตัวมันเอง ด้านล่างนี้คือข้อควรพิจารณาหลักบางประการในการตัดสินใจว่าจะใช้อาร์เรย์หรือ ArrayList
ประโยชน์ของการใช้อาร์เรย์
รวดเร็วและมีประสิทธิภาพสำหรับ dataMemory จำนวนน้อย เนื่องจากไม่ต้องใช้โอเวอร์เฮด
ข้อเสียของการใช้อาร์เรย์
ขนาดคงที่ หมายความว่าคุณอาจต้องจัดสรรหน่วยความจำมากเกินความจำเป็น หรือจัดสรรหน่วยความจำใหม่หาก ขนาดของการเปลี่ยนแปลงอาร์เรย์อาจเป็นเรื่องยากที่จะทำงานเมื่อต้องรับมือกับข้อมูลจำนวนมากขึ้นไม่สามารถปรับขนาดได้ ซึ่งหมายความว่าคุณต้องสร้างอาร์เรย์ใหม่และคัดลอกองค์ประกอบต่างๆ หากต้องการเปลี่ยนขนาด
ประโยชน์ของการใช้รายการอาร์เรย์
ขนาดไดนามิก ซึ่งช่วยให้ขยายหรือย่อได้ตามต้องการ มีประสิทธิภาพในการจัดการข้อมูลจำนวนมาก สามารถจัดเรียงหรือค้นหาได้ง่ายโดยใช้วิธีการในตัว
ข้อเสียของการใช้ Arraylists
ต้องการหน่วยความจำมากกว่าอาร์เรย์แบบเดิม เนื่องจากจำเป็นต้องเก็บข้อมูลเพิ่มเติมเพื่อปรับขนาดความปลอดภัยของรันไทม์ เนื่องจากประเภทของออบเจกต์ที่จัดเก็บไว้ใน ArrayList สามารถตรวจสอบได้ที่รันไทม์เท่านั้น มีประสิทธิภาพน้อยกว่าอาร์เรย์สำหรับข้อมูลจำนวนน้อย
ดังนั้น หากคุณจัดการกับข้อมูลจำนวนน้อย ข้อมูลและประสิทธิภาพเป็นสิ่งสำคัญ อาร์เรย์อาจเป็นทางเลือกที่ดีกว่า อย่างไรก็ตาม หากคุณต้องการจัดการข้อมูลจำนวนมากหรือต้องการการปรับขนาดแบบไดนามิก ArrayList อาจเป็นตัวเลือกที่ดีกว่า
“Associative Arrays” ใน Java — Maps
Java ทำ ไม่รองรับอาร์เรย์ที่เชื่อมโยง แต่ใช้สิ่งที่คล้ายกันผ่านโครงสร้างข้อมูลแผนที่ แผนผัง เช่น อาร์เรย์ที่เชื่อมโยง คือชุดของคู่คีย์-ค่า โดยที่แต่ละคีย์แม็พกับค่าที่สอดคล้องกัน
แผนที่มีประโยชน์เมื่อคุณต้องการค้นหาค่าตามคีย์เฉพาะ และสามารถนำไปใช้ได้โดยใช้คลาสต่างๆ มากมายใน Java มาดูกันว่าเราจะเริ่มต้นแผนที่โดยใช้คลาส HashMap ได้อย่างไร:
HashMap phoneBook=new HashMap>();
สิ่งนี้เริ่มต้น HashMap ว่างด้วยคีย์ประเภทสตริงและ ค่าประเภทจำนวนเต็ม เราสามารถเพิ่มองค์ประกอบลงในแผนที่โดยใช้เมธอด put():
phoneBook.put(“John”, 1234567890);
phoneBook.put(“Jane”, 2345678901);
ในที่นี้”John”และ”Jane”คือคีย์ และ 1234567890 และ 2345678901 คือค่าที่สอดคล้องกัน เรายังสามารถเข้าถึงค่าในแผนที่โดยใช้คีย์ของมัน:
int johnsPhoneNumber=phoneBook.get(“John”);
ที่นี่ johnsPhoneNumber จะได้รับการกำหนดค่า 1234567890
ข้อดีของการใช้แผนที่
ข้อดีอย่างหนึ่งของการใช้แผนที่บนอาร์เรย์หรือ ArrayList คือคีย์ไม่จำเป็นต้องเป็นจำนวนเต็ม ซึ่งหมายความว่าคุณสามารถใช้อ็อบเจกต์ใดก็ได้เป็นคีย์ ตราบใดที่มันใช้เมธอด equals() และ hashCode() อย่างเหมาะสม ซึ่งช่วยให้คุณสร้างคู่คีย์-ค่าที่กำหนดเองสำหรับโครงสร้างข้อมูลที่ซับซ้อนมากขึ้นได้
แผนที่ยังช่วยให้ค้นหาได้อย่างรวดเร็วตามคีย์ เนื่องจากคีย์ไม่ซ้ำกันในแมป คุณจึงสามารถดึงค่าที่เกี่ยวข้องกับคีย์เฉพาะได้อย่างรวดเร็วโดยไม่ต้องทำซ้ำผ่านโครงสร้างข้อมูลทั้งหมด สิ่งนี้ช่วยเป็นพิเศษเมื่อทำงานกับชุดข้อมูลขนาดใหญ่ที่การเข้าถึงค่าเฉพาะอย่างรวดเร็วเป็นสิ่งสำคัญ
ข้อดีอีกประการของแผนที่คือสามารถใช้เพื่อลดความซับซ้อนของโค้ดในบางสถานการณ์ ตัวอย่างเช่น สมมติว่าเรามีอัลกอริทึมที่นับความถี่ของคำในไฟล์ข้อความ:
Map wordCounts=new HashMap>();
//read in text file
for ( คำสตริง: textFile) {
if (wordCounts.containsKey(word)) {
int count=wordCounts.get(word);
wordCounts.put(word, count + 1);
} อื่น {
wordCounts.put(word, 1);
}
}
ในที่นี้ เรากำลังใช้อาร์เรย์ที่เชื่อมโยงเพื่อติดตามความถี่ของแต่ละคำในข้อความ ไฟล์. ถ้าคำนั้นอยู่ในอาร์เรย์ที่เชื่อมโยงแล้ว เราจะดึงจำนวนปัจจุบันของคำนั้นโดยใช้เมธอด get() เพิ่มจำนวน แล้วใส่จำนวนที่อัปเดตกลับเข้าไปในอาร์เรย์ที่เชื่อมโยง หากคำนั้นยังไม่ได้อยู่ในอาร์เรย์ที่เชื่อมโยง เราจะเพิ่มด้วยจำนวน 1
สรุปง่ายๆ คือแมปโค้ดทำให้โค้ดง่ายขึ้นและช่วยให้ค้นหาค่าได้อย่างมีประสิทธิภาพโดยอิงจากคีย์ที่สอดคล้องกัน หากคุณพบว่าตัวเองจำเป็นต้องค้นหาค่าตามคีย์บ่อยๆ ในขณะที่ทำงานกับชุดข้อมูลขนาดใหญ่ แผนที่จะช่วยให้คุณขจัดงานที่ต้องใช้พื้นฐานจำนวนมากไปได้
บรรทัดล่างสุด
อาร์เรย์เป็นโครงสร้างข้อมูลที่สำคัญใน Java และการฝึกฝนให้เชี่ยวชาญจะช่วยให้เข้าใจถึงพลังที่แท้จริงใน Java ได้ มีประโยชน์หลากหลาย ช่วยให้คุณสร้างอาร์เรย์หนึ่งมิติและหลายมิติที่สามารถเก็บประเภทข้อมูลดั้งเดิมหรือวัตถุได้
ด้วยอาร์เรย์ คุณสามารถเข้าถึงองค์ประกอบต่างๆ โดยใช้ดัชนีและจัดการองค์ประกอบเหล่านั้นได้อย่างง่ายดายผ่านการดำเนินการต่างๆ เช่น การเรียงลำดับ ดังนั้น หากคุณกำลังเรียนรู้ Java และต้องการยกระดับการเขียนโปรแกรมของคุณไปอีกขั้น อาร์เรย์คือวิธีที่แน่นอนในการพาคุณไปที่นั่น
อาร์เรย์ใน Java อธิบายด้วยตัวอย่าง คำถามที่พบบ่อย (คำถามที่พบบ่อย)
คุณจะหาความยาวของอาร์เรย์ใน Java ได้อย่างไร
หากต้องการหาความยาวของอาร์เรย์ใน Java คุณสามารถใช้คุณสมบัติความยาวได้ ตัวอย่างเช่น หากคุณมีอาร์เรย์ชื่อ “myArray” คุณสามารถค้นหาความยาวของอาร์เรย์โดยใช้ไวยากรณ์ต่อไปนี้: “int length=myArray.length;” ซึ่งจะให้จำนวนองค์ประกอบในอาร์เรย์
คุณมีอาร์เรย์ที่มีทั้งประเภทข้อมูลดั้งเดิมและออบเจกต์ใน Java ได้ไหม
ได้ คุณสามารถมีอาร์เรย์ที่มีทั้งประเภทข้อมูลดั้งเดิมและวัตถุใน Java สิ่งนี้เรียกว่าอาร์เรย์ผสม
ตัวอย่างเช่น คุณสามารถสร้างอาร์เรย์ที่มีทั้งจำนวนเต็มและสตริงโดยการประกาศเป็น “Object[] mixedArray={1, 2, “hello”};”
อย่างไรก็ตาม โดยทั่วไปไม่แนะนำให้ใช้อาร์เรย์แบบผสม เนื่องจากอาจใช้งานยากและอาจนำไปสู่ข้อผิดพลาดในการพิมพ์
คุณจะแปลงอาร์เรย์เป็น รายการใน Java หรือไม่
ในการแปลงอาร์เรย์เป็นรายการใน Java คุณสามารถใช้เมธอด Arrays.asList() ถ้าสมมติว่าคุณมีอาร์เรย์ชื่อ “myArray” คุณสามารถแปลงเป็นรายการได้โดยใช้ไวยากรณ์ต่อไปนี้: “รายการ
ความแตกต่างระหว่างอาร์เรย์และ ArrayList ใน Java คืออะไร
ข้อแตกต่างหลักระหว่างอาร์เรย์และ ArrayList ใน Java คือ อาร์เรย์มีความยาวคงที่ซึ่งไม่สามารถเปลี่ยนแปลงได้เมื่อเริ่มใช้งานแล้ว ในขณะที่ ArrayList ปรับขนาดได้และเปลี่ยนขนาดแบบไดนามิกได้ ระหว่างรันไทม์ นอกจากนี้ อาร์เรย์สามารถมีองค์ประกอบของข้อมูลประเภทเดียวเท่านั้น ในขณะที่ ArrayList สามารถมีองค์ประกอบของข้อมูลประเภทใดก็ได้
คุณสามารถเปลี่ยนขนาดของอาร์เรย์เมื่อเริ่มต้นแล้วได้หรือไม่
ไม่ คุณไม่สามารถเปลี่ยนขนาดของอาร์เรย์ได้เมื่อเริ่มต้นแล้ว อาร์เรย์มีความยาวคงที่ซึ่งถูกกำหนดเมื่อสร้างขึ้น
หากคุณต้องการเพิ่มหรือลบองค์ประกอบออกจากอาร์เรย์ คุณจะต้องสร้างอาร์เรย์ใหม่ที่มีขนาดที่ต้องการและคัดลอกองค์ประกอบจาก อาร์เรย์เก่าไปยังอาร์เรย์ใหม่ ตอบ
อีกทางหนึ่ง คุณสามารถใช้ ArrayList ซึ่งปรับขนาดได้และเปลี่ยนขนาดได้แบบไดนามิกระหว่างรันไทม์