Java Koleksiyonları Hızlı Başvuru Kılavuzu: Örneklerle

Java geliştiricileri için veri yönetimi, modern uygulamaların kalbinde yer alır. Ancak bu kadar çok veri yapısı seçeneği varken, doğru koleksiyonu seçmek ve en verimli şekilde kullanmak bazen kafa karıştırıcı olabilir. Bu kapsamlı kılavuz, Java Koleksiyon Çerçevesi’nin temelden ileri seviyeye tüm yönlerini örneklerle açıklayarak, veri yapılarını ustalıkla kullanmanız için size yol gösterecektir.

Java’da birbiriyle ilişkili verileri düzenlemek, depolamak ve üzerinde işlem yapmak için kullanılan yapılar topluluğuna Java Koleksiyon Çerçevesi (Java Collections Framework – JCF) adı verilir. Peki, neden bu kadar önemli? Tek kelimeyle: verimlilik ve standardizasyon. JCF, verileri yönetmek için kanıtlanmış, yüksek performanslı algoritmalar ve veri yapıları sunar. Böylece geliştiriciler tekerleği yeniden icat etmek yerine, doğrudan iş mantığına odaklanabilirler.

Bir program düşünün ki, müşterilerin siparişlerini, öğrencilerin notlarını veya bir e-ticaret sitesindeki ürünleri depolaması gerekiyor. Bu verilerin her birini ayrı ayrı değişkenlerde tutmak imkansız ve yönetilemez bir durum yaratır. İşte burada koleksiyonlar devreye girer. Ortak bir arayüz kümesi (List, Set, Queue, Map gibi) ve bu arayüzleri uygulayan sınıflar (ArrayList, HashSet, HashMap vb.) sayesinde, verileri istediğimiz mantığa uygun şekilde depolayabilir, sıralayabilir, arayabilir ve üzerinde karmaşık işlemler yapabiliriz.

Koleksiyon Çerçevesi’nin temel bileşenleri, veri yapılarını soyutlayan arayüzler ve bu arayüzleri somutlaştıran sınıflardır. Bu hiyerarşi, kodu daha esnek ve bakımı kolay hale getirir. Örneğin, bir metot parametresini List olarak tanımladığınızda, bu metoda hem ArrayList hem de LinkedList nesneleri gönderebilirsiniz, böylece veri yapısının altındaki detaylara takılmadan genel bir yaklaşım benimsemiş olursunuz. Ayrıca, JCF sayesinde veri tutarlılığı, erişim performansı ve hafıza kullanımı gibi kritik konular standart bir yaklaşımla ele alınır. Böylece uygulamanızın daha sağlam ve ölçeklenebilir olmasını sağlarsınız.

Özünde, JCF, karmaşık veri yönetimi görevlerini basitleştiren güçlü bir araç kutusudur. İster basit bir sayı listesi, ister benzersiz kullanıcı kimlikleri, ister anahtar-değer çiftlerinden oluşan bir yapı olsun, Java Koleksiyon Çerçevesi size uygun çözümü sunar. Bu araçların nasıl kullanılacağını anlamak, her Java geliştiricisinin temel yeteneklerinden biri olmalıdır. Bu kılavuzun ilerleyen bölümlerinde, bu temel arayüzleri ve onların popüler uygulamalarını detaylı örneklerle inceleyeceğiz.

JCF’nin sunduğu temel arayüzler şunlardır:

• Collection: Tüm koleksiyonların kök arayüzüdür. Temel ekleme, silme, kontrol etme gibi işlemleri tanımlar.
• List: Verilerin sıralı olduğu ve tekrarlı elemanlara izin veren bir koleksiyondur. Elemanlara indeksleri üzerinden erişilebilir.
• Set: Benzersiz elemanlar kümesidir. Tekrarlı elemanlara izin vermez ve genellikle elemanların belirli bir sıralaması yoktur.
• Queue: FIFO (First-In, First-Out) prensibine göre çalışan bir koleksiyondur. Sıra tabanlı işlemlerde kullanılır.
• Map: Anahtar-değer çiftlerini depolayan bir yapıdır. Her anahtar benzersizdir ve bir değere karşılık gelir. Collection arayüzünden türemez, ancak koleksiyon çerçevesinin ayrılmaz bir parçasıdır.

