• Koleksiyon (collection): birden çok öğeyi tek bir nesnede saklayan ve yöneten veri yapısıdır.
• Java Koleksiyon Çerçevesi (Java Collections Framework): java.util paketindeki hazır arayüzler, sınıflar ve algoritmalar.
• Veri saklamak, sıralamak, aramak ve işlemek için güçlü, test edilmiş, performans ve güvenlik açısından optimize edilmiş araçlar sunar.
• Diziden farkı: boyut dinamiktir; add, remove, contains gibi hazır metotlar vardır.
• Doğru yapıyı seçmek önemlidir: her koleksiyon türü farklı bir ihtiyaca göre tasarlanmıştır.

Dizi: boyut baştan sabit

int[] dizi = new int[3];      // boyut sabit: 3
dizi[0] = 10;
dizi[1] = 20;
dizi[2] = 30;
// dizi[3] = 40;  → ArrayIndexOutOfBoundsException

Liste: gerektikçe büyür

List<Integer> liste = new ArrayList<>();
liste.add(10);
liste.add(20);
liste.add(30);
liste.add(40);       // sorun yok: büyür
System.out.println(liste);
System.out.println("boyut: " + liste.size());

[10, 20, 30, 40]
boyut: 4

• Arayüz bir davranışı tanımlar; sınıflar bu davranışı kendi yöntemleriyle uygular.
• Farklı depolama türleri: ArrayList dinamik dizi, LinkedList çift yönlü bağlı liste, HashMap anahtar-değer tablosu.
• Her sınıf belirli bir veri yapısının gereksinimlerini karşılar ve belirli bir görevi yerine getirir.
• Değişkeni ve parametreyi arayüz türünde tanımlayın: uygulamayı tek satırda değiştirebilirsiniz; kodun geri kalanı ve temel davranış aynı kalır.

public class ListeYazdir {
    // Parametre türü arayüz: her List ile çalışır
    static void yazdir(List<String> liste) {
        for (String s : liste) {
            System.out.print(s + " ");
        }
        System.out.println("(" + liste.size() + " öğe)");
    }

    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("Elma");
        a.add("Armut");
        List<String> b = new LinkedList<>(a);  // aynı öğeler
        b.add("Kiraz");
        yazdir(a);
        yazdir(b);
    }
}

Elma Armut (2 öğe)
Elma Armut Kiraz (3 öğe)

List<String> isimler = new ArrayList<>();
isimler.add("Ali");
// isimler.add(42);           // derleme hatası
String ilk = isimler.get(0);  // tür dönüşümü gerekmez

List<Integer> notlar = new ArrayList<>();  // List<int> olmaz
notlar.add(85);               // kutulama: int → Integer
int n = notlar.get(0);        // kutu açma: Integer → int
System.out.println(ilk + " " + n);

Ali 85

• <> içine öğe türü yazılır: List<String> “String listesi” demektir.
• Yanlış tür derleme anında yakalanır; get sonucu için tür dönüşümü (cast) gerekmez.
• Sağdaki boş <>: elmas (diamond) işleci, Java 7+; tür soldan çıkarılır.

Koleksiyonlar yalnızca nesne tutar

İlkel türler için sarmalayıcı (wrapper) sınıf kullanılır. Dönüşüm otomatiktir: otomatik kutulama (autoboxing) ve kutu açma (unboxing).

// İsim listesi (ArrayList)
List<String> isimListesi = new ArrayList<>();
isimListesi.add("Ahmet");
isimListesi.add("Ayşe");
System.out.println(isimListesi);

// Telefon rehberi (HashMap)
Map<String, String> telefonRehberi = new HashMap<>();
telefonRehberi.put("Ahmet", "555-1234");
telefonRehberi.put("Ayşe", "555-9876");
System.out.println(telefonRehberi.get("Ahmet"));

[Ahmet, Ayşe]
555-1234

