Java01-java/47-arraylist

ArrayList Sınıfı

ArrayList, Java'da açık ara en çok kullanılan koleksiyondur. İçte boyutu otomatik büyüyen bir dizi tutar; böylece sabit boyutlu dizilerin (int[]) aksine eleman ekledikçe genişler. İndeksli hızlı erişim, kolay ekleme/s…

ArrayList Sınıfı

ArrayList, Java'da açık ara en çok kullanılan koleksiyondur. İçte boyutu otomatik büyüyen bir dizi tutar; böylece sabit boyutlu dizilerin (int[]) aksine eleman ekledikçe genişler. İndeksli hızlı erişim, kolay ekleme/silme ve zengin yardımcı metotlarıyla "varsayılan liste" seçimidir. Collections bölümünde genel hatlarıyla gördük; burada en sık kullanılan metotlarını ve performans inceliklerini odaklı biçimde ele alıyoruz.

İç yapı ve performans

ArrayList arka planda bir dizi (Object[]) tutar. Bu, davranışını belirler:

İndeksli erişim get(i)/set(i): O(1) — diziye doğrudan erişim, çok hızlı.
Sona ekleme add(e): amortize O(1) — dizi dolunca daha büyük bir diziye kopyalanır (genelde ~1.5 kat), ama ortalama maliyet sabittir.
Ortaya/başa ekleme-silme: O(n) — sonraki tüm elemanlar kaydırılır.

Çok sayıda eleman ekleyeceğini biliyorsan başlangıç kapasitesi ver: new ArrayList<>(1000) — gereksiz yeniden boyutlandırmayı önler.

Temel işlemler

List<String> l = new ArrayList<>();
l.add("a");           // sona ekle
l.add(1, "b");        // indekse ekle
l.get(0);             // eriş
l.set(0, "x");        // güncelle
l.remove(1);          // indekse göre sil
l.remove("x");        // değere göre sil
l.contains("a");      // var mı?
l.indexOf("a");       // konumu
l.size();             // eleman sayısı

Örnek 1 (./Ornek1.java) bunların hepsini gösterir ve önemli bir tuzağa dikkat çeker:

Tuzak: remove(int) indeksi, remove(Object) değeri siler. List<Integer>'da list.remove(2) indeks 2'yi siler; değer 2'yi silmek için list.remove(Integer.valueOf(2)) kullan.

Toplu işlemler ve dönüşümler

l.addAll(digerListe);          // toplu ekle
l.removeAll(c); l.retainAll(c); // toplu sil / kesişim
l.removeIf(x -> x.isEmpty());   // koşullu sil
l.sort(Comparator...);          // sırala
l.subList(0, 3);                // alt görünüm
l.toArray(new T[0]);            // diziye çevir
l.stream().map(...).toList();   // stream ile dönüştür

Collections yardımcıları da çok kullanılır: sort, reverse, shuffle, max, min, frequency. Örnek 2 (./Ornek2.java) toplu işlemleri, sıralamayı, subList, toArray ve stream dönüşümünü gösterir.

subList uyarısı: subList, ana listenin bir görünümüdür (view); üzerinde yapılan değişiklik ana listeyi etkiler. Bağımsız kopya istiyorsan new ArrayList<>(l.subList(...)).

ArrayList vs Array (dizi)

	`int[]` (dizi)	`ArrayList<Integer>`
Boyut	Sabit	Dinamik (büyür)
Tip	İlkel veya nesne	Yalnızca nesne (kutulama)
Metotlar	Yok (Arrays yardımcı)	Zengin API
Performans	En hızlı, kutulamasız	Çok hızlı, küçük ek yük

İlkel tiplerle yoğun sayısal iş yapıyorsan dizi daha verimlidir; esneklik ve API istiyorsan ArrayList.

ArrayList vs LinkedList

İkisi de List'tir ama iç yapıları farklıdır: ArrayList dizi tabanlı (hızlı erişim), LinkedList bağlı düğümler (hızlı baş/son ekleme). Çoğu durumda ArrayList daha iyidir; ayrıntıyı bir sonraki konuda karşılaştırıyoruz.

Özet

ArrayList'in dizi tabanlı iç yapısını ve performans özelliklerini; temel işlemleri ve remove(int) vs remove(Object) tuzağını (Örnek 1); toplu işlemleri, sıralamayı, subList ve dönüşümleri (Örnek 2) öğrendik. "Varsayılan liste ArrayList" kuralı çoğu durumda doğrudur. Sırada, bağlı liste tabanlı alternatif ve karşılaştırma: LinkedList.

▶ Kod Örnekleri(2)

Ornek1

çalıştırılabilir

Ornek1.java

1// Ornek1: ArrayList — temel işlemler (ekle, eriş, güncelle, sil, ara).
2// Çalıştırma: java Ornek1.java
3import java.util.ArrayList;
4import java.util.List;
5
6public class Ornek1 {
7
8    public static void main(String[] args) {
9        List<String> gorevler = new ArrayList<>();
10
11        // Ekleme
12        gorevler.add("Kahvaltı");          // sona ekle
13        gorevler.add("Spor");
14        gorevler.add("Toplantı");
15        gorevler.add(1, "Kod yaz");        // belirli indekse ekle
16        System.out.println("Liste: " + gorevler);
17
18        // Erişim ve güncelleme
19        System.out.println("0. eleman: " + gorevler.get(0));
20        gorevler.set(0, "Geç kahvaltı");   // indeksteki elemanı değiştir
21        System.out.println("Güncel 0: " + gorevler.get(0));
22
23        // Arama
24        System.out.println("'Spor' var mı? " + gorevler.contains("Spor"));
25        System.out.println("'Spor' indeksi: " + gorevler.indexOf("Spor"));
26        System.out.println("Boyut: " + gorevler.size());
27
28        // Silme: indekse göre VE değere göre
29        gorevler.remove(1);                 // indeks 1
30        gorevler.remove("Spor");            // değer "Spor"
31        System.out.println("Silmeler sonrası: " + gorevler);
32
33        // Gezinme (for-each)
34        System.out.print("Kalan görevler: ");
35        for (String g : gorevler) System.out.print(g + "; ");
36        System.out.println();
37
38        System.out.println("""
39
40                --- ArrayList temelleri ---
41                İçte dinamik bir dizi tutar: indeksli erişim O(1), sona ekleme amortize O(1).
42                add/get/set/remove/contains/indexOf/size en sık kullanılan metotlardır.
43                DİKKAT: remove(int) indeksi siler, remove(Object) değeri siler. Integer listede
44                remove(2) -> indeks 2; remove(Integer.valueOf(2)) -> değer 2.""");
45    }
46}

Çıktı yerel JDK 21 ile yakalandı — tarayıcıda JVM çalışmaz.

Ornek2

çalıştırılabilir

Ornek2.java

1// Ornek2: ArrayList — toplu işlemler, sıralama, subList, toArray, dönüşümler.
2// Çalıştırma: java Ornek2.java
3import java.util.ArrayList;
4import java.util.Collections;
5import java.util.Comparator;
6import java.util.List;
7
8public class Ornek2 {
9
10    public static void main(String[] args) {
11        List<Integer> sayilar = new ArrayList<>(List.of(5, 3, 9, 1, 7, 3, 8));
12
13        // Toplu işlemler
14        sayilar.addAll(List.of(10, 2));
15        System.out.println("addAll sonrası: " + sayilar);
16        sayilar.removeIf(n -> n % 2 == 0);   // çiftleri sil (koşullu silme)
17        System.out.println("Tekler: " + sayilar);
18
19        // Sıralama
20        sayilar.sort(Comparator.naturalOrder());
21        System.out.println("Sıralı: " + sayilar);
22        Collections.reverse(sayilar);
23        System.out.println("Ters: " + sayilar);
24        System.out.println("Max/Min: " + Collections.max(sayilar) + " / " + Collections.min(sayilar));
25
26        // Alt liste (görünüm) ve diziye çevirme
27        List<Integer> ilkUc = sayilar.subList(0, 3);
28        System.out.println("subList(0,3): " + ilkUc);
29        Integer[] dizi = sayilar.toArray(new Integer[0]);
30        System.out.println("toArray uzunluk: " + dizi.length);
31
32        // Stream ile dönüşüm
33        List<String> etiketler = sayilar.stream().map(n -> "#" + n).toList();
34        System.out.println("map sonucu: " + etiketler);
35
36        System.out.println("""
37
38                --- ArrayList toplu işlemler ---
39                addAll/removeAll/retainAll: toplu ekleme/silme/kesişim.
40                removeIf(predicate): koşullu silme (güvenli, iç tarafta iterator).
41                Sıralama: list.sort(cmp) veya Collections.sort; Collections.reverse/max/min.
42                subList(from,to): listenin bir GÖRÜNÜMÜ (değişiklik ana listeyi etkiler).
43                Performans: rastgele erişim hızlı; ortaya/başa ekleme-silme elemanları kaydırır (O(n)).""");
44    }
45}

Çıktı yerel JDK 21 ile yakalandı — tarayıcıda JVM çalışmaz.