คู่มือฉบับสมบูรณ์: Java List (ArrayList, LinkedList) ตั้งแต่พื้นฐานถึงขั้นสูง

1. บทนำ

ความสำคัญของ List ใน Java คืออะไร?

ในการเขียนโปรแกรม Java, “List” เป็นโครงสร้างข้อมูลที่พบได้บ่อยมาก โดยเฉพาะอย่างยิ่งในสถานการณ์ที่ต้องการจัดการค่าหลายๆ ค่ารวมกัน มันมีความยืดหยุ่นและใช้งานง่ายกว่า Array จึงเป็นที่นิยมอย่างแพร่หลายในวงการ.

“List” เป็นอินเตอร์เฟสหลักที่อยู่ใน Java Collections Framework และมีกลไกที่พร้อมรองรับสถานการณ์ต่างๆ ผ่านคลาสที่นำไปใช้งาน (Implementation Classes) ที่หลากหลาย เช่น ArrayList และ LinkedList การที่สามารถดำเนินการเพิ่ม ลบ ค้นหา และอัปเดตข้อมูลได้อย่างตรงไปตรงมา ก็เป็นอีกเหตุผลหนึ่งที่ทำให้ List ได้รับการยอมรับ.

วัตถุประสงค์ของบทความนี้และกลุ่มผู้อ่าน

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

• ผู้ที่เพิ่งเริ่มต้นเรียน Java และไม่แน่ใจวิธีการใช้งาน List
• ผู้ที่ต้องการเข้าใจความแตกต่างระหว่าง Array และ List อย่างชัดเจน
• ผู้ที่กำลังสับสนว่าจะเลือกใช้ ArrayList หรือ LinkedList
• ผู้ที่ต้องการทบทวนพื้นฐานการใช้งาน List ในการทำงานจริง

เมื่ออ่านบทความนี้จบลง คุณจะมีความเข้าใจแนวคิดพื้นฐาน วิธีการนำไปใช้ และการดำเนินการต่างๆ เกี่ยวกับ List ใน Java อย่างถ่องแท้ และสามารถเขียนโค้ดได้อย่างมั่นใจ

ในบทต่อไป เราจะเริ่มอธิบายจากส่วนพื้นฐานคือ “List คืออะไร?” ตามลำดับ

2. List คืออะไร?

ภาพรวมและคุณสมบัติของ List

“List” ใน Java เป็นอินเตอร์เฟสของคอลเลกชันที่เก็บองค์ประกอบโดยมีลำดับ คุณสมบัติที่สำคัญที่สุดคือ ลำดับการเพิ่มองค์ประกอบจะถูกรักษาไว้ และ สามารถเข้าถึงองค์ประกอบแต่ละรายการได้โดยใช้ดัชนี (Index) ซึ่งเริ่มต้นจาก 0

List ถูกจัดเตรียมไว้เป็นส่วนหนึ่งของ Collections Framework และมีฟังก์ชันดังต่อไปนี้:

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

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

ความแตกต่างกับ Array

ใน Java, Array (เช่น int[] หรือ String[]) ก็เป็นวิธีการเก็บค่าหลายๆ ค่าเช่นกัน แต่มีความแตกต่างกับ List ในหลายประการ

ดังที่เห็น List เป็นคอลเลกชันที่มีความยืดหยุ่นและฟังก์ชันมากกว่า จึงมีประโยชน์ในทางปฏิบัติมากกว่า Array ในหลายๆ สถานการณ์

อินเตอร์เฟส List และคลาสที่นำไปใช้งาน

เมื่อใช้ List ใน Java โดยทั่วไปแล้ว จะประกาศตัวแปรโดยใช้อินเตอร์เฟส List และสร้าง Instance ด้วยคลาสที่เฉพาะเจาะจง (Implementation Class) คลาสที่นำไปใช้งานที่สำคัญมีดังนี้:

• ArrayList
  มีโครงสร้างคล้าย Array สามารถเข้าถึงได้อย่างรวดเร็ว เหมาะสำหรับการค้นหาข้อมูลและการเข้าถึงแบบสุ่ม (Random Access)
• LinkedList
  แต่ละองค์ประกอบจะเชื่อมโยงกับองค์ประกอบก่อนหน้าและถัดไป การแทรกและลบทำได้รวดเร็ว เหมาะสำหรับ List ที่มีการดำเนินการบ่อยๆ
