Enumeration ve Legacy (Eski) Yapılar
Java'nın koleksiyon dünyası iki katmanlıdır: 1996'daki ilk sürümlerden kalan eski (legacy) sınıflar (Vector, Stack, Hashtable, Enumeration) ve Java 1.2 ile gelen modern Collections Framework (ArrayList, ArrayDeque, Ha…
Enumeration ve Legacy (Eski) Yapılar
Java'nın koleksiyon dünyası iki katmanlıdır: 1996'daki ilk sürümlerden kalan eski (legacy)
sınıflar (Vector, Stack, Hashtable, Enumeration) ve Java 1.2 ile gelen modern Collections
Framework (ArrayList, ArrayDeque, HashMap, Iterator). Yeni kod modern olanları kullanır;
ama eski API'lerde (ve bazı kütüphanelerde) hâlâ eskilerine rastlarsın. Bu konu, ikisi arasındaki
farkı ve neyi ne zaman kullanacağını netleştirir.
Enumeration: Iterator'ın atası
Enumeration (Java 1.0), bir koleksiyonu gezmenin ilk yoluydu. İki metodu vardır:
Enumeration<String> e = vector.elements(); while (e.hasMoreElements()) { System.out.println(e.nextElement()); }
Iterator (Java 1.2) bunun halefidir ve üç iyileştirme getirir:
| Enumeration (1.0) | Iterator (1.2) | |
|---|---|---|
| Metotlar | hasMoreElements(), nextElement() | hasNext(), next(), remove() |
| Silme | Yok | Var (remove()) |
| Fail-fast | Hayır | Evet |
| İsimlendirme | Uzun | Kısa |
Örnek 1 (./Ornek1.java) aynı Vector'ı hem Enumeration hem Iterator ile gezer ve Hashtable'ın
Enumeration döndüren metotlarını gösterir. Bugün Enumeration'ı yalnızca eski API'lerde görürsün:
Vector, Hashtable, StringTokenizer, Servlet'lerde request.getHeaderNames() gibi.
Eski koleksiyonlar ve modern karşılıkları
| Eski (1.0–1.1) | Modern (1.2+) | Fark |
|---|---|---|
Vector | ArrayList | Vector her metotta synchronized (yavaş) |
Stack | ArrayDeque | Stack, Vector'dan türer; ArrayDeque daha hızlı yığın/kuyruk |
Hashtable | HashMap | Hashtable senkronize, null anahtar/değer kabul etmez |
Enumeration | Iterator | yukarıdaki tablo |
Örnek 2 (./Ornek2.java) bu çiftleri yan yana gösterir.
Neden modern olanları tercih ediyoruz?
Eski sınıfların ortak sorunu: hepsi her metotta kilit alır (synchronized). Çok thread'li erişimde bu güvenlik sağlar gibi görünse de:
- Tek thread'de gereksiz yavaşlıktır (kilit maliyeti, çoğu kod tek thread).
- Çok thread'de bile yetersizdir: Tek tek metotlar kilitli olsa da, "oku-sonra-yaz" gibi bileşik işlemler yine yarış koşuluna açıktır.
Doğru yaklaşım:
- Tek thread / çoğu durum:
ArrayList,ArrayDeque,HashMap(senkronsuz, hızlı). - Eş zamanlılık gerçekten gerekiyorsa:
java.util.concurrentpaketini kullan —ConcurrentHashMap,CopyOnWriteArrayList,ConcurrentLinkedQueue— bunlar Vector/Hashtable'dan çok daha iyi ölçeklenir. Ya daCollections.synchronizedList(...)ile sarmala.
Kural: Yeni kodda
Vector/Stack/Hashtablekullanma. Modern koleksiyonları seç; eş zamanlılık içinjava.util.concurrent'a git.
StringTokenizer notu
Eski StringTokenizer de metni parçalara ayırmak için Enumeration benzeri bir gezinti sunar.
Bugün yerine String.split(regex) veya Scanner tercih edilir.
Özet
Enumeration'ın Iterator'ın atası olduğunu (hasMoreElements/nextElement, silme yok) ve eski
API'lerde nerede karşına çıktığını (Örnek 1); eski koleksiyonların (Vector/Stack/Hashtable)
modern karşılıklarını ve neden senkronize tasarımları yüzünden artık tercih edilmediklerini
(Örnek 2) öğrendik. Bu, Data Structures bölümünü tamamlıyor: kavramsal olarak Iterator,
Comparable, Comparator ve eski yapılar artık net. Sırada — bir sonraki büyük bölüm — sık kullanılan
sınıf referansları (Scanner, ArrayList, HashMap...) başlıyor.
▶ Kod Örnekleri(2)
Ornek1
çalıştırılabilir1// Ornek1: Enumeration — Iterator'ın atası (eski API'lerde hâlâ karşına çıkar).
2// Çalıştırma: java Ornek1.java
3import java.util.Enumeration;
4import java.util.Hashtable;
5import java.util.Iterator;
6import java.util.Vector;
7
8public class Ornek1 {
9
10 public static void main(String[] args) {
11 // Vector ve Hashtable (eski koleksiyonlar) Enumeration döndüren metotlar sunar.
12 Vector<String> sehirler = new Vector<>();
13 sehirler.add("Ankara"); sehirler.add("İzmir"); sehirler.add("Bursa");
14
15 // Enumeration: hasMoreElements() + nextElement() (Iterator'ın eski, uzun adlı hali).
16 Enumeration<String> e = sehirler.elements();
17 System.out.print("Enumeration ile: ");
18 while (e.hasMoreElements()) {
19 System.out.print(e.nextElement() + " ");
20 }
21 System.out.println();
22
23 // Aynı Vector'ı modern Iterator ile gezmek (tercih edilen):
24 Iterator<String> it = sehirler.iterator();
25 System.out.print("Iterator ile : ");
26 while (it.hasNext()) System.out.print(it.next() + " ");
27 System.out.println();
28
29 // Hashtable da Enumeration verir (anahtarlar / değerler):
30 Hashtable<String, Integer> tablo = new Hashtable<>();
31 tablo.put("bir", 1); tablo.put("iki", 2);
32 Enumeration<String> anahtarlar = tablo.keys();
33 System.out.print("Hashtable anahtarları: ");
34 while (anahtarlar.hasMoreElements()) System.out.print(anahtarlar.nextElement() + " ");
35 System.out.println();
36
37 System.out.println("""
38
39 --- Enumeration vs Iterator ---
40 Enumeration (Java 1.0): hasMoreElements() / nextElement(). SİLME yok.
41 Iterator (Java 1.2) : hasNext() / next() / remove(). Daha kısa, silme destekli, fail-fast.
42 Bugün Iterator (ve for-each) tercih edilir; Enumeration'ı yalnızca eski API'lerde
43 (Vector, Hashtable, StringTokenizer, ServletRequest başlıkları...) görürsün.""");
44 }
45}Ornek2
çalıştırılabilir1// Ornek2: Eski (legacy) koleksiyonlar vs modern karşılıkları.
2// Çalıştırma: java Ornek2.java
3import java.util.ArrayDeque;
4import java.util.ArrayList;
5import java.util.Deque;
6import java.util.HashMap;
7import java.util.List;
8import java.util.Map;
9import java.util.Stack;
10import java.util.Vector;
11
12public class Ornek2 {
13
14 public static void main(String[] args) {
15 // Vector (eski, senkronize) -> ArrayList (modern, senkronsuz/hızlı)
16 Vector<Integer> vector = new Vector<>(List.of(1, 2, 3));
17 List<Integer> arrayList = new ArrayList<>(List.of(1, 2, 3));
18 System.out.println("Vector : " + vector + " (her metot synchronized -> yavaş)");
19 System.out.println("ArrayList: " + arrayList + " (senkronsuz -> hızlı, tercih edilen)");
20
21 // Stack (eski, Vector'dan türer) -> ArrayDeque (modern yığın/kuyruk)
22 Stack<String> stack = new Stack<>();
23 stack.push("a"); stack.push("b");
24 Deque<String> deque = new ArrayDeque<>();
25 deque.push("a"); deque.push("b");
26 System.out.println("\nStack.pop() : " + stack.pop() + " (eski)");
27 System.out.println("ArrayDeque.pop(): " + deque.pop() + " (modern yığın, daha hızlı)");
28
29 // Hashtable (eski, senkronize, null kabul etmez) -> HashMap (modern)
30 Map<String, Integer> hashMap = new HashMap<>();
31 hashMap.put("x", 10); hashMap.put(null, 0); // HashMap null anahtara izin verir
32 System.out.println("\nHashMap (null anahtar ok): " + hashMap);
33
34 System.out.println("""
35
36 --- Legacy vs modern koleksiyonlar ---
37 Eski (Java 1.0-1.1, hepsi synchronized): Vector, Stack, Hashtable, Enumeration.
38 Modern (Java 1.2+ Collections Framework): ArrayList, ArrayDeque, HashMap, Iterator.
39 Neden modern? Eskiler HER metotta kilit alır (tek thread'de gereksiz yavaşlık).
40 Eş zamanlılık gerekiyorsa: Collections.synchronizedList(...) veya java.util.concurrent
41 (ConcurrentHashMap, CopyOnWriteArrayList) kullan — Vector/Hashtable DEĞİL.
42 Kural: yeni kodda ArrayList/ArrayDeque/HashMap tercih et.""");
43 }
44}