Bu arayüzleri derinlemesine anlamak, uygulamanız için en uygun veri yapısını seçmenize yardımcı olacaktır. Hangi durumda hangi yapıyı kullanmanız gerektiğini bilmek, performans sorunlarının önüne geçebilir ve kodunuzu daha okunabilir hale getirebilir.

List Arayüzü ile Verileri Sıralı Bir Şekilde Nasıl Yönetiriz?

List arayüzü, Java Koleksiyon Çerçevesi’nin en sık kullanılan ve belki de en sezgisel parçalarından biridir. Adından da anlaşılacağı gibi, elemanları belirli bir sırayla tutan bir koleksiyondur. Tıpkı gerçek dünyadaki bir alışveriş listesi veya yapılacaklar listesi gibi, elemanların eklenme sırası korunur ve aynı eleman birden fazla kez listeye eklenebilir. List‘ler, elemanlara indeksleri (0’dan başlayarak) üzerinden erişim imkanı sunar, bu da belirli bir konumdaki elemana doğrudan ulaşmayı veya elemanları belirli bir düzende işlemeyi çok kolaylaştırır.

List arayüzünün iki popüler uygulaması vardır: ArrayList ve LinkedList. Her ikisi de List davranışını sunsa da, dahili implementasyonları ve dolayısıyla performans karakteristikleri farklılık gösterir:

• ArrayList: Dahili olarak dinamik bir dizi (array) kullanır. Elemanlara indeksleri üzerinden erişim (get(index)) çok hızlıdır (O(1) zaman karmaşıklığına sahiptir). Ancak listenin ortasına eleman eklemek veya silmek (çünkü diğer elemanların kaydırılması gerekir) daha yavaştır (O(n) zaman karmaşıklığı). Büyük miktarda rastgele erişim gerektiren ve çok sık ekleme/silme işlemi yapılmayan durumlarda idealdir.
• LinkedList: Dahili olarak çift yönlü bağlı liste (doubly linked list) kullanır. Eleman ekleme veya silme işlemleri (listenin başı veya sonundan) çok hızlıdır (O(1)). Ancak belirli bir indekse erişmek için listenin başından veya sonundan başlayarak ilgili elemana kadar ilerlemesi gerektiği için daha yavaştır (O(n)). Sık sık eleman ekleme veya silme işlemi yapılan ve rastgele erişimin az olduğu durumlarda tercih edilir.

Vaka Analizi: Bir Müşteri Sipariş Listesi Yönetimi

Bir e-ticaret uygulamasında, bir müşterinin verdiği siparişleri tutmamız gerektiğini varsayalım. Her siparişin bir sıra numarası ve detayı olsun. Müşteri, siparişlerinin hem eklenme sırasına göre listelenmesini istiyor hem de belirli bir siparişi indeksine göre hızla görüntülemek isteyebilir. Bu senaryo için ArrayList mükemmel bir seçimdir:

import java.util.ArrayList;
import java.util.List;

class Siparis {
    private int siparisKodu;
    private String urunAdi;
    private double fiyat;

    public Siparis(int siparisKodu, String urunAdi, double fiyat) {
        this.siparisKodu = siparisKodu;
        this.urunAdi = urunAdi;
        this.fiyat = fiyat;
    }

    @Override
    public String toString() {
        return "Siparis Kodu: " + siparisKodu + ", Ürün: " + urunAdi + ", Fiyat: " + fiyat + " TL";
    }

    // Getter metotları...
    public int getSiparisKodu() { return siparisKodu; }
    public String getUrunAdi() { return urunAdi; }
    public double getFiyat() { return fiyat; }
}