• Vector
  คล้ายกับ ArrayList แต่เป็น Thread-Safe ซึ่งทำให้ทำงานช้ากว่าเล็กน้อย ปัจจุบันไม่ค่อยนิยมใช้

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

3. วิธีการใช้งาน List พื้นฐาน

เราจะอธิบายการดำเนินการพื้นฐานในการใช้ List ใน Java ทีละขั้นตอน โดยจะใช้ ArrayList เป็นตัวอย่างหลักและแนะนำการดำเนินการที่สำคัญของ List

การประกาศและการกำหนดค่าเริ่มต้น (Initialization) ของ List

เริ่มต้นด้วยการประกาศและการกำหนดค่าเริ่มต้นของ List โดยใช้ ArrayList

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
    }
}

โดยทั่วไป จะประกาศตัวแปรด้วยอินเตอร์เฟส List และสร้าง Instance ด้วย ArrayList ใช้ Generics เพื่อระบุชนิดข้อมูลที่จะจัดเก็บ (ในที่นี้คือ String)

การเพิ่มองค์ประกอบ (add)

ในการเพิ่มองค์ประกอบลงใน List ใช้เมธอด add()

fruits.add("แอปเปิ้ล");
fruits.add("กล้วย");
fruits.add("ส้ม");

ด้วยวิธีนี้ องค์ประกอบทั้ง 3 จะถูกเพิ่มเข้าไปใน List ตามลำดับ List จะรักษาลำดับการเพิ่ม

การดึงองค์ประกอบ (get)

ในการดึงองค์ประกอบที่ดัชนีที่ระบุ ใช้ get(int index)

System.out.println(fruits.get(0)); // แสดง "แอปเปิ้ล"

โปรดทราบว่าดัชนีเริ่มต้นจาก 0

การอัปเดตองค์ประกอบ (set)

หากต้องการอัปเดตองค์ประกอบที่ตำแหน่งใดตำแหน่งหนึ่ง ใช้ set(int index, E element)

fruits.set(1, "องุ่น"); // องค์ประกอบที่ 2 "กล้วย" จะถูกแทนที่ด้วย "องุ่น"

การลบองค์ประกอบ (remove)

สามารถลบองค์ประกอบที่ดัชนีที่ระบุ หรือลบองค์ประกอบนั้นๆ ได้

fruits.remove(0);           // ลบองค์ประกอบแรก
fruits.remove("ส้ม");   // ลบ "ส้ม" (เฉพาะรายการแรกที่ตรงกัน)

การดึงขนาดของ List (size)

จำนวนองค์ประกอบปัจจุบัน สามารถดึงได้ด้วยเมธอด size()

System.out.println(fruits.size()); // จะคืนค่าเป็น 2 หรืออื่นๆ

การตรวจสอบว่ามีองค์ประกอบอยู่หรือไม่ (contains)

ในการตรวจสอบว่า List มีองค์ประกอบที่ระบุอยู่หรือไม่ ใช้ contains()

if (fruits.contains("องุ่น")) {
    System.out.println("มีองุ่นอยู่");
}

สรุป: รายการการดำเนินการพื้นฐานที่ใช้บ่อย

4. ตัวอย่างการดำเนินการกับ List

ในบทนี้ จะนำเสนอตัวอย่างการดำเนินการจริงโดยใช้ List ใน Java สถานการณ์ที่ต้องการประมวลผลองค์ประกอบใน List ตามลำดับนั้นมีอยู่บ่อยมาก ในที่นี้จะกล่าวถึงวิธีการทั่วไปโดยใช้ for loop, Enhanced for loop และ Stream API

การวนซ้ำด้วย for loop

วิธีพื้นฐานที่สุดคือการวนซ้ำเพื่อดึงองค์ประกอบโดยใช้ดัชนีด้วย for loop

List<String> fruits = new ArrayList<>();
fruits.add("แอปเปิ้ล");
fruits.add("กล้วย");
fruits.add("ส้ม");

for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

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

การวนซ้ำด้วย Enhanced for loop (for-each)

หากต้องการประมวลผลองค์ประกอบทั้งหมดตามลำดับโดยไม่ต้องสนใจดัชนี Enhanced for loop จะสะดวก

for (String fruit : fruits) {
    System.out.println(fruit);
}

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

