Java List: คู่มือครบวงจรสำหรับผู้เริ่มต้นและนักพัฒนา

1. บทนำ

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

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

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

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

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

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

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

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

2. List คืออะไร?

ภาพรวมและลักษณะของ List

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

List ถูกให้มาเป็นส่วนหนึ่งของ Collections Framework และมีคุณสมบัติดังต่อไปนี้:

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

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

ความแตกต่างจาก Array

ใน Java arrays (เช่น int[] หรือ String[]) ก็มีอยู่เช่นกันในฐานะวิธีการเก็บค่าหลายค่า แต่มีความแตกต่างหลายอย่างจาก List。

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

อินเทอร์เฟซ List และคลาสการ implement ของมัน

เมื่อใช้ List ใน Java โดยทั่วไปจะประกาศตัวแปรโดยใช้ List interface และสร้างอินสแตนซ์ด้วยคลาสเฉพาะ (implementation class) คลาส implementation ที่เป็นตัวแทนมีดังนี้:

• ArrayList โครงสร้างคล้าย array อนุญาตให้เข้าถึงเร็ว แข็งแกร่งสำหรับการค้นหาข้อมูลและการเข้าถึงแบบสุ่ม。
• LinkedList ถูก implement ด้วยโครงสร้าง doubly linked list เร็วสำหรับการแทรกและลบ เหมาะสำหรับรายการที่การดำเนินการบ่อย。
• Vector คล้าย ArrayList แต่หนักกว่าเล็กน้อยเพราะ thread-safe ไม่ค่อยใช้ในปัจจุบัน。

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

3. การใช้งานพื้นฐานของ List

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

การประกาศและการเริ่มต้นของ 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 และสร้างอินสแตนซ์ด้วย ArrayList จีเนอริกส์ถูกใช้เพื่อระบุประเภทที่จะเก็บ (ที่นี่คือ String)。

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

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

fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

นี่คือการเพิ่มสามองค์ประกอบลงใน List ตามลำดับ List รักษาลำดับของการเพิ่ม。

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

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

System.out.println(fruits.get(0)); // "apple" will be displayed

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

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

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

fruits.set(1, "grape"); // The second element "banana" is replaced with "grape"

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

คุณยังสามารถลบองค์ประกอบโดยดัชนีเฉพาะหรือองค์ประกอบนั้นเองได้。

fruits.remove(0);           // Removes the first element
fruits.remove("orange");    // Removes "orange" (only the first match)

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

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

System.out.println(fruits.size()); // Returns 2, etc.

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

เพื่อตรวจสอบว่ามีองค์ประกอบเฉพาะใน List หรือไม่ ให้ใช้ contains()。

if (fruits.contains("grape")) {
    System.out.println("grape is present");
}

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

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

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

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

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

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

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 Expressions และ Stream API

ตั้งแต่ Java 8 คุณยังสามารถใช้ไวยากรณ์กับ Stream API และ lambda expressions ได้。

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

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

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

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

การเลือกเมธอดที่เหมาะสม

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

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

ลักษณะและกรณีการใช้งานที่เหมาะสมของ ArrayList

ArrayList ภายในใช้ dynamic array (resizable array)。

ลักษณะหลัก:

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

สถานการณ์ที่เหมาะสม

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

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

ลักษณะและกรณีการใช้งานที่เหมาะสมของ LinkedList

LinkedList ถูกนำไปใช้ด้วยโครงสร้าง รายการเชื่อมโยงสองทาง.

ลักษณะหลัก

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

สถานการณ์ที่เหมาะสม

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

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

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

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

* เวลาในการประมวลผลจริงอาจได้รับผลกระทบจากขนาดข้อมูล, การปรับแต่ง JVM, เป็นต้น

จุดที่ควรพิจารณาในการใช้งานจริง

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

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

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

การเรียงลำดับ List (Collections.sort)

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

import java.util.*;

List<String> fruits = new ArrayList<>();
fruits.add("banana");
fruits.add("apple");
fruits.add("orange");

Collections.sort(fruits);

System.out.println(fruits); // [apple, banana, orange]

การเรียงลำดับแบบกำหนดเอง (โดยใช้ Comparator)

fruits.sort(Comparator.reverseOrder()); // Sorts in descending order

การสับเปลี่ยน List (Collections.shuffle)

เพื่อสับเปลี่ยนองค์ประกอบแบบสุ่ม คุณสามารถใช้ Collections.shuffle().

Collections.shuffle(fruits);
System.out.println(fruits); // [banana, orange, apple] (example)

สิ่งนี้มีประโยชน์เมื่อคุณต้องการสำรับไพ่สำหรับเกมหรือการแสดงผลแบบสุ่ม.

การกรองโดยใช้ Stream API (filter)

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

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

System.out.println(filtered); // [apple, banana, orange] (depending on original content and filter)

การแปลงโดยใช้ Stream API (map)

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

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

System.out.println(lengths); // Lengths of each fruit name [5, 6, 6] etc.

map() เป็นเครื่องมือที่ทรงพลังสำหรับ การแปลงรูปแบบข้อมูลและการเตรียมข้อมูลล่วงหน้า.

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

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

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

IndexOutOfBoundsException

สาเหตุ

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

List<String> list = new ArrayList<>();
list.add("apple");

System.out.println(list.get(1)); // Error: Index 1 out of bounds

Solution:

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

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

NullPointerException

Cause:

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

List<String> list = null;
list.add("apple"); // NullPointerException occurs

Solution:

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

if (list != null) {
    list.add("apple");
}

Also, be careful about forgetting to initialize:

List<String> list = new ArrayList<>(); // Correct initialization

ConcurrentModificationException

Cause:

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

for (String fruit : list) {
    if (fruit.equals("banana")) {
        list.remove(fruit); // ConcurrentModificationException
    }
}

Solution:

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

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("banana")) {
        it.remove(); // Safe removal
    }
}

Or, more concisely from Java 8 onwards:

list.removeIf(fruit -> fruit.equals("banana"));

Other Points to Note

• ตรวจสอบว่า List ไม่เป็น null
• การประกาศตัวแปรแต่ไม่ได้ใช้เป็นเรื่องทั่วไปมาก การกำหนดค่าเริ่มต้นเป็นสิ่งสำคัญ.
• เข้าใจว่าดัชนีเริ่มจาก 0
• ผู้เริ่มต้นมักเข้าใจผิดว่า “องค์ประกอบแรกคือดัชนี 1”.

Error Countermeasures Summary

8. Conclusion

Reviewing the Basics of Java List

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

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

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

Differentiating between ArrayList and LinkedList Usage

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

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

Towards Future Learning

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

• Set และ Map : การจัดการองค์ประกอบที่ไม่ซ้ำกัน, โครงสร้างคู่คีย์-ค่า
• คลาสยูทิลิตี้ Collections : การจัดเรียง, การหาค่าต่ำสุด/สูงสุด, เป็นต้น
• การใช้ Stream API : การแนะนำการเขียนโปรแกรมเชิงฟังก์ชัน
• การเข้าใจ Generics : การดำเนินการคอลเลกชันที่ปลอดภัยต่อประเภท

การเชี่ยวชาญพื้นฐานของ List จะทำให้ การเขียนโปรแกรม Java ของคุณโดยรวมง่ายต่อการจัดการอย่างมาก.

Frequently Asked Questions (FAQ)

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

Q1. ความแตกต่างระหว่าง List และ Array ของ Java คืออะไร?

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

Q2. ฉันควรใช้ ArrayList หรือ LinkedList ใด?

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

Q3. ฉันสามารถเก็บประเภทพื้นฐาน (เช่น int หรือ double) ใน List ได้หรือไม่?

A. ทำไม่ได้โดยตรง เนื่องจาก List ของ Java จัดการเฉพาะประเภทอ็อบเจกต์เท่านั้น สำหรับประเภทพื้นฐานเช่น int จำเป็นต้องใช้คลาส wrapper ที่สอดคล้อง (Integer, Double เป็นต้น)

List<Integer> numbers = new ArrayList<>();
numbers.add(10); // Auto-boxed and stored as Integer type

Q4. ฉันจะเรียงลำดับองค์ประกอบใน List อย่างไร?

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

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

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

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

Q6. ฉันทำอย่างไรเมื่ออยากลบทุกองค์ประกอบออกจาก List?

A. สามารถลบสมาชิกทั้งหมดจาก List ได้โดยใช้เมธอด clear()

list.clear();

Q7. การดำเนินการที่ใช้บ่อยที่สุดใน List คืออะไร?

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