Collections

Java Collection Framework (ការប្រមូលទិន្នន័យ)

📚 Collection Framework គឺជាអ្វី?

Java Collection Framework គឺស្ថាបត្យកម្មដែលបង្កើតរួចហើយដើម្បីរក្សាទុក និង គ្រប់គ្រងក្រុមនៃ objects។ វាផ្តល់interfaces និង classesជាច្រើនសម្រាប់ការងារផ្សេងៗ។

ឧទាហរណ៍ក្នុងជីវិតពិត:

• បញ្ជីទិញទំនិញ: ArrayList (រៀបតាមលំដាប់)
• វចនានុក្រម: HashMap (key-value pairs)
• សិស្សក្នុងថ្នាក់: Set (មិនមានស្ទួន)
• ជួរសម្រាប់ចូល: Queue (FIFO - First In First Out)

💡 ហេតុអ្វីប្រើ Collections?

1. Dynamic Size: ទំហំបន្ថែម/ថយដោយស្វ័យប្រវត្តិ (ផ្ទុយពី arrays)
2. Ready-made Methods: add, remove, search, sort មានរួចហើយ
3. Different Data Structures: List, Set, Map, Queue...
4. Performance: Optimized algorithms
5. Interoperability: Collections ធ្វើការជាមួយគ្នាបាន
6. Type Safety: Generics ធានា type safety

🎯 Collection Hierarchy

Collection Interface
├── List (Ordered, allows duplicates)
│   ├── ArrayList
│   ├── LinkedList
│   └── Vector
│
├── Set (Unique elements only)
│   ├── HashSet
│   ├── LinkedHashSet
│   └── TreeSet
│
└── Queue (FIFO)
    ├── PriorityQueue
    └── LinkedList

Map Interface (Separate - Key-Value pairs)
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable

📊 Collections vs Arrays

📋 ArrayList

📖 ArrayList គឺជាអ្វី?

ArrayList គឺdynamic arrayដែល:

• ទំហំអាចប្តូរបាន
• រក្សាលំដាប់ insertion
• អនុញ្ញាតduplicate elements
• អាចaccess by index

✅ Basic Usage

import java.util.ArrayList;

// Create ArrayList
ArrayList<String> fruits = new ArrayList<>();

// Add elements
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

// Access element
String first = fruits.get(0);  // "Apple"

// Size
int size = fruits.size();  // 3

// Remove element
fruits.remove(1);  // Remove "Banana"
fruits.remove("Orange");  // Remove by value

// Check if contains
boolean hasApple = fruits.contains("Apple");  // true

// Clear all
fruits.clear();

📊 ArrayList Methods

🗺️ HashMap

📖 HashMap គឺជាអ្វី?

HashMap រក្សាទុកទិន្នន័យជាkey-value pairs:

• Keys ត្រូវតែunique
• Values អាចduplicate
• មិនរក្សាលំដាប់
• Fast access by key
• អនុញ្ញាតnull (1 null key, multiple null values)

✅ Basic Usage

import java.util.HashMap;

// Create HashMap
HashMap<String, Integer> scores = new HashMap<>();

// Add key-value pairs
scores.put("Dara", 95);
scores.put("Sok", 87);
scores.put("Chan", 92);

// Get value by key
int daraScore = scores.get("Dara");  // 95

// Check if key exists
boolean hasSok = scores.containsKey("Sok");  // true

// Check if value exists
boolean has95 = scores.containsValue(95);  // true

// Remove by key
scores.remove("Sok");

// Size
int size = scores.size();  // 2

// Update value
scores.put("Dara", 98);  // Update existing key

📊 HashMap Methods

🔄 Iterating HashMap

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);

// Method 1: Using keySet()
for (String key : map.keySet()) {
    System.out.println(key + " = " + map.get(key));
}

// Method 2: Using entrySet()
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

🎨 List vs Set vs Map

💡 When to Use What?

✅ Use ArrayList when:

• ត្រូវការaccess by index
• ត្រូវការរក្សាលំដាប់
• Duplicates are allowed
• Shopping cart, To-do list, Student list

✅ Use HashSet when:

• ត្រូវការunique elements only
• មិនខ្វល់លំដាប់
• Fast lookup
• Email addresses, Unique IDs, Tags

✅ Use HashMap when:

• ត្រូវការkey-value mapping
• Fast lookup by key
• Dictionary, Phone book, Configuration

✅ Best Practices

1. Use interface type: List<String> list = new ArrayList<>();
2. Specify generic type: ArrayList<String> (avoid raw types)
3. Initialize with capacity: new ArrayList<>(100) if size known
4. Use appropriate collection: Choose based on requirements
5. Check before operations: isEmpty(), contains() មុនពេលប្រើ

⚠️ Common Mistakes