การวนซ้ำด้วย Lambda Expression และ Stream API

ตั้งแต่ Java 8 เป็นต้นมา ยังสามารถเขียนโดยใช้ Stream API และ Lambda Expression ได้อีกด้วย

fruits.stream().forEach(fruit -> System.out.println(fruit));

ข้อดีของการเขียนแบบนี้คือ สามารถเชื่อมโยงการประมวลผลหลายอย่างเข้าด้วยกันได้ ตัวอย่างเช่น สามารถกรองตามเงื่อนไขที่กำหนดแล้วค่อยแสดงผลออกมาได้อย่างง่ายดาย

fruits.stream()
      .filter(fruit -> fruit.contains("ん"))
      .forEach(System.out::println);

ในตัวอย่างนี้ จะแสดงเฉพาะผลไม้ที่มีตัว “ん” (น) อยู่ ขอแนะนำเป็นพิเศษสำหรับผู้ที่ต้องการคุ้นเคยกับการเขียนโค้ดในรูปแบบ Functional Style

การเลือกใช้วิธีการต่างๆ

5. ความแตกต่างและการเลือกใช้ ArrayList และ LinkedList

ในฐานะคลาสสำคัญที่นำอินเตอร์เฟส List ของ Java ไปใช้งาน มีทั้ง ArrayList และ LinkedList ทั้งสองสามารถใช้งานเหมือน List ได้ แต่มีความแตกต่างกันในโครงสร้างภายในและลักษณะประสิทธิภาพ ดังนั้นจึงสำคัญที่จะเลือกใช้ให้เหมาะสมกับสถานการณ์

คุณสมบัติและกรณีที่เหมาะสมของ ArrayList

ArrayList ใช้ Dynamic Array (Array ที่มีความยาวผันแปรได้) ภายใน

คุณสมบัติหลัก:

• การเข้าถึงแบบสุ่ม (ระบุดัชนี) ทำได้รวดเร็วมาก
• การเพิ่มองค์ประกอบ ทำได้รวดเร็วหากเป็นการเพิ่มที่ท้ายสุดของ List (เฉลี่ย O(1))
• การแทรกหรือลบที่ตำแหน่งกลางจะช้าลง (O(n))

กรณีที่เหมาะสม:

• สถานการณ์ที่มีการค้นหาบ่อย (get())
• สถานการณ์ที่สามารถคาดการณ์จำนวนองค์ประกอบล่วงหน้าได้ในระดับหนึ่ง
• การประมวลผลที่เน้นการอ่านข้อมูล มีการเพิ่ม/ลบองค์ประกอบน้อย

List<String> list = new ArrayList<>();

คุณสมบัติและกรณีที่เหมาะสมของ LinkedList

LinkedList นำไปใช้งานด้วยโครงสร้างแบบ Doubly Linked List

คุณสมบัติหลัก:

• การเพิ่ม/ลบองค์ประกอบทำได้รวดเร็ว (โดยเฉพาะที่หัวหรือท้าย)
• การเข้าถึงแบบสุ่ม (get(index)) ทำได้ช้า (O(n))
• มีการใช้หน่วยความจำมากกว่า ArrayList เล็กน้อย

กรณีที่เหมาะสม:

• สถานการณ์ที่มีการแทรก/ลบองค์ประกอบบ่อย (โดยเฉพาะที่หัวหรือกลาง)
• กรณีที่ต้องการใช้งานเหมือน Queue หรือ Stack
• กรณีที่เน้นการวนซ้ำ (Iteration) และไม่ต้องการเข้าถึงด้วยดัชนี

List<String> list = new LinkedList<>();

การเปรียบเทียบประสิทธิภาพ

ตารางด้านล่างแสดงถึงความซับซ้อนทางทฤษฎี (ในรูปแบบ Big O Notation) สำหรับการดำเนินการที่ใช้บ่อย

※ เวลาในการประมวลผลจริงได้รับผลกระทบจากขนาดข้อมูล การปรับปรุงประสิทธิภาพของ JVM และปัจจัยอื่นๆ ด้วย

ข้อควรพิจารณาในการเลือกใช้ในการทำงานจริง