public class SiparisYonetimi {
    public static void main(String[] args) {
        // Bir ArrayList oluşturarak siparişleri tutalım
        List musteriSiparisleri = new ArrayList<>();

        // Siparişleri ekleyelim
        musteriSiparisleri.add(new Siparis(101, "Laptop", 15000.0));
        musteriSiparisleri.add(new Siparis(102, "Mouse", 250.0));
        musteriSiparisleri.add(new Siparis(103, "Klavye", 500.0));
        musteriSiparisleri.add(new Siparis(102, "Mouse", 250.0)); // Tekrarlı ekleme mümkün

        System.out.println("Müşterinin Tüm Siparişleri:");
        for (Siparis s : musteriSiparisleri) {
            System.out.println(s);
        }

        // Belirli bir indeksteki siparişe erişim (çok hızlı)
        System.out.println("\nİlk Sipariş: " + musteriSiparisleri.get(0));
        System.out.println("Üçüncü Sipariş: " + musteriSiparisleri.get(2));

        // Ortadan bir siparişi güncelleme (yavaş olabilir)
        musteriSiparisleri.set(1, new Siparis(104, "Harici Disk", 1200.0));
        System.out.println("\nGüncellenmiş İkinci Sipariş:");
        System.out.println(musteriSiparisleri.get(1));

        // Bir siparişi silme
        musteriSiparisleri.remove(3); // 4. elemanı (indeks 3) sil
        System.out.println("\n3. indeksteki sipariş silindikten sonra kalan siparişler:");
        musteriSiparisleri.forEach(System.out::println);
        
        System.out.println("\nToplam sipariş sayısı: " + musteriSiparisleri.size());
        System.out.println("Siparişler boş mu? " + musteriSiparisleri.isEmpty());
    }
}
    

Yukarıdaki örnekte ArrayList'in esnekliğini ve kullanım kolaylığını görüyoruz. add(), get(), set() ve remove() gibi temel metotlarla siparişlerimizi kolayca yönetebiliyoruz. Eğer uygulamanızda sıkça listenin başına veya ortasına eleman ekleme/silme operasyonları yapıyorsanız, o zaman LinkedList daha performanslı bir alternatif olabilir. Örneğin, bir müzik çaların "şimdi çalanlar" listesi gibi, şarkılar sürekli eklenip çıkarılıyorsa LinkedList daha mantıklı olacaktır.

Set Arayüzü ile Benzersiz Veri Kümeleri Nasıl Oluşturulur?

Java Koleksiyon Çerçevesi'ndeki Set arayüzü, matematikteki küme kavramının dijital karşılığıdır: benzersiz elemanlardan oluşan bir koleksiyon. Bir Set'e aynı elemanı iki kez eklemeye çalıştığınızda, ikincisi yok sayılır. Bu özellik, özellikle tekrarlayan verileri filtrelemek veya belirli bir koleksiyonda yalnızca eşsiz değerlerin bulunmasını sağlamak istediğinizde oldukça kullanışlıdır. Set'lerin çoğu, elemanların eklenme sırasını garantilemez, yani elemanlara belirli bir indeks üzerinden erişemezsiniz.

Set arayüzünün üç ana uygulaması vardır ve her birinin farklı özellikleri ve performans karakteristikleri bulunur:

• HashSet: Elemanların sırasını garanti etmez ve null eleman kabul eder. En hızlı Set implementasyonudur çünkü elemanları depolamak için hash tabloları kullanır. Eleman ekleme, silme ve arama işlemleri ortalama O(1) zaman karmaşıklığına sahiptir. En çok genel amaçlı benzersiz eleman depolama için tercih edilir.
• LinkedHashSet: HashSet'in tüm özelliklerini taşır ancak elemanların eklenme sırasını korur (insertion order). Bu, elemanlara eklediğiniz sırayla erişmek istediğiniz ancak yine de benzersizlik gereksinimi duyduğunuz senaryolarda kullanışlıdır. Performans olarak HashSet'e göre biraz daha yavaştır.
• TreeSet: Elemanları doğal sıralarına göre veya belirtilen bir Comparator ile sıralı bir şekilde tutar. Elemanlar "sorted" bir şekilde saklandığı için, her ekleme, silme ve arama işlemi O(log n) zaman karmaşıklığına sahiptir. Sıralı benzersiz elemanlara ihtiyacınız olduğunda idealdir. Null elemana izin vermez.

Vaka Analizi: Benzersiz Ziyaretçi Kimlikleri