• İsim listesi: ArrayList öğeleri eklenme sırasıyla tutar; add sona ekler.
• Telefon rehberi: HashMap bir anahtarı (isim) bir değere (numara) eşler.
• put(anahtar, değer) ile ekleriz, get(anahtar) ile değeri buluruz.
• Listeyi println ile yazdırmak öğeleri [ … ] içinde gösterir.

Collection<String> renkler = new ArrayList<>();
renkler.add("kırmızı");
renkler.add("yeşil");
renkler.add("mavi");
System.out.println(renkler.size());
System.out.println(renkler.contains("yeşil"));
renkler.remove("yeşil");
System.out.println(renkler);
Collection<String> aranan = Arrays.asList("mavi", "kırmızı");
System.out.println(renkler.containsAll(aranan));
Object[] dizi = renkler.toArray();
System.out.println(dizi.length);
renkler.clear();
System.out.println(renkler.isEmpty());

Çıktı

3
true
[kırmızı, mavi]
true
2
true

• Değişken türü Collection: yalnızca ortak metotlar kullanılabilir (indeksli get yok).
• remove("yeşil") öğeyi değerine göre siler.
• toArray() kopyalanmış yeni bir dizi döndürür.

• Öğeler eklenme sırasına göre tutulur: sıralı (ordered) ama sıralanmış (sorted) değil.
• İndeks tabanlı erişim: ilk öğe 0, son öğe size() − 1.
• Aynı öğe birden çok kez bulunabilir.
• ArrayList: dinamik dizi, hızlı indeksli erişim.
• LinkedList: çift yönlü bağlı liste; uçlarda ekleme ve çıkarma hızlı.
• Vector: eski, senkronize (thread-safe) sürüm; yerine ArrayList tercih edilir.

• Dinamik dizi: öğeleri içerideki bir dizide, eklenme sırasıyla saklar.
• AbstractList sınıfından türetilmiştir ve List arayüzünü uygular.
• Dinamik boyut: iç dizi dolunca kendiliğinden büyür.
• get(i) / set(i, e) çok hızlıdır: O(1).
• Sona ekleme ortalamada hızlıdır; ortaya ekleme ve ortadan çıkarma öğeleri kaydırdığı için yavaştır: O(n).

ArrayList<String> meyveler = new ArrayList<>();
meyveler.add("Elma");
meyveler.add("Armut");
System.out.println(meyveler.get(1));  // indeksle

Armut

LinkedList<String> meyveler = new LinkedList<>();
meyveler.add("Elma");
meyveler.add("Armut");
meyveler.addFirst("Kiraz");   // başa ekle
meyveler.addLast("Muz");      // sona ekle
System.out.println(meyveler);
System.out.println(meyveler.getFirst());
System.out.println(meyveler.getLast());
meyveler.removeFirst();
System.out.println(meyveler);

[Kiraz, Elma, Armut, Muz]
Kiraz
Muz
[Elma, Armut, Muz]

Bu metotlar Deque arayüzünden gelir; add, get, remove(i) ise List'ten.

• List arayüzünü uygulayan, genişletilebilir bir dinamik dizidir.
• Belirtilen (varsayılan 10) kapasiteyle başlar; doldukça kapasitesi iki katına çıkar.
• Metotları senkronizedir (synchronized): çoklu iş parçacıklı ortamda güvenle kullanılabilir; ama bu her çağrıda ek maliyettir.
• Java 1.0'dan kalmadır; modern kodda daha hafif ve hızlı ArrayList tercih edilir.

Vector<Integer> v = new Vector<>();   // kapasite: 10
for (int i = 1; i <= 11; i++) {
    v.addElement(i * 10);
}
System.out.println(v.size() + " / " + v.capacity());
System.out.println(v.elementAt(0));
v.removeElement(110);    // değeri 110 olan öğe
System.out.println(v.size() + " / " + v.capacity());

11 / 20
10
10 / 20

11. eleman eklenince kapasite 10 → 20 olur. Silme kapasiteyi küçültmez.

• LIFO (Last In, First Out): son giren ilk çıkar.
• En son eklenen en üstte (top), en eski eklenen en altta (base) durur.
• Vector sınıfından türetilmiştir (genişletilmiş bir sürümüdür).
• Kullanım: geri alma (undo), metin ve ifade analizi (parantez denetimi), derinlik öncelikli arama, metot çağrı yığını.
• Modern kodda yerine Deque arayüzünü uygulayan ArrayDeque (veya LinkedList) önerilir.

Benzetme: üst üste konmuş tabaklar; tabak hep en üstten alınır ve en üste konur.

List<String> dersler = new ArrayList<>(
        Arrays.asList("Fizik", "Java", "Devre"));
// 1) İndeksli for
for (int i = 0; i < dersler.size(); i++) {
    System.out.print(dersler.get(i) + " ");
}
System.out.println();
// 2) Gelişmiş for (for-each)
for (String d : dersler) {
    System.out.print(d + " ");
}
System.out.println();
// 3) forEach + lambda (Java 8+)
dersler.forEach(d -> System.out.print(d + " "));
System.out.println();

Çıktı

Fizik Java Devre 
Fizik Java Devre 
Fizik Java Devre 

• İndeksli for: indekse ihtiyaç olduğunda (yalnızca listelerde).
• for-each: en okunur yol; tüm koleksiyonlarda çalışır.
• forEach + lambda: Java 8+ kısa yazım.
• Gezinirken öğe silmek gerekiyorsa Iterator kullanılır (ileride).

• FIFO (First-In-First-Out): ilk giren ilk çıkar.
• Öğeler kuyruğa eklendikleri sırayla çıkarılır; yeni öğe sona girer, işlenecek öğe baştan alınır.
• Öğeler genellikle offer, poll ve peek metotlarıyla işlenir.
• Uygulamalar: LinkedList (çift yönlü bağlı liste), PriorityQueue (önceliğe göre; FIFO değil), ArrayDeque (dinamik dizi).
• Kullanım: yazıcı kuyruğu, görev sırası, genişlik öncelikli arama.

Benzetme: market kasası. Sıraya en sondan girilir, ödemeyi en öndeki yapar.

Kuyruk boşken remove() ve element() NoSuchElementException fırlatır; poll() ve peek() ise null döndürür. size(): eleman sayısı.

• Öncelikli kuyruk (priority queue): çıkan öğe her zaman en öncelikli olandır, eklenme sırası değil.
• Varsayılan öncelik doğal sıradır: en küçük öğe önce çıkar. Tersi için karşılaştırıcı verilir.
• Öğeler karşılaştırılabilir (Comparable) olmalı ya da bir karşılaştırıcı (Comparator) verilmelidir.
• İçte ikili yığın (binary heap) kullanır: add/poll O(log n), peek O(1); dinamik olarak büyür.
• Kullanım: görev zamanlama, acil servis sırası, en kısa yol algoritmaları.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(30);
pq.add(10);
pq.add(40);
pq.add(20);
System.out.println(pq.peek());   // en küçük
System.out.println(pq);          // iç düzen (yığın)
while (!pq.isEmpty()) {
    System.out.print(pq.poll() + " ");
}
System.out.println();

10
[10, 20, 40, 30]
10 20 30 40 

println(pq) sıralı değildir: iç dizi yalnızca “her ebeveyn çocuklarından küçük” kuralına uyar. Sıralı sonuç için poll ile tek tek çıkarılır.

class Gorev implements Comparable<Gorev> {
    String ad;
    int oncelik;          // küçük = acil

    Gorev(String ad, int oncelik) {
        this.ad = ad;
        this.oncelik = oncelik;
    }

    @Override
    public int compareTo(Gorev diger) {
        return Integer.compare(oncelik, diger.oncelik);
    }

    @Override
    public String toString() {
        return ad + "(" + oncelik + ")";
    }
}

compareTo negatif dönerse this önce gelir. Collections.reverseOrder() doğal sırayı tersine çevirir: en büyük önce çıkar.

PriorityQueue<Gorev> gorevler =
        new PriorityQueue<>();
gorevler.add(new Gorev("Rapor", 3));
gorevler.add(new Gorev("Arıza", 1));
gorevler.add(new Gorev("Toplantı", 2));
while (!gorevler.isEmpty()) {
    System.out.println(gorevler.poll());
}

Arıza(1)
Toplantı(2)
Rapor(3)

PriorityQueue<Integer> buyukOnce =
        new PriorityQueue<>(
        Collections.reverseOrder());
buyukOnce.add(30);
buyukOnce.add(10);
buyukOnce.add(40);
System.out.println(buyukOnce.poll());

40

• Çift uçlu kuyruk yapısını dinamik (dairesel) bir diziyle uygular.
• Hem kuyruk hem yığın işlemlerini destekler.
• Genellikle LinkedList'ten ve Stack'ten daha hızlı ve hafiftir; yığın ve kuyruk için önerilen sınıftır.
• null öğe kabul etmez.

Yığın olarak (Stack yerine)

Deque<String> yigin = new ArrayDeque<>();
yigin.push("A");     // başa ekler
yigin.push("B");
System.out.println(yigin.pop());

B

push/pop/peek baş uçta çalışır. Kuyruk olarak: offer sona ekler, poll baştan alır.

• Tekil öğeleri saklar; matematikteki küme gibidir ve küme işlemlerine uygundur.
• Her öğeden yalnızca bir tane bulunur: var olan öğeyi add eklemez, false döndürür.
• Genel olarak sıra garantisi vermez (sıra, uygulamaya bağlıdır).
• Ekleme, çıkarma ve arama hızlıdır.
• HashSet: sırasız. LinkedHashSet: eklenme sırası. TreeSet: sıralı (doğal sıra ya da Comparator).

Set<String> meyveler = new HashSet<>();
System.out.println(meyveler.add("Elma"));
System.out.println(meyveler.add("Armut"));
System.out.println(meyveler.add("Elma"));
System.out.println(meyveler.size());
System.out.println(meyveler.contains("Armut"));
meyveler.remove("Armut");
System.out.println(meyveler);

true
true
false
2
true
[Elma]

• Sadece tekil elemanları içeren bir küme; HashSet'ten türer.
• Ek olarak elemanları bir bağlı listeyle birbirine bağlar: eklenme sırası korunur.
• Hızlı erişim sağlar ve elemanların benzersizliğini garanti eder.
• Hem performans hem sıra önemliyse tercih edilir; sıra önemli değilse ve performans kritikse HashSet kullanılır.

LinkedHashSet<Integer> sayilar =
        new LinkedHashSet<>();
sayilar.add(5);
sayilar.add(10);
sayilar.add(5);         // tekrar: eklenmez
sayilar.add(1);
System.out.println(sayilar);

[5, 10, 1]

class Nokta {
    int x, y;
    Nokta(int x, int y) {
        this.x = x;
        this.y = y;
    }
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Nokta)) return false;
        Nokta n = (Nokta) o;
        return x == n.x && y == n.y;
    }
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

NoktaA: aynı sınıf, equals/hashCode yok

Set<NoktaA> s1 = new HashSet<>();
s1.add(new NoktaA(1, 2));
s1.add(new NoktaA(1, 2));
System.out.println(s1.size());

Set<Nokta> s2 = new HashSet<>();
s2.add(new Nokta(1, 2));
s2.add(new Nokta(1, 2));
System.out.println(s2.size());

2
1

• NoktaA: iki nesne farklı sayılır (Object'in equals'ı referansları karşılaştırır) → boyut 2.
• Nokta: equals ve hashCode geçersiz kılındı → aynı nokta bir kez → boyut 1.

• SortedSet: elemanları sıralı saklayan tekil küme arayüzü.
• Sıralama doğal sıraya (Comparable) ya da verilen bir Comparator'a göre yapılır.
• Alt küme ve üst küme işlemleri sunar.
• TreeSet: AbstractSet'ten türetilir, NavigableSet (dolayısıyla SortedSet) arayüzünü uygular.
• İçte kırmızı-siyah ağaç: ekleme, silme, arama O(log n).

TreeSet<Integer> notlar = new TreeSet<>();
notlar.add(70);
notlar.add(50);
notlar.add(90);
notlar.add(60);
notlar.add(80);
System.out.println(notlar);
System.out.println(notlar.first() + " " + notlar.last());
System.out.println(notlar.headSet(70));     // 70 hariç
System.out.println(notlar.tailSet(70));     // 70 dahil
System.out.println(notlar.subSet(60, 90));  // [60, 90)
System.out.println(notlar.comparator());    // doğal sıra

TreeSet<String> meyveler = new TreeSet<>();
meyveler.add("Elma");
meyveler.add("Armut");
System.out.println(meyveler);

Çıktı

[50, 60, 70, 80, 90]
50 90
[50, 60]
[70, 80, 90]
[60, 70, 80]
null
[Armut, Elma]

Öğeler hangi sırayla eklenirse eklensin sıralı tutulur. Dizgiler alfabetik (karakter kodu) sırayla dizilir.

Set<Integer> a = new TreeSet<>(Arrays.asList(1, 2, 3, 4));
Set<Integer> b = new TreeSet<>(Arrays.asList(3, 4, 5));

Set<Integer> birlesim = new TreeSet<>(a);
birlesim.addAll(b);
Set<Integer> kesisim = new TreeSet<>(a);
kesisim.retainAll(b);
Set<Integer> fark = new TreeSet<>(a);
fark.removeAll(b);

System.out.println("A ∪ B = " + birlesim);
System.out.println("A ∩ B = " + kesisim);
System.out.println("A − B = " + fark);
System.out.println(a.containsAll(kesisim));

A ∪ B = [1, 2, 3, 4, 5]
A ∩ B = [3, 4]
A − B = [1, 2]
true

Bu metotlar çağrıldığı kümeyi değiştirir; bu yüzden önce kopya alınır.

• Anahtar-değer (key-value) çiftlerini saklar: her anahtar bir değere eşlenir.
• Anahtarlar tekildir; değerler tekrar edebilir.
• Anahtar üzerinden hızlı erişim sağlar; çiftler üzerinde işlem yapmaya olanak tanır.
• HashMap: sıra garantisi yok. LinkedHashMap: eklenme sırası. TreeMap: anahtarlar sıralı (doğal sıra ya da Comparator).

Benzetme: sözlük. Kelime (anahtar) ile anlamını (değer) bulursunuz; aynı kelime iki kez yer almaz.

HashMap<String, Double> urunFiyatlari = new HashMap<>();
urunFiyatlari.put("Telefon", 2000.0);
urunFiyatlari.put("Kulaklık", 350.0);
urunFiyatlari.put("Kılıf", 120.0);
Double eski = urunFiyatlari.put("Telefon", 1800.0);
System.out.println(eski);
System.out.println(urunFiyatlari.get("Telefon"));
System.out.println(urunFiyatlari.get("Tablet"));
System.out.println(urunFiyatlari.containsKey("Kılıf"));
urunFiyatlari.remove("Kılıf");
System.out.println(urunFiyatlari.size());

2000.0
1800.0
null
true
2

urunFiyatlari.put(null, 0.0);         // tek null anahtar
urunFiyatlari.put("Kalem", null);     // null değer
System.out.println(urunFiyatlari.size());

4

• Anahtar-değer çiftlerini karma tablosunda saklar: get/put ortalama O(1).
• AbstractMap'ten türetilmiştir ve Map'i uygular.
• Tekil anahtarlar: aynı anahtarla put değeri değiştirir.
• Null: bir null anahtara ve birden çok null değere izin verir.
• Elemanlar sırasız depolanır.

Map<String, Integer> notlar = new TreeMap<>();
notlar.put("Cem", 72);
notlar.put("Ayşe", 95);
notlar.put("Banu", 60);

for (String isim : notlar.keySet()) {
    System.out.print(isim + " ");
}
System.out.println();
for (Integer not : notlar.values()) {
    System.out.print(not + " ");
}
System.out.println();
for (Map.Entry<String, Integer> g : notlar.entrySet()) {
    System.out.println(g.getKey() + " → " + g.getValue());
}

Ayşe Banu Cem 
95 60 72 
Ayşe → 95
Banu → 60
Cem → 72

• keySet(): yalnız anahtarlar.
• values(): yalnız değerler.
• entrySet(): her çift bir Map.Entry; getKey() ve getValue() ile okunur. Hem anahtar hem değer gerekiyorsa en verimli yol budur.
• Map doğrudan for-each'e verilemez: Iterable değildir.

• Tekil anahtar-değer çiftlerini içeren bir eşleme; HashMap'ten türer.
• Her eleman bir anahtar (key) ve bir değer (value) çiftidir; anahtarlar tekildir.
• Çiftleri bağlı listeyle birbirine bağlar: eklenme sırası korunur.
• Performans ve sıra birlikte önemliyse tercih edilir; sıra önemli değilse HashMap yeterlidir.

Map<String, String> rehber = new LinkedHashMap<>();
rehber.put("Zeynep", "555-1111");
rehber.put("Ahmet", "555-1234");
rehber.put("Mert", "555-2222");
Map<String, String> h = new HashMap<>(rehber);
Map<String, String> t = new TreeMap<>(rehber);
System.out.println("LinkedHashMap: " + rehber);
System.out.println("HashMap:       " + h);
System.out.println("TreeMap:       " + t);

Hashtable<String, String> telefonRehberi = new Hashtable<>();
telefonRehberi.put("Ahmet", "555-1234");
System.out.println(telefonRehberi.get("Ahmet"));
System.out.println(telefonRehberi.containsKey("Ayşe"));
// telefonRehberi.put(null, "x");  → NullPointerException

555-1234
false

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Object.hashCode()" because "key" is null

• SortedMap: anahtarları sıralı saklayan eşleme arayüzü; her anahtar bir kez bulunur.
• Alt harita ve üst harita gibi işlemler sunar.
• TreeMap: AbstractMap'ten türetilir, NavigableMap arayüzünü uygular.
• Anahtarlar doğal sıraya ya da verilen Comparator'a göre dizilir.
• İçte kırmızı-siyah ağaç (red-black tree): get/put O(log n).

• Yineleyici (iterator): koleksiyonda öğeleri sırayla gezmek için kullanılan nesne.
• Koleksiyonun iç yapısını bilmeden (dizi, ağaç, karma tablosu…) her öğeye erişmeyi sağlar.
• Gezerken güvenli silme yapılabilen tek yoldur.
• for-each döngüsü arka planda bir Iterator kullanır.
• Listeler için ListIterator ayrıca geriye gitmeyi, add ve set işlemlerini destekler.

Genellikle while (it.hasNext()) döngüsüyle (veya for ile) kullanılır.

Doğru: Iterator.remove()

List<Integer> sayilar = new ArrayList<>();
Collections.addAll(sayilar, 4, 7, 10, 13, 16);
Iterator<Integer> it = sayilar.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();         // güvenli silme
    }
}
System.out.println(sayilar);

Kısa yol (Java 8+)

List<Integer> s2 = new ArrayList<>();
Collections.addAll(s2, 4, 7, 10, 13, 16);
s2.removeIf(s -> s % 2 == 0);
System.out.println(s2);

[7, 13]

İki yolun çıktısı da aynı: yalnız tek sayılar kalır.

List<String> isimler = new ArrayList<>(
        Arrays.asList("Cem", "Ayşe", "Banu", "Ali"));
Collections.sort(isimler);
System.out.println(isimler);
Collections.sort(isimler, Collections.reverseOrder());
System.out.println(isimler);
Collections.reverse(isimler);
System.out.println(isimler);

[Ali, Ayşe, Banu, Cem]
[Cem, Banu, Ayşe, Ali]
[Ali, Ayşe, Banu, Cem]

String, Integer, Double gibi sınıflar zaten Comparable’dır. Java 8+: liste.sort(null) de doğal sıraya göre sıralar.

class Ogrenci implements Comparable<Ogrenci> {
    String isim;
    int puan;

    Ogrenci(String isim, int puan) {
        this.isim = isim;
        this.puan = puan;
    }

    // puana göre artan sıra
    @Override
    public int compareTo(Ogrenci diger) {
        return Integer.compare(puan, diger.puan);
    }

    @Override
    public String toString() {
        return isim + ":" + puan;
    }
}

List<Ogrenci> sinif = new ArrayList<>();
sinif.add(new Ogrenci("Cem", 72));
sinif.add(new Ogrenci("Ayşe", 95));
sinif.add(new Ogrenci("Banu", 60));

Collections.sort(sinif);
System.out.println(sinif);

[Banu:60, Cem:72, Ayşe:95]

• Sınıf Comparable<Ogrenci> arayüzünü uygular ve compareTo'yu yazar.
• Sonuç: negatif → this önce; 0 → eşit; pozitif → diger önce.
• Integer.compare çıkarma yapmaktan (puan − diger.puan) güvenlidir: taşma olmaz.

Collections.sort(sinif, new Comparator<Ogrenci>() {
    @Override
    public int compare(Ogrenci a, Ogrenci b) {
        return a.isim.compareTo(b.isim);   // isme göre
    }
});
System.out.println(sinif);

// Java 8+: aynı işin kısa yazımı
sinif.sort(Comparator.comparing(o -> o.puan));
System.out.println(sinif);

[Ayşe:95, Banu:60, Cem:72]
[Banu:60, Cem:72, Ayşe:95]

• Comparator: sınıfın dışında yazılan ayrı bir sıralama ölçütü; bir sınıf için birden çok olabilir.
• Klasik yazım: anonim iç sınıf (anonymous class) ile compare(a, b).
• Java 8+: Comparator.comparing(…) ve lambda ile tek satır; ters sıra için .reversed().
• Doğal sıra (compareTo) değişmez; yalnızca o sıralama için başka ölçüt kullanılır.

List<String> ogrenciler = new ArrayList<>(
        Arrays.asList("Ali", "Banu", "Cem", "Deniz"));
Collections.shuffle(ogrenciler);
System.out.println(ogrenciler);

Bir çalıştırmanın çıktısı

[Cem, Ali, Deniz, Banu]

Çıktı her çalıştırmada farklıdır. Aynı karışım için (test) sabit tohumlu new Random(42) ikinci argüman olarak verilir.

public class Loto {
    // Loto çekilişi yapan metot
    public static Integer[] lotoYap(int toplamSayi, int cekilecekSayi) {
        ArrayList<Integer> sayilar = new ArrayList<Integer>();
        for (int i = 0; i < toplamSayi; i++) {
            sayilar.add(i + 1);          // 1 … toplamSayi
        }
        Collections.shuffle(sayilar);    // karıştır
        Integer[] cekilenSayilar = new Integer[cekilecekSayi];
        for (int i = 0; i < cekilecekSayi; i++) {
            cekilenSayilar[i] = sayilar.get(i);
        }
        return cekilenSayilar;
    }

    public static void main(String[] args) {
        Integer[] sonuc = lotoYap(49, 6);   // 49'dan 6
        for (Integer item : sonuc) {
            System.out.print(item + " ");
        }
    }
}

Örnek çıktı

46 18 22 11 20 10 

1–49 listesi karıştırılır, ilk 6 öğe alınır: sayılar tekrarsızdır. Çıktı her çalıştırmada farklıdır.

Çıktı

3
-4
3

Bulunamazsa dönüş negatiftir: −(ekleme noktası) − 1. Liste sıralı değilse sonuç tanımsızdır.

List<Integer> n = Arrays.asList(4, 9, 2, 9, 5);
System.out.println(Collections.max(n));
System.out.println(Collections.min(n));
System.out.println(Collections.frequency(n, 9));

9
2
2

Hedef kısa ise copy IndexOutOfBoundsException: Source does not fit in dest fırlatır.

İlkel tür ile generic

List<int> notlar = new ArrayList<>();

error: unexpected type
        List<int> notlar = new ArrayList<>();
             ^
  required: reference
  found:    int

Koleksiyonlar nesne tutar: List<Integer> yazın. int değerler otomatik kutulanır.

Yanlış türde öğe eklemek

List<String> isimler = new ArrayList<>();
isimler.add(42);

error: incompatible types: int cannot be converted to String
        isimler.add(42);
                    ^

Generic tür derleme anında denetlenir. Sayıyı dizgi olarak saklamak isterseniz String.valueOf(42).

Arrays.asList listesine eklemek

List<Integer> sabit = Arrays.asList(1, 2, 3);
sabit.add(4);

Exception in thread "main" java.lang.UnsupportedOperationException

Arrays.asList sabit boyutlu liste döndürür (set olur, add/remove olmaz). Çözüm: new ArrayList<>(Arrays.asList(…)).

Map'i doğrudan for-each ile gezmek

Map<String, Integer> m = new HashMap<>();
for (String s : m) {
    System.out.println(s);
}

error: for-each not applicable to expression type
        for (String s : m) {
                        ^
  required: array or java.lang.Iterable
  found:    Map<String,Integer>

Map Iterable değildir: keySet(), values() veya entrySet() üzerinde gezin.

public class Fibonacci {
    public static int fibonacci(int sayi) {
        List<Integer> liste = new ArrayList<>();
        liste.add(0);
        liste.add(1);
        for (int i = 2; i < sayi + 1; i++) {
            liste.add(liste.get(i - 2) + liste.get(i - 1));
        }
        return liste.get(sayi);
    }
    public static void main(String[] args) {
        int sonuc = fibonacci(10);
        System.out.println(sonuc);
    }
}

1. Program ne yazdırır?
2. fibonacci(10) dönerken listede kaç öğe vardır? Son üç öğe nedir?
3. fibonacci(1) çağrısında döngü kaç kez döner?
4. Bu soru için liste gerçekten gerekli mi?

public class TekrarSiz {
    static List<String> tekrarSiz(List<String> giris) {
        Set<String> gorulen = new LinkedHashSet<>(giris);
        return new ArrayList<>(gorulen);
    }

    public static void main(String[] args) {
        List<String> l = Arrays.asList("b", "a", "b", "c", "a");
        System.out.println(tekrarSiz(l));
    }
}

1. Program ne yazdırır?
2. LinkedHashSet yerine HashSet veya TreeSet kullanılsaydı ne değişirdi?

static boolean dengeliMi(String ifade) {
    Deque<Character> yigin = new ArrayDeque<>();
    for (char c : ifade.toCharArray()) {
        if (c == '(' || c == '[') {
            yigin.push(c);
        } else if (c == ')' || c == ']') {
            if (yigin.isEmpty()) return false;
            char ac = yigin.pop();
            if (c == ')' && ac != '(') return false;
            if (c == ']' && ac != '[') return false;
        }
    }
    return yigin.isEmpty();
}

Parantez dengesi: her açılan parantez doğru türde ve doğru sırada kapanmalı.

1. dengeliMi("(a[b]c)"), dengeliMi("(a[b)c]") ve dengeliMi("((") ne döndürür?
2. Neden yığın kullanıldı?

Deque<Integer> d = new ArrayDeque<>();
d.offerLast(1);
d.offerFirst(2);
d.offerLast(3);
d.push(4);
System.out.println(d);
System.out.println(d.pollLast() + d.pop());
System.out.println(d);

Map<String, Integer> m = new TreeMap<>();
m.put("b", 1);
m.put("a", 2);
m.put("b", 3);
Set<Integer> s = new TreeSet<>(m.values());
s.add(2);
System.out.println(m + " " + s + " " + m.size());

Her iki parçanın çıktısını tahmin edin. (İpucu: push = offerFirst, pop = removeFirst.)