• หาก “จัดการข้อมูลเป็นรายการ และเข้าถึงด้วยดัชนี” ควรใช้ ArrayList
• หาก “มีการแทรก/ลบที่หัวหรือตำแหน่งกลางบ่อย” ควรใช้ LinkedList
• ในการประมวลผลที่ประสิทธิภาพมีความสำคัญมาก ควรทดสอบโดยการทำ Benchmark เสมอ

6. การใช้งาน List แบบขั้นสูง

ในที่นี้จะแนะนำเทคนิคการประยุกต์ใช้เพื่อให้การใช้ List ใน Java สะดวกยิ่งขึ้น List ไม่ใช่แค่กลุ่มข้อมูลเท่านั้น แต่ยังสามารถประมวลผลที่หลากหลายผ่านการจัดเรียง (Sort), การสลับ (Shuffle), การกรอง (Filter), การแปลง (Transform) เป็นต้น

การจัดเรียง List (Collections.sort)

เมื่อใช้ Collections.sort() สามารถจัดเรียงองค์ประกอบใน List ตามลำดับจากน้อยไปมากได้ องค์ประกอบนั้นจะต้อง implement อินเตอร์เฟส Comparable

import java.util.*;

List<String> fruits = new ArrayList<>();
fruits.add("กล้วย");
fruits.add("แอปเปิ้ล");
fruits.add("ส้ม");

Collections.sort(fruits);

System.out.println(fruits); // [ส้ม, แอปเปิ้ล, กล้วย]

กรณีที่ต้องการจัดเรียงตามลำดับที่กำหนดเอง (ใช้ Comparator)

fruits.sort(Comparator.reverseOrder()); // จัดเรียงจากมากไปน้อย

การสลับตำแหน่งองค์ประกอบใน List (Collections.shuffle)

ในการสลับลำดับขององค์ประกอบแบบสุ่ม สามารถใช้ Collections.shuffle() ได้

Collections.shuffle(fruits);
System.out.println(fruits); // [กล้วย, ส้ม, แอปเปิ้ล] (ตัวอย่าง)

สะดวกเมื่อต้องการสับไพ่ในเกม หรือต้องการลำดับการแสดงผลแบบสุ่ม

การกรองด้วย Stream API (filter)

ตั้งแต่ Java 8 เป็นต้นมา เมื่อใช้ Stream สามารถเขียนการประมวลผลเพื่อดึงเฉพาะองค์ประกอบที่ตรงตามเงื่อนไขได้อย่างกระชับ

List<String> filtered = fruits.stream()
    .filter(fruit -> fruit.contains("ん"))
    .collect(Collectors.toList());

System.out.println(filtered); // [ส้ม, แอปเปิ้ล]

การแปลงด้วย Stream API (map)

หากต้องการแปลงองค์ประกอบเป็นรูปแบบอื่น ใช้ map()

List<Integer> lengths = fruits.stream()
    .map(String::length)
    .collect(Collectors.toList());

System.out.println(lengths); // จำนวนตัวอักษรของชื่อผลไม้แต่ละชนิด เช่น [3, 3, 2]

map() เป็นเครื่องมือที่มีประสิทธิภาพในการแปลงรูปแบบข้อมูลและการประมวลผลเบื้องต้น

สรุปการดำเนินการขั้นสูง

7. ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

เมื่อจัดการกับ List ใน Java สิ่งที่ผู้เริ่มต้นมักจะสะดุดคือ “Exception (ข้อผิดพลาด)” ในที่นี้จะอธิบายอย่างละเอียดถึงข้อผิดพลาดสำคัญที่เกิดขึ้นบ่อย สาเหตุ และวิธีการแก้ไข

IndexOutOfBoundsException (ข้อผิดพลาดเมื่อดัชนีอยู่นอกขอบเขต)

สาเหตุ:

เกิดขึ้นเมื่อพยายามเข้าถึงดัชนีที่ไม่มีอยู่

List<String> list = new ArrayList<>();
list.add("แอปเปิ้ล");

System.out.println(list.get(1)); // ข้อผิดพลาด: Index 1 out of bounds

วิธีแก้ไข:

ตรวจสอบขนาดก่อนเข้าถึง หรือควบคุมด้วยการใช้เงื่อนไขตรวจสอบว่าดัชนีถูกต้องหรือไม่

if (list.size() > 1) {
    System.out.println(list.get(1));
}

NullPointerException

สาเหตุ:

เกิดขึ้นเมื่อเรียกเมธอดในขณะที่ List หรือองค์ประกอบใน List เป็น null

List<String> list = null;
list.add("แอปเปิ้ล"); // เกิด NullPointerException

วิธีแก้ไข:

ตรวจสอบว่าตัวแปรไม่ใช่ null ล่วงหน้า หรือใช้ Optional เป็นต้น

if (list != null) {
    list.add("แอปเปิ้ล");
}

หรือระวังการลืมกำหนดค่าเริ่มต้น:

List<String> list = new ArrayList<>(); // การกำหนดค่าเริ่มต้นที่ถูกต้อง

ConcurrentModificationException (ข้อผิดพลาดเมื่อมีการแก้ไขพร้อมกัน)

สาเหตุ:

เกิดขึ้นเมื่อมีการแก้ไข List โดยตรงในขณะที่กำลังวนซ้ำ List ด้วย for-each loop หรือ Iterator

for (String fruit : list) {
    if (fruit.equals("กล้วย")) {
        list.remove(fruit); // ConcurrentModificationException
    }
}

วิธีแก้ไข:

ใช้ Iterator ในการลบอย่างปลอดภัย หรือใช้เมธอดเช่น removeIf()

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("กล้วย")) {
        it.remove(); // ลบอย่างปลอดภัย
    }
}

หรือตั้งแต่ Java 8 เป็นต้นไป สามารถเขียนให้กระชับได้:

list.removeIf(fruit -> fruit.equals("กล้วย"));

ข้อควรระวังอื่นๆ

• การตรวจสอบว่า List ไม่ใช่ null

กรณีที่ประกาศตัวแปรไว้เฉยๆ โดยไม่ใช้มีบ่อยมาก การกำหนดค่าเริ่มต้นเป็นสิ่งที่จำเป็น

• การทำความเข้าใจว่าดัชนีเริ่มต้นจาก 0

เป็นความเข้าใจผิดที่ผู้เริ่มต้นมักจะคิดว่า “รายการที่ 1 คือดัชนี 1”

สรุปการป้องกันข้อผิดพลาด

8. สรุป

ทบทวนพื้นฐานของ List ใน Java

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

อันดับแรก หลังจากทำความเข้าใจว่า List คืออะไรแล้ว เราก็ได้เรียนรู้ประเด็นต่างๆ ดังนี้:

• List เป็นคอลเลกชันแบบมีลำดับ และอนุญาตให้มีองค์ประกอบซ้ำได้ สามารถดำเนินการด้วยดัชนีได้
• มีคลาสที่นำไปใช้งานที่สำคัญอย่าง ArrayList และ LinkedList ซึ่งมีคุณสมบัติและวัตถุประสงค์การใช้งานที่แตกต่างกัน
• การใช้การดำเนินการพื้นฐาน (เพิ่ม, ดึง, อัปเดต, ลบ, ค้นหา) ได้อย่างคล่องแคล่ว ทำให้สามารถจัดการข้อมูลได้อย่างอิสระ
• การประมวลผลแบบวนซ้ำที่เหมาะสมกับสถานการณ์ เช่น for loop, Enhanced for loop, Stream API
• รองรับการประมวลผลแบบขั้นสูง เช่น การจัดเรียง, การกรอง, การแปลง
• การทำความเข้าใจข้อผิดพลาดที่พบบ่อยและสาเหตุ/วิธีแก้ไข สามารถป้องกันปัญหาที่อาจเกิดขึ้นได้

การเลือกใช้ ArrayList และ LinkedList

การเลือกใช้ List Implementation ตัวใดนั้น สำคัญที่จะต้องเลือกให้เหมาะสมกับเนื้อหาของการประมวลผลและปริมาณข้อมูล การตัดสินใจดังต่อไปนี้จะเป็นแนวทาง:

• ArrayList: มีการเข้าถึงแบบสุ่มบ่อย และเน้นการอ่านข้อมูล
• LinkedList: มีการแทรก/ลบเกิดขึ้นบ่อย และลำดับการเข้าถึงมีความสำคัญ

สำหรับการเรียนรู้ต่อไป

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

• Set・Map: การจัดการองค์ประกอบที่ไม่ซ้ำกัน, โครงสร้างแบบคู่ของ Key และ Value
• Collections Utility Class: การจัดเรียง, การดึงค่าต่ำสุด/สูงสุด เป็นต้น
• การใช้ Stream API: การนำ Functional Programming มาใช้
• การทำความเข้าใจ Generics: การดำเนินการกับ Collections ที่ปลอดภัยในด้านชนิดข้อมูล

หากคุณเชี่ยวชาญพื้นฐานของ List แล้ว การเขียนโปรแกรม Java โดยรวมจะง่ายขึ้นอย่างมาก

คำถามที่พบบ่อย (FAQ)

เรารวบรวมประเด็นที่ผู้เริ่มต้นเกี่ยวกับ Java List มักจะสงสัย โดยได้คัดเลือกเนื้อหาที่พบบ่อยในการทำงานจริง

คำถามที่ 1. ความแตกต่างระหว่าง Java List และ Array คืออะไร?

ตอบ Array มีจำนวนองค์ประกอบคงที่ ต้องกำหนดขนาดตอนประกาศ ในขณะที่ List มีขนาดที่เปลี่ยนแปลงได้ สามารถเพิ่มหรือลบองค์ประกอบได้อย่างยืดหยุ่น นอกจากนี้ List ยังมีเมธอดอำนวยความสะดวกมากมาย (เช่น add, remove, contains) และมีความเหนือกว่าในด้านความสามารถในการอ่านโค้ดและบำรุงรักษา

คำถามที่ 2. ควรใช้ ArrayList หรือ LinkedList ดี?

ตอบ หากส่วนใหญ่เป็นการเข้าถึงแบบสุ่ม (ดึงข้อมูลโดยระบุดัชนี) บ่อย ควรใช้ ArrayList หากมีการแทรก/ลบองค์ประกอบเกิดขึ้นบ่อย ควรใช้ LinkedList หากไม่แน่ใจ โดยทั่วไปมักจะเริ่มต้นด้วย ArrayList

คำถามที่ 3. สามารถเก็บ Primitive Type (เช่น int หรือ double) ใน List ได้หรือไม่?

ตอบ ไม่ได้โดยตรง List ใน Java สามารถจัดการได้เฉพาะ Object Type เท่านั้น ดังนั้นสำหรับ Primitive Type เช่น int จะต้องใช้ Wrapper Class ที่เกี่ยวข้อง (เช่น Integer, Double)

List<Integer> numbers = new ArrayList<>();
numbers.add(10); // Auto-boxing ทำให้ถูกเก็บในรูปแบบ Integer Type

คำถามที่ 4. ต้องการจัดเรียงองค์ประกอบใน List ต้องทำอย่างไร?

ตอบ สามารถจัดเรียงตามลำดับจากน้อยไปมากได้โดยใช้ Collections.sort(list) นอกจากนี้ หากต้องการจัดเรียงตามลำดับที่กำหนดเอง สามารถระบุ Comparator เพื่อกำหนดลำดับได้อย่างอิสระ

คำถามที่ 5. หากต้องการจัดการองค์ประกอบโดยไม่ให้ซ้ำกันต้องทำอย่างไร?

ตอบ List เป็นคอลเลกชันที่อนุญาตให้มีองค์ประกอบซ้ำได้ หากต้องการหลีกเลี่ยงการซ้ำ ควรพิจารณาใช้ Set (เช่น HashSet) อย่างไรก็ตาม ต้องระวังเรื่องที่ลำดับอาจไม่ถูกรักษาไว้ หากต้องการลบองค์ประกอบที่ซ้ำกันออกจาก List โดยยังคงเป็น List อยู่ สามารถใช้การประมวลผล Stream ดังนี้ได้:

List<String> distinctList = list.stream()
    .distinct()
    .collect(Collectors.toList());

คำถามที่ 6. หากต้องการลบเนื้อหาทั้งหมดใน List ต้องทำอย่างไร?

ตอบ สามารถลบองค์ประกอบทั้งหมดใน List ได้โดยใช้เมธอด clear()

list.clear();

คำถามที่ 7. การดำเนินการใดที่ใช้บ่อยที่สุดใน List?

ตอบ การดำเนินการที่ใช้บ่อยที่สุดในการทำงานจริงคือ add (เพิ่ม), get (ดึง), remove (ลบ), และ size (ดึงขนาด) หากเชี่ยวชาญเหล่านี้ ก็จะครอบคลุมการประมวลผลพื้นฐานส่วนใหญ่ได้