Java’da Koleksiyonlar – Bilmeniz Gereken Her Şey
Giriş: Java Koleksiyon Çatısının Önemi
Java programlama dilinde veri yapıları, yazılım geliştirmenin temel taşlarından biridir. Verileri etkili bir şekilde depolamak, yönetmek ve işlemek, her uygulamanın performansını ve sürdürülebilirliğini doğrudan etkiler. İşte bu noktada Java Koleksiyon Çatısı (Java Collections Framework – JCF) devreye girer. JCF, yaygın olarak kullanılan veri yapılarını (listeler, kümeler, kuyruklar, haritalar vb.) ve bu yapılar üzerinde işlem yapmak için standartlaştırılmış bir dizi arayüz ve sınıf sunar.
Java’nın ilk günlerinden itibaren geliştiriciler, nesne gruplarını yönetmek için Array’ler gibi ilkel yapıları kullanmışlardır. Ancak Array’lerin sabit boyutu, tür güvenliği eksikliği (Java 5’ten önceki genel koleksiyonlar için) ve sınırlı işlevselliği, daha esnek ve güçlü çözümlerin ihtiyacını doğurmuştur. JCF, bu ihtiyaçlara yanıt olarak ortaya çıkmış ve Java geliştiricilerinin günlük işlerinde vazgeçilmez bir araç haline gelmiştir. Generic’lerin Java 5 ile tanıtılmasıyla birlikte, koleksiyonlar tür güvenliği ve kod okunabilirliği açısından devrim niteliğinde bir iyileşme yaşamıştır.
Bu makalede, Java Koleksiyon Çatısı’nın temel bileşenlerini, her bir arayüzün ve uygulamanın özelliklerini, kullanım senaryolarını, performans farklılıklarını ve en iyi uygulamaları derinlemesine inceleyeceğiz. Amacımız, Java’da koleksiyonları etkin bir şekilde kullanmak için gereken tüm temel ve ileri düzey bilgileri sunmaktır.
Java Koleksiyon Çatısına Genel Bakış
Java Koleksiyon Çatısı, bir dizi arayüz (interfaces) ve bunların uygulamalarından (implementations) oluşur. Bu yapı, veri depolama ve işleme için standart bir mimari sağlar. Çerçevenin temelini oluşturan arayüzler, veri yapılarının davranışlarını tanımlarken, uygulamalar bu davranışları somut sınıflar aracılığıyla gerçekler.
JCF’nin ana arayüzleri şunlardır:
* Iterable: Koleksiyonların üzerinde döngü yapılabilmesini sağlayan en temel arayüzdür.
* Collection: Tek bir eleman grubunu temsil eden kök arayüzdür. Listeler, kümeler ve kuyruklar bu arayüzden türetilir.
* List: Elemanların sıralı bir şekilde depolandığı ve tekrar eden elemanlara izin veren koleksiyonlardır.
* Set: Elemanların benzersiz olduğu ve genellikle sırasız depolandığı koleksiyonlardır.
* Queue: Elemanların belirli bir işlem sırasına göre (genellikle FIFO – First-In, First-Out) işlendiği koleksiyonlardır.
* Map: Anahtar-değer çiftleri şeklinde veri depolayan koleksiyonlardır. Collection arayüzünden türemez, ancak Koleksiyon Çatısı’nın ayrılmaz bir parçasıdır.
Bu arayüzleri anlamak, doğru veri yapısını seçmek ve uygulamalarınızı optimize etmek için kritik öneme sahiptir.
Temel Arayüzler ve Uygulamaları
Collection Arayüzü
Collection arayüzü, JCF’nin temelini oluşturan kök arayüzdür (Map hariç). Bir grup nesneyi temsil eder ve bu nesneler üzerinde temel işlemler yapmak için metodlar sunar. Bu metodlar arasında add(), remove(), contains(), size(), isEmpty(), clear() ve toArray() bulunur. Collection arayüzü, Iterable arayüzünü genişletir, bu da tüm koleksiyonların for-each döngüsü ile kolayca taranabileceği anlamına gelir.
List Arayüzü
List arayüzü, elemanların belirli bir sırada tutulduğu ve indeks tabanlı erişime izin veren koleksiyonları tanımlar. Tekrarlayan elemanlara izin verir. List arayüzü, Collection arayüzünü genişletir ve ek olarak indeks bazlı işlemler için get(int index), set(int index, E element), add(int index, E element), remove(int index) gibi metodlar sunar.
ArrayList
ArrayList, List arayüzünün en yaygın kullanılan uygulamalarından biridir. Dahili olarak dinamik bir dizi (array) kullanarak elemanları depolar.
* Avantajları: Elemanlara indeks aracılığıyla hızlı erişim (O(1)).
* Dezavantajları: Ortadan veya baştan eleman ekleme/silme işlemleri yavaştır (O(n)), çünkü diğer elemanların kaydırılması gerekir. Kapasite aşıldığında dizinin yeniden boyutlandırılması (yeni ve daha büyük bir dizi oluşturulup eski elemanların kopyalanması) maliyetli olabilir.
* Kullanım Senaryoları: Sık sık elemanlara indeks ile erişim gereken durumlarda veya listenin sonuna eklemelerin yoğun olduğu yerlerde tercih edilir.
List arrayList = new ArrayList<>();
arrayList.add("Elma");
arrayList.add("Armut");
System.out.println(arrayList.get(0)); // Elma LinkedList
LinkedList, List arayüzünün bir başka popüler uygulamasıdır. Dahili olarak çift yönlü bağlı liste (doubly linked list) kullanarak elemanları depolar. Her eleman, kendisinden önceki ve sonraki elemanın referansını tutar.
* Avantajları: Ortadan veya baştan eleman ekleme/silme işlemleri hızlıdır (O(1)), sadece referansların güncellenmesi yeterlidir.
* Dezavantajları: Elemanlara indeks aracılığıyla erişim yavaştır (O(n)), çünkü listenin başından veya sonundan başlayarak ilgili indekse kadar ilerlemek gerekir.
* Kullanım Senaryoları: Sık sık listenin başından veya ortasından eleman ekleme/silme gereken durumlarda tercih edilir. Ayrıca Queue veya Deque olarak da kullanılabilir.
List linkedList = new LinkedList<>();
linkedList.add("Kedi");
linkedList.add("Köpek");
linkedList.add(0, "Kuş"); // Başa ekleme
System.out.println(linkedList); // [Kuş, Kedi, Köpek] Vector (Eski Nesil)
Vector, ArrayList‘e benzer şekilde dinamik bir dizi kullanır, ancak tüm metodları senkronizedir (thread-safe). Bu özelliği nedeniyle, çoklu iş parçacıklı ortamlarda doğrudan kullanılabilir, ancak tek iş parçacıklı senaryolarda ArrayList‘ten daha yavaş performans gösterir. Genellikle yeni kodlarda ArrayList veya java.util.concurrent paketindeki eşzamanlı koleksiyonlar tercih edilir.
Set Arayüzü
Set arayüzü, benzersiz elemanlardan oluşan bir koleksiyonu temsil eder. Yani bir Set içerisinde aynı elemandan birden fazla bulunamaz. Elemanların sırası genellikle garanti edilmez. Set arayüzü, Collection arayüzünü genişletir.
HashSet
HashSet, Set arayüzünün en yaygın uygulamasıdır. Dahili olarak bir hash tablosu kullanır.
* Avantajları: Eleman ekleme, silme ve kontrol etme işlemleri ortalama olarak çok hızlıdır (O(1)).
* Dezavantajları: Elemanların sırasını garanti etmez.
* Kullanım Senaryoları: Veri tekrarını önlemek ve hızlı arama, ekleme, silme işlemleri yapmak için idealdir. hashCode() ve equals() metodlarının doğru implementasyonu, HashSet‘in düzgün çalışması için hayati öneme sahiptir.
Set hashSet = new HashSet<>();
hashSet.add("Java");
hashSet.add("Python");
hashSet.add("Java"); // Tekrar eden eleman eklenmez
System.out.println(hashSet.size()); // 2
System.out.println(hashSet.contains("Java")); // true LinkedHashSet
LinkedHashSet, HashSet‘in bir alt sınıfıdır ve ekleme sırasını korur. Dahili olarak bir hash tablosu ve çift yönlü bağlı liste kullanır.
* Avantajları: HashSet gibi hızlı işlemlere sahiptir ve elemanların eklenme sırasını korur.
* Dezavantajları: HashSet‘e göre biraz daha fazla bellek tüketir.
* Kullanım Senaryoları: Benzersiz elemanlara ihtiyaç duyulduğunda ve aynı zamanda elemanların eklenme sırasının önemli olduğu durumlarda kullanılır.
TreeSet
TreeSet, elemanları doğal sıralarına göre veya bir Comparator tarafından belirtilen sıraya göre sıralanmış bir şekilde depolar. Dahili olarak bir kırmızı-siyah ağaç (red-black tree) kullanır.
* Avantajları: Elemanlar her zaman sıralı tutulur. first(), last(), headSet(), tailSet() gibi sıralı koleksiyonlara özgü metodlar sunar.
* Dezavantajları: Ekleme, silme ve arama işlemleri HashSet‘e göre daha yavaştır (O(log n)).
* Kullanım Senaryoları: Elemanların her zaman sıralı olmasının gerektiği durumlarda kullanılır. TreeSet‘e eklenen nesnelerin Comparable arayüzünü implement etmesi veya TreeSet oluşturulurken bir Comparator sağlanması gerekir.
Set treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(1);
treeSet.add(3);
System.out.println(treeSet); // [1, 3, 5] Queue Arayüzü
Queue arayüzü, elemanların belirli bir işlem sırasına göre (genellikle FIFO – First-In, First-Out) işlendiği koleksiyonları temsil eder. Kuyruklar genellikle bir işlem hattı veya görev yöneticisi gibi senaryolarda kullanılır.
LinkedList (Queue olarak)
LinkedList, Queue arayüzünü implement eder ve bu nedenle bir kuyruk olarak kullanılabilir. Özellikle add()/offer() (kuyruğa eleman ekleme), remove()/poll() (kuyruktan eleman alma) ve element()/peek() (kuyruğun başındaki elemana bakma) metodları kullanılarak FIFO prensibine uygun davranır.
PriorityQueue
PriorityQueue, elemanları doğal sıralarına göre veya bir Comparator tarafından belirtilen öncelik sırasına göre depolar. En yüksek önceliğe sahip eleman her zaman kuyruğun başında bulunur.
* Avantajları: Elemanları öncelik sırasına göre işler.
* Dezavantajları: Rastgele erişim desteklemez.
* Kullanım Senaryoları: Görevlerin önceliğe göre işlenmesi gereken durumlarda (örn. işlemci zamanlayıcıları, olay simülasyonları) kullanılır.
Queue priorityQueue = new PriorityQueue<>();
priorityQueue.offer("Görev C");
priorityQueue.offer("Görev A");
priorityQueue.offer("Görev B");
System.out.println(priorityQueue.poll()); // Görev A (alfabetik sıra) ArrayDeque
ArrayDeque, hem Queue hem de Deque (Double-Ended Queue – Çift Yönlü Kuyruk) arayüzlerini implement eder. Dinamik bir dizi kullanarak hem baştan hem de sondan hızlı ekleme ve silme işlemleri sunar.
* Avantajları: LinkedList‘e göre genellikle daha hızlıdır ve null elemanlara izin vermez.
* Kullanım Senaryoları: Hem kuyruk hem de yığın (stack) olarak kullanılabilir.
Map Arayüzü
Map arayüzü, anahtar-değer çiftleri şeklinde veri depolayan bir koleksiyonu temsil eder. Her anahtar benzersizdir ve bir değere karşılık gelir. Map arayüzü, Collection arayüzünden türemez, ancak Koleksiyon Çatısı’nın temel bir parçasıdır.
HashMap
HashMap, Map arayüzünün en yaygın kullanılan uygulamasıdır. Dahili olarak bir hash tablosu kullanır.
* Avantajları: Anahtarlara göre değer ekleme, alma ve silme işlemleri ortalama olarak çok hızlıdır (O(1)).
* Dezavantajları: Anahtar-değer çiftlerinin sırasını garanti etmez. null anahtara ve null değerlere izin verir.
* Kullanım Senaryoları: Hızlı arama ve veri depolama için idealdir. hashCode() ve equals() metodlarının doğru implementasyonu, HashMap‘in düzgün çalışması için HashSet‘te olduğu gibi hayati öneme sahiptir.
Map hashMap = new HashMap<>();
hashMap.put("Ahmet", 30);
hashMap.put("Ayşe", 25);
System.out.println(hashMap.get("Ahmet")); // 30
System.out.println(hashMap.containsKey("Ayşe")); // true LinkedHashMap
LinkedHashMap, HashMap‘in bir alt sınıfıdır ve anahtar-değer çiftlerinin eklenme sırasını (insertion order) veya erişim sırasını (access order) korur. Dahili olarak bir hash tablosu ve çift yönlü bağlı liste kullanır.
* Avantajları: HashMap gibi hızlı işlemlere sahiptir ve anahtar-değer çiftlerinin eklenme sırasını korur.
* Kullanım Senaryoları: HashMap‘in hızına ihtiyaç duyulduğunda ve aynı zamanda anahtar-değer çiftlerinin sırasının önemli olduğu durumlarda kullanılır (örn. LRU cache implementasyonu).
TreeMap
TreeMap, anahtarları doğal sıralarına göre veya bir Comparator tarafından belirtilen sıraya göre sıralanmış bir şekilde depolar. Dahili olarak bir kırmızı-siyah ağaç (red-black tree) kullanır.
* Avantajları: Anahtarlar her zaman sıralı tutulur. Sıralı koleksiyonlara özgü metodlar sunar.
* Dezavantajları: Ekleme, silme ve arama işlemleri HashMap‘e göre daha yavaştır (O(log n)).
* Kullanım Senaryoları: Anahtarların her zaman sıralı olmasının gerektiği durumlarda kullanılır. TreeMap‘e eklenen anahtarların Comparable arayüzünü implement etmesi veya TreeMap oluşturulurken bir Comparator sağlanması gerekir.
Hashtable (Eski Nesil)
Hashtable, HashMap‘e benzer, ancak tüm metodları senkronizedir (thread-safe) ve null anahtarlara veya değerlere izin vermez. Vector gibi, senkronize olması nedeniyle tek iş parçacıklı senaryolarda HashMap‘ten daha yavaştır. Yeni kodlarda ConcurrentHashMap veya HashMap tercih edilir.
Yardımcı Sınıflar ve Araçlar
Collections Sınıfı
java.util.Collections sınıfı, koleksiyonlar üzerinde çeşitli statik yardımcı metodlar sağlar. Bu metodlar arasında koleksiyonları sıralama (sort()), tersine çevirme (reverse()), karıştırma (shuffle()), maksimum/minimum elemanı bulma (max(), min()), senkronize koleksiyonlar oluşturma (synchronizedList(), synchronizedSet(), synchronizedMap()) ve değiştirilemez (unmodifiable) koleksiyonlar oluşturma (unmodifiableList(), unmodifiableSet(), unmodifiableMap()) bulunur.
Arrays Sınıfı
java.util.Arrays sınıfı, diziler üzerinde benzer yardımcı metodlar sunar. Özellikle Arrays.asList() metodu, bir diziyi List‘e dönüştürmek için kullanışlıdır. Ancak bu metodun döndürdüğü List sabit boyutludur ve add() veya remove() gibi boyutunu değiştiren metodlar desteklemez.
Iterator ve ListIterator
Iterator arayüzü, bir koleksiyonun elemanları üzerinde gezinmek için standart bir yol sağlar. hasNext(), next() ve remove() metodlarını içerir. ListIterator, List arayüzüne özel bir iteratördür; hem ileri hem de geri yönde gezinmeye, eleman eklemeye, değiştirmeye ve indeks bilgilerine erişmeye olanak tanır.
Generics’in Önemi
Java 5 ile tanıtılan Generics (Jenerikler), Koleksiyon Çatısı’nı dönüştürmüştür. Generic’ler sayesinde koleksiyonlar, hangi türde elemanları tutacaklarını derleme zamanında belirtebilirler.
* Tür Güvenliği: Derleme zamanında tür kontrolü sağlayarak çalışma zamanı ClassCastException hatalarını önler.
* Kod Okunabilirliği: Hangi türde elemanların beklendiği açıkça belirtilir, bu da kodu daha anlaşılır hale getirir.
* Casting İhtiyacının Ortadan Kalkması: Elemanları alırken manuel casting yapmaya gerek kalmaz, bu da kodu daha temiz ve güvenli yapar.
// Generic'siz (eski yöntem)
List list = new ArrayList();
list.add("String");
list.add(123); // Derleme hatası vermez
String s = (String) list.get(0);
// String s2 = (String) list.get(1); // Çalışma zamanı ClassCastException
// Generic'li (önerilen yöntem)
List stringList = new ArrayList<>();
stringList.add("String");
// stringList.add(123); // Derleme hatası verir
String s3 = stringList.get(0); // Casting'e gerek yok Concurrency ve Thread Safety (Eşzamanlılık ve İş Parçacığı Güvenliği)
Java Koleksiyon Çatısı’ndaki standart uygulamaların çoğu (örn. ArrayList, HashMap, HashSet), varsayılan olarak iş parçacığı güvenli değildir. Yani birden fazla iş parçacığı aynı koleksiyona aynı anda erişmeye ve onu değiştirmeye çalıştığında beklenmedik sonuçlar (data corruption, infinite loops vb.) ortaya çıkabilir.
Senkronize Koleksiyonlar
Collections sınıfı, mevcut koleksiyonları iş parçacığı güvenli hale getirmek için senkronize sarıcı metodlar sunar: Collections.synchronizedList(), synchronizedSet(), synchronizedMap(). Bu metodlar, temel koleksiyonu bir kilit mekanizmasıyla sararak her erişimde senkronizasyon sağlar.
* Avantajları: Mevcut koleksiyonları kolayca thread-safe hale getirir.
* Dezavantajları: Tüm metod çağrıları üzerinde global bir kilit kullandığı için performans darboğazlarına neden olabilir, özellikle yüksek eşzamanlılık durumlarında ölçeklenemez.
java.util.concurrent Paketi
Java 5 ile tanıtılan java.util.concurrent paketi, yüksek performanslı ve ölçeklenebilir eşzamanlı koleksiyonlar sunar. Bu koleksiyonlar, genellikle daha ince taneli kilit mekanizmaları (fine-grained locking) veya kilitsiz (lock-free) algoritmalar kullanarak synchronized sarıcılardan daha iyi performans gösterir.
* ConcurrentHashMap: HashMap‘in eşzamanlı versiyonudur. Tüm haritayı kilitlemek yerine, veriyi segmentlere ayırır ve her segmenti ayrı ayrı kilitler. Bu, birden fazla iş parçacığının aynı anda farklı segmentlere erişmesine izin vererek performansı artırır.
* CopyOnWriteArrayList / CopyOnWriteArraySet: Bu koleksiyonlar, bir değişiklik (ekleme, silme) olduğunda temel dizinin bir kopyasını oluşturur. Okuma işlemleri için kilit gerekmez, bu da okuma ağırlıklı senaryolarda yüksek eşzamanlılık sağlar. Ancak yazma işlemleri maliyetlidir ve koleksiyon boyutu büyüdükçe performans düşer.
* BlockingQueue (örn. ArrayBlockingQueue, LinkedBlockingQueue): İş parçacıkları arasında veri alışverişi için kullanılan kuyruklardır. Kuyruk boşsa take() metodu, kuyruk doluysa put() metodu iş parçacığını bloke eder (bekletir), bu da üretici-tüketici desenleri için idealdir.
Eşzamanlı uygulamalarda, genellikle Collections.synchronizedXxx() metodları yerine java.util.concurrent paketindeki koleksiyonların kullanılması önerilir, çünkü bunlar daha iyi performans ve ölçeklenebilirlik sunar.
En İyi Uygulamalar ve İpuçları
Arayüzleri Kullanın, Uygulamaları Değil
Koleksiyonları bildirirken her zaman arayüz türünü kullanın (örn. List yerine ArrayList). Bu, kodunuzu daha esnek hale getirir. Gelecekte uygulamasını değiştirmek istediğinizde (örn. ArrayList‘ten LinkedList‘e), sadece nesneyi oluşturduğunuz satırı değiştirmeniz yeterli olur, geri kalan kod etkilenmez.
Doğru Koleksiyonu Seçin
Uygulamanızın gereksinimlerine göre doğru koleksiyonu seçmek performansı büyük ölçüde etkiler:
* Sıralı ve tekrar eden elemanlar: ArrayList (hızlı erişim) veya LinkedList (hızlı ekleme/silme).
* Benzersiz elemanlar: HashSet (hızlı işlem) veya TreeSet (sıralı).
* Anahtar-değer çiftleri: HashMap (hızlı işlem) veya TreeMap (sıralı anahtarlar).
* FIFO davranışı: LinkedList (Queue olarak) veya ArrayDeque.
* Öncelikli işlem: PriorityQueue.
* Eşzamanlılık: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue.
hashCode() ve equals() Metodlarının Doğru Implementasyonu
HashSet, HashMap ve LinkedHashSet gibi hash tabanlı koleksiyonlar kullanırken, özel nesnelerinizin hashCode() ve equals() metodlarını doğru bir şekilde override etmesi kritik öneme sahiptir. Yanlış implementasyonlar, koleksiyonların elemanları yanlış bir şekilde depolamasına, arama yapamamasına veya tekrar eden elemanlara izin vermesine neden olabilir.
Performans İpuçları: Başlangıç Kapasitesi
ArrayList ve HashMap gibi koleksiyonlar için, başlangıç kapasitesini (initial capacity) tahmin edebiliyorsanız belirtmek performansı artırabilir. Bu, koleksiyonun sık sık yeniden boyutlandırılmasını ve maliyetli eleman kopyalama işlemlerini önler.
// 100 eleman içereceği tahmin ediliyorsa
List list = new ArrayList<>(100);
Map map = new HashMap<>(100); Değiştirilemez (Immutable) Koleksiyonlar (Java 9+)
Java 9 ve sonraki sürümler, List.of(), Set.of() ve Map.of() gibi fabrika metodları aracılığıyla kolayca değiştirilemez koleksiyonlar oluşturma imkanı sunar. Bu koleksiyonlar oluşturulduktan sonra elemanları eklenemez, çıkarılamaz veya değiştirilemez. Değiştirilemez koleksiyonlar, iş parçacığı güvenliği sağlar, kodun anlaşılırlığını artırır ve hataları azaltır.
List immutableList = List.of("Elma", "Armut", "Kiraz");
// immutableList.add("Muz"); // UnsupportedOperationException atar Stream API ile Koleksiyonları İşlemek (Java 8+)
Java 8 ile tanıtılan Stream API, koleksiyonlar üzerinde fonksiyonel programlama tarzında güçlü ve ifade edici işlemler yapmayı sağlar. Filtreleme, dönüştürme, gruplama gibi karmaşık işlemleri daha okunabilir ve paralel olarak gerçekleştirme yeteneği sunar.
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List evenNumbersSquared = numbers.stream()
.filter(n -> n % 2 == 0) // Çift sayıları filtrele
.map(n -> n * n) // Karelerini al
.collect(Collectors.toList()); // Yeni bir Listeye topla
System.out.println(evenNumbersSquared); // [4, 16, 36, 64, 100] Sonuç
Java Koleksiyon Çatısı, Java programlama dilinin en güçlü ve en sık kullanılan özelliklerinden biridir. Sağladığı zengin arayüz ve uygulama seti sayesinde geliştiriciler, çeşitli veri yönetimi ihtiyaçları için sağlam ve performanslı çözümler üretebilirler. List, Set, Queue ve Map gibi temel arayüzleri, bunların ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap gibi popüler uygulamalarını ve her birinin kendine özgü avantaj ve dezavantajlarını anlamak, etkili Java kodu yazmanın anahtarıdır.
Generics’in sağladığı tür güvenliği, java.util.concurrent paketinin sunduğu eşzamanlılık çözümleri ve Collections sınıfının yardımcı metodları, Koleksiyon Çatısı’nı daha da güçlü kılar. Ayrıca, Java 8 ile gelen Stream API ve Java 9 ile tanıtılan değiştirilemez koleksiyonlar gibi modern özellikler, koleksiyonlarla çalışmayı daha verimli ve keyifli hale getirmiştir.
Doğru koleksiyonu seçmek, hashCode() ve equals() metodlarını doğru implemente etmek, arayüzleri kullanmak ve eşzamanlılık gerektiren durumlarda uygun concurrent koleksiyonları tercih etmek, Java geliştiricisi olarak bilmeniz gereken “olmazsa olmaz” bilgilerdir. Bu bilgilerle donanmış olarak, daha sağlam, performanslı ve sürdürülebilir Java uygulamaları geliştirebilirsiniz.