Bir web sitesinin analitik sisteminde, siteyi ziyaret eden tekil kullanıcıların IP adreslerini veya oturum kimliklerini depolamamız gerektiğini varsayalım. Aynı kullanıcının birden fazla kez ziyaret etmesi durumunda, onu sadece bir kez saymak isteriz. Bu senaryoda Set, özellikle HashSet, mükemmel bir çözümdür.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class ZiyaretciTakibi {
    public static void main(String[] args) {
        // HashSet ile benzersiz ziyaretçi IP'lerini tutalım
        Set uniqueIps = new HashSet<>();

        System.out.println("--- HashSet Kullanımı (Sıra Garantisi Yok) ---");
        uniqueIps.add("192.168.1.1");
        uniqueIps.add("10.0.0.5");
        uniqueIps.add("192.168.1.1"); // Bu eklenmeyecek, çünkü zaten var
        uniqueIps.add("172.16.0.10");
        uniqueIps.add("10.0.0.5"); // Bu da eklenmeyecek

        System.out.println("Benzersiz IP Adresleri:");
        uniqueIps.forEach(System.out::println);
        System.out.println("Toplam benzersiz IP sayısı: " + uniqueIps.size()); // 3 olmalı

        System.out.println("10.0.0.5 adresi mevcut mu? " + uniqueIps.contains("10.0.0.5"));
        System.out.println("192.168.1.2 adresi mevcut mu? " + uniqueIps.contains("192.168.1.2"));

        uniqueIps.remove("192.168.1.1");
        System.out.println("\n'192.168.1.1' silindikten sonra kalan IP'ler:");
        uniqueIps.forEach(System.out::println);

        System.out.println("\n--- LinkedHashSet Kullanımı (Ekleme Sırası Korunur) ---");
        Set orderedIps = new LinkedHashSet<>();
        orderedIps.add("192.168.1.1");
        orderedIps.add("10.0.0.5");
        orderedIps.add("172.16.0.10");
        orderedIps.add("192.168.1.1"); // Bu eklenmeyecek

        System.out.println("Ekleme sırasına göre benzersiz IP Adresleri:");
        orderedIps.forEach(System.out::println);

        System.out.println("\n--- TreeSet Kullanımı (Doğal Sıraya Göre Sıralı) ---");
        Set sortedIps = new TreeSet<>();
        sortedIps.add("192.168.1.1");
        sortedIps.add("10.0.0.5");
        sortedIps.add("172.16.0.10");
        sortedIps.add("10.0.0.5"); // Bu eklenmeyecek

        System.out.println("Alfabetik sıraya göre benzersiz IP Adresleri:");
        sortedIps.forEach(System.out::println);
    }
}
    

Bu örnekte, aynı IP adreslerinin HashSet, LinkedHashSet ve TreeSet tarafından nasıl işlendiğini görüyoruz. HashSet ve LinkedHashSet, benzersizlik özelliğini korurken, LinkedHashSet ekleme sırasını garantiler. TreeSet ise elemanları doğal sıralarına göre (alfabetik olarak) düzenler. Hangi Set implementasyonunu kullanacağınız, ihtiyaçlarınıza bağlıdır: sadece benzersizlik yeterliyse HashSet, ekleme sırası da önemliyse LinkedHashSet, sıralı benzersiz elemanlar gerekiyorsa TreeSet tercih edilmelidir.

Set'ler, elemanları hızlı bir şekilde kontrol etmek (contains() metodu) için idealdir. Örneğin, bir kullanıcının belirli bir rolü olup olmadığını kontrol etmek veya bir veri kümesindeki yinelenen kayıtları temizlemek için etkili bir yöntem sunarlar. Ayrıca, iki küme arasındaki kesişim, birleşim veya fark gibi matematiksel küme işlemlerini gerçekleştirmek için de Set arayüzünün metotları oldukça işlevseldir.

Map Yapıları: Anahtar-Değer Çiftlerini Etkili Bir Şekilde Nasıl Depolarız?

Map arayüzü, Java Koleksiyon Çerçevesi'nin en güçlü ve esnek veri yapılarından biridir, ancak teknik olarak Collection arayüzünden türemez. Map'ler, verileri bir anahtar-değer çifti (key-value pair) şeklinde depolarlar. Her anahtar benzersizdir ve yalnızca bir değere karşılık gelir. Tıpkı bir sözlük gibi düşünebilirsiniz: bir kelime (anahtar) ve onun anlamı (değer). Bu yapı, belirli bir anahtar aracılığıyla değere hızlıca erişme imkanı sunduğu için çok çeşitli senaryolarda kullanılır.

Map arayüzünün üç ana implementasyonu vardır:

• HashMap: Anahtar-değer çiftlerini depolamak için hash tabloları kullanır. Anahtarların veya değerlerin eklenme sırasını garanti etmez. En hızlı Map implementasyonudur; put(), get() ve remove() işlemleri ortalama O(1) zaman karmaşıklığına sahiptir. Genel amaçlı anahtar-değer depolama için en sık kullanılan Map türüdür. Hem anahtar hem de değer olarak null kabul eder (sadece bir null anahtar).
• LinkedHashMap: HashMap'in tüm özelliklerini taşır ancak elemanların eklenme sırasını korur (insertion order). Bu sayede, anahtar-değer çiftlerine eklediğiniz sırayla erişebilirsiniz. HashMap'e göre biraz daha yavaştır ancak sıralı erişim gerektiğinde tercih edilir.
• TreeMap: Anahtarları doğal sıralarına göre veya belirtilen bir Comparator ile sıralı bir şekilde tutar. SortedMap arayüzünü uygular ve bu sayede anahtarlar her zaman sıralıdır. Eleman ekleme, silme ve arama işlemleri O(log n) zaman karmaşıklığına sahiptir. Anahtarların null olmasına izin vermez.

Vaka Analizi: Ürün Stok Takibi Uygulaması

Bir depodaki ürünlerin stok miktarını takip ettiğimiz bir senaryo düşünelim. Her ürünün benzersiz bir stok kodu (SKU) ve bu koda karşılık gelen stok miktarı olsun. Stok kodunu kullanarak belirli bir ürünün miktarını hızla sorgulamak veya güncellemek isteriz. Bu durumda HashMap, hızlı erişim ve kolay yönetim sağladığı için en ideal çözümdür.

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class UrunStokTakibi {
    public static void main(String[] args) {
        // HashMap ile ürün stoklarını tutalım: SKU (Anahtar) -> Miktar (Değer)
        Map urunStoklari = new HashMap<>();

        System.out.println("--- HashMap Kullanımı (Sıra Garantisi Yok) ---");
        // Ürün ekleme
        urunStoklari.put("LAPTOP001", 50);
        urunStoklari.put("MOUSE005", 120);
        urunStoklari.put("KEYB010", 80);
        urunStoklari.put("MONITOR003", 30);

        System.out.println("Mevcut Ürün Stokları:");
        // Map'i iterate etmenin farklı yolları
        for (Map.Entry entry : urunStoklari.entrySet()) {
            System.out.println("SKU: " + entry.getKey() + ", Stok: " + entry.getValue());
        }

        // Belirli bir ürünün stoğunu sorgulama
        String arananSKU = "MOUSE005";
        if (urunStoklari.containsKey(arananSKU)) {
            System.out.println("\n" + arananSKU + " stok miktarı: " + urunStoklari.get(aranananSKU));
        } else {
            System.out.println("\n" + arananSKU + " bulunamadı.");
        }

        // Stok güncelleme
        urunStoklari.put("LAPTOP001", 45); // Var olan anahtara yeni değer atamak güncellemeyi sağlar
        System.out.println("LAPTOP001 güncel stok: " + urunStoklari.get("LAPTOP001"));

        // Ürün silme
        urunStoklari.remove("KEYB010");
        System.out.println("\nKEYB010 silindikten sonra kalan stoklar:");
        urunStoklari.forEach((sku, stok) -> System.out.println("SKU: " + sku + ", Stok: " + stok));

        System.out.println("\n--- LinkedHashMap Kullanımı (Ekleme Sırası Korunur) ---");
        Map orderedUrunStoklari = new LinkedHashMap<>();
        orderedUrunStoklari.put("LAPTOP001", 50);
        orderedUrunStoklari.put("MOUSE005", 120);
        orderedUrunStoklari.put("KEYB010", 80);
        orderedUrunStoklari.put("MONITOR003", 30);
        System.out.println("Ekleme sırasına göre Ürün Stokları:");
        orderedUrunStoklari.forEach((sku, stok) -> System.out.println("SKU: " + sku + ", Stok: " + stok));

        System.out.println("\n--- TreeMap Kullanımı (Anahtarlara Göre Sıralı) ---");
        Map sortedUrunStoklari = new TreeMap<>();
        sortedUrunStoklari.put("LAPTOP001", 50);
        sortedUrunStoklari.put("MOUSE005", 120);
        sortedUrunStoklari.put("KEYB010", 80);
        sortedUrunStoklari.put("MONITOR003", 30);
        System.out.println("SKU'ya göre alfabetik sıralı Ürün Stokları:");
        sortedUrunStoklari.forEach((sku, stok) -> System.out.println("SKU: " + sku + ", Stok: " + stok));
    }
}
    

Bu örnek, HashMap'in anahtar-değer çiftlerini nasıl hızlıca yönettiğini gösteriyor. put() metodu hem yeni eleman eklemek hem de var olan bir anahtarın değerini güncellemek için kullanılır. get() metodu ile anahtarı kullanarak değere hızlıca ulaşırız. containsKey() ile bir anahtarın varlığını kontrol edebilir, remove() ile elemanları silebiliriz. Ayrıca, bir Map'in tüm anahtarlarını (keySet()), değerlerini (values()) veya hem anahtar hem de değer çiftlerini (entrySet()) alarak üzerinde döngü yapabiliriz.

Map'ler, bir veritabanından alınan kayıtları geçici olarak bellekte tutmak, bir uygulamanın konfigürasyon ayarlarını yönetmek veya bir nesnenin özelliklerini dinamik olarak saklamak gibi birçok senaryoda vazgeçilmezdir. Doğru Map implementasyonunu seçmek, uygulamanızın performansını doğrudan etkileyecektir. Genel olarak hızlı erişim öncelikliyse HashMap, ekleme sırası önemliyse LinkedHashMap, anahtarların sıralı olması gerekiyorsa TreeMap tercih edilmelidir.

Koleksiyonlarda Performans ve Güvenlik: İleri Düzey İpuçları Nelerdir?

Java Koleksiyon Çerçevesi'ni sadece temel düzeyde kullanmak yeterli değildir; uygulamanızın performansını ve güvenliğini artırmak için bazı ileri düzey konulara hakim olmak kritik öneme sahiptir. Bu bölümde, koleksiyonları daha etkin kullanmanıza yardımcı olacak önemli ipuçlarına ve kavramlara değineceğiz.

Generics (Jenerikler) Kullanımının Önemi

Java 5 ile tanıtılan Generics, koleksiyonların tip güvenliğini artırmanın temel yoludur. Koleksiyonları jenerik tiplerle (örn. List veya Map) tanımladığınızda, derleme zamanında tip kontrolü yapılır ve çalışma zamanında oluşabilecek ClassCastException gibi hataların önüne geçilir. Ayrıca, kodu daha okunabilir ve anlaşılır hale getirir.

// Jeneriksiz kullanım (tip güvenliği yok, cast gerekli)
List rawList = new ArrayList();
rawList.add("Merhaba");
rawList.add(123); // Hata yok, ama çalışma zamanında sorun çıkarabilir

String s = (String) rawList.get(0);
// Integer i = (String) rawList.get(1); // Çalışma zamanı hatası (ClassCastException)

// Jenerikli kullanım (tip güvenliği var)
List stringList = new ArrayList<>();
stringList.add("Dünya");
// stringList.add(456); // Derleme zamanı hatası: Integer, String'e dönüştürülemez

String s2 = stringList.get(0); // Cast gerekmez, kod daha temiz
    

Jenerikler, koleksiyonlarınızın sadece belirli bir türdeki nesneleri depolamasını garanti ederek kodunuzu daha sağlam hale getirir ve geliştirme sürecindeki hataları erken aşamada tespit etmenize olanak tanır.

Iterator ile Güvenli Gezinti

Koleksiyonlar üzerinde döngü yapmanın birden fazla yolu vardır (enhanced for loop, forEach metodu). Ancak bazı durumlarda, özellikle döngü sırasında koleksiyonu değiştirmeye çalıştığınızda, Iterator kullanmak en güvenli yoldur. Iterator, bir koleksiyonun elemanları üzerinde güvenli bir şekilde gezinmenizi ve aynı zamanda elemanları silmenizi sağlar. Doğrudan döngü içinde koleksiyondan eleman silmeye çalışmak, ConcurrentModificationException hatasına yol açabilir.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorKullanimi {
    public static void main(String[] args) {
        List sehirler = new ArrayList<>();
        sehirler.add("Ankara");
        sehirler.add("İstanbul");
        sehirler.add("İzmir");
        sehirler.add("Bursa");
        sehirler.add("Antalya");

        Iterator iterator = sehirler.iterator();
        while (iterator.hasNext()) {
            String sehir = iterator.next();
            System.out.println("Şehir: " + sehir);
            if (sehir.equals("İzmir")) {
                iterator.remove(); // Koleksiyondan güvenli bir şekilde eleman silme
                System.out.println("İzmir silindi!");
            }
        }
        System.out.println("\nGüncel Şehir Listesi: " + sehirler);

        // Hata örneği: for-each döngüsü içinde koleksiyonu değiştirmek
        try {
            for (String s : sehirler) {
                if (s.equals("Bursa")) {
                    sehirler.remove(s); // ConcurrentModificationException fırlatır
                }
            }
        } catch (Exception e) {
            System.err.println("\nHata oluştu: " + e.getMessage());
        }
    }
}
    

Thread-Safe (İş Parçacığı Güvenli) Koleksiyonlar

Çoklu iş parçacıklı (multi-threaded) ortamlarda, birden fazla iş parçacığının aynı anda bir koleksiyona erişip onu değiştirmeye çalışması veri tutarsızlığına yol açabilir. Bu tür senaryolar için Java, özel thread-safe koleksiyonlar sunar:

• Collections.synchronizedList(), synchronizedSet(), synchronizedMap(): Mevcut koleksiyonları iş parçacığı güvenli hale getirmek için kullanılan sarmalayıcı (wrapper) metotlardır. Her erişimden önce kilitleme (locking) mekanizması kullanır.
• ConcurrentHashMap: HashMap'in yüksek performanslı, thread-safe versiyonudur. Tüm map'i kilitlemek yerine, sadece ilgili bölümleri kilitler (segment locking) ve bu sayede daha iyi eşzamanlılık (concurrency) sağlar.
• CopyOnWriteArrayList, CopyOnWriteArraySet: Bu koleksiyonlar, bir değişiklik (ekleme, silme) olduğunda temel dizinin/kümenin yeni bir kopyasını oluşturur. Okuma işlemleri çok hızlıdır çünkü kilitlenmeye gerek yoktur. Ancak yazma işlemleri maliyetlidir, bu nedenle okuma işlemlerinin yazma işlemlerinden çok daha fazla olduğu durumlarda kullanılırlar.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ThreadSafeKoleksiyonlar {
    public static void main(String[] args) {
        // synchronizedList ile thread-safe bir List
        List senkronizeList = Collections.synchronizedList(new ArrayList<>());
        senkronizeList.add("Eleman 1");
        senkronizeList.add("Eleman 2");
        // Birden fazla thread bu listeye güvenle erişebilir ve değişiklik yapabilir

        // ConcurrentHashMap ile thread-safe bir Map
        Map concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("AnahtarA", 1);
        concurrentMap.put("AnahtarB", 2);
        // Bu map, yüksek eşzamanlılık gerektiren uygulamalarda tercih edilir
        System.out.println("Concurrent Map: " + concurrentMap);
    }
}
    

Değişmez (Immutable) Koleksiyonlar

Java 9'dan itibaren, List.of(), Set.of() ve Map.of() metotları ile kolayca değişmez (immutable) koleksiyonlar oluşturmak mümkündür. Değişmez koleksiyonlar oluşturulduktan sonra içeriği değiştirilemez. Bu, özellikle güvenlik, thread-safety ve kodun daha öngörülebilir olması açısından avantajlar sunar.

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ImmutableKoleksiyonlar {
    public static void main(String[] args) {
        // Değişmez List
        List immutableList = List.of("Elma", "Armut", "Kiraz");
        System.out.println("Değişmez Liste: " + immutableList);
        // immutableList.add("Muz"); // UnsupportedOperationException hatası verir

        // Değişmez Set
        Set immutableSet = Set.of(1, 2, 3);
        System.out.println("Değişmez Küme: " + immutableSet);

        // Değişmez Map
        Map immutableMap = Map.of("TR", "Türkiye", "US", "Amerika");
        System.out.println("Değişmez Map: " + immutableMap);
    }
}
    

Değişmez koleksiyonlar, özellikle birden fazla iş parçacığı arasında veri paylaşılırken kilit mekanizmalarına ihtiyaç duymadıkları için performans avantajı sağlayabilir ve hata yapma olasılığını azaltır.

@media (max-width: 768px) {
  pre code {
    white-space: pre-wrap; /* Uzun satırları otomatik sarar */
    word-break: break-all; /* Gerekirse kelimeleri böler */
    overflow-x: auto; /* Yatay kaydırma çubuğu ekler */
    display: block;
    width: 100%;
  }
}
        

 etiketlerinizin davranışını değiştirir. Uzun kod satırları otomatik olarak bir alt satıra geçer ve gerekirse yatay kaydırma çubuğu görünür, böylece mobil cihazlarda okuma deneyimi iyileşir.