Əsas məzmuna keçin

Java Collections Framework

Collections Nədir?​

Java Collections Framework (JCF) data strukturlarını idarə etmək üçün standart interfeys və implementasiyalar təqdim edir. Java 1.2-də təqdim edilib.

Əsas İnterfeyslər​

  • Collection - Bütün kolleksiyaların əsas interfeysi
  • List - Sıralı kolleksiya, dublikatlar icazəli
  • Set - Unikal elementlər kolleksiyası
  • Queue - FIFO prinsipi
  • Map - Key-value cütlükləri

List Interface​

ArrayList​

Dinamik array, random access.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("JavaScript");

String first = list.get(0);        // "Java"
list.set(1, "Kotlin");             // Replace
list.remove(2);                    // Remove by index
System.out.println(list.size());   // 2

LinkedList​

Doubly-linked list, əlavə/silmə əməliyyatları üçün effektiv.

LinkedList<String> linked = new LinkedList<>();
linked.addFirst("First");
linked.addLast("Last");
linked.add(1, "Middle");

String head = linked.removeFirst();
String tail = linked.removeLast();

Set Interface​

HashSet​

Hash table əsasında, O(1) əməliyyatlar.

Set<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java");                // Dublikat, əlavə edilməz

System.out.println(set.size()); // 2
boolean contains = set.contains("Java"); // true

TreeSet​

Red-black tree, sıralanmış.

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);

System.out.println(treeSet); // [1, 2, 3] - sıralanmış

LinkedHashSet​

Insertion order saxlayır.

Set<String> linkedSet = new LinkedHashSet<>();
linkedSet.add("C");
linkedSet.add("A");
linkedSet.add("B");

System.out.println(linkedSet); // [C, A, B] - əlavə sırası

Map Interface​

HashMap​

Key-value cütlükləri, O(1) əməliyyatlar.

Map<String, Integer> map = new HashMap<>();
map.put("Java", 25);
map.put("Python", 30);
map.put("JavaScript", 28);

Integer age = map.get("Java");        // 25
boolean hasKey = map.containsKey("C++"); // false
map.remove("Python");

TreeMap​

Sıralanmış key-lər.

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("C", 1);
treeMap.put("A", 2);
treeMap.put("B", 3);

System.out.println(treeMap); // {A=2, B=3, C=1}

LinkedHashMap​

Insertion order saxlayır.

Map<String, Integer> linkedMap = new LinkedHashMap<>();
linkedMap.put("First", 1);
linkedMap.put("Second", 2);
// Sıra saxlanılır

Queue Interface​

ArrayDeque​

Double-ended queue.

Queue<String> queue = new ArrayDeque<>();
queue.offer("First");
queue.offer("Second");

String head = queue.poll();     // "First"
String peek = queue.peek();     // "Second" (silmədən)

PriorityQueue​

Heap əsasında priority queue.

Queue<Integer> pq = new PriorityQueue<>();
pq.offer(3);
pq.offer(1);
pq.offer(2);

System.out.println(pq.poll()); // 1 (ən kiçik)

Iterasiya​

List<String> list = Arrays.asList("A", "B", "C");

// Enhanced for loop
for (String item : list) {
    System.out.println(item);
}

// Iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Stream API
list.forEach(System.out::println);

Collections Utility Class​

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5);

// Sort
Collections.sort(numbers);           // [1, 1, 3, 4, 5]

// Reverse
Collections.reverse(numbers);        // [5, 4, 3, 1, 1]

// Shuffle
Collections.shuffle(numbers);

// Binary search (sıralanmış listdə)
int index = Collections.binarySearch(numbers, 3);

// Min/Max
int min = Collections.min(numbers);
int max = Collections.max(numbers);

// Frequency
int count = Collections.frequency(numbers, 1); // 2

Performans Müqayisəsi​

ƏməliyyatArrayListLinkedListHashSetTreeSet
AddO(1)O(1)O(1)O(log n)
RemoveO(n)O(1)O(1)O(log n)
ContainsO(n)O(n)O(1)O(log n)
GetO(1)O(n)--

Best Practices​

  1. Interface tipini istifadə edin:

    List<String> list = new ArrayList<>();  // ✅
    ArrayList<String> list = new ArrayList<>(); // ❌

  2. Başlanğıc capacity təyin edin:

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

  3. Uyğun kolleksiyanı seçin:

    • ArrayList: Random access lazımdırsa
    • LinkedList: Çox əlavə/silmə əməliyyatı varsa
    • HashSet: Unikal elementlər və sürət lazımdırsa
    • TreeSet: Sıralanmış unikal elementlər lazımdırsa

  4. Generic istifadə edin:

    List<String> list = new ArrayList<>(); // ✅
    List list = new ArrayList();           // ❌