← Kursa Dön
📄 Text · 15 min

ArrayList Kullanımı

Giriş

Diziler güzeldir, hızlıdır, bellekte verimlidir. Ama bir sorunları var: boyutları sabit. Bir kere new int[5] dedin mi, o dizi ömrü boyunca 5 elemanlıktır. 6. eleman eklemek istersen? Yeni dizi oluştur, eskileri kopyala, yenisini ekle... Çok zahmetli.

İşte ArrayList tam bu sorunu çözer. ArrayList dinamik boyutlu bir listedir. Eleman eklediğinde büyür, çıkardığında küçülür. Sen boyutuyla uğraşmazsın, Java halleder.

ArrayList Nedir?

ArrayList'i bir akordeon dosya gibi düşün. Normal dizi sabit boyutlu bir kutu — 5 gözlüyse 5 gözlü. Ama akordeon dosya esner: yeni dosya geldiğinde büyür, dosya çıkardığında küçülür.

Teknik olarak ArrayList, arka planda bir dizi kullanır. Dizi dolduğunda, daha büyük bir dizi oluşturup elemanları kopyalar. Ama bunu otomatik yapar, senin haberin bile olmaz.

ArrayList Oluşturma

import java.util.ArrayList;

ArrayList<String> isimler = new ArrayList<String>();
// veya kısaca (Java 7+):
ArrayList<String> isimler2 = new ArrayList<>();

<String> kısmı bu listenin String tutacağını belirtir. Buna generic tip denir. Yanlış tip eklemeye çalışırsan derleme hatası alırsın.

ArrayList<Integer> sayilar = new ArrayList<>();
ArrayList<Double> fiyatlar = new ArrayList<>();
ArrayList<Boolean> bayraklar = new ArrayList<>();

⚠️ Dikkat: ArrayList'te primitive tipler (int, double, boolean) direkt kullanılamaz. Sarmalayıcı (wrapper) sınıflarını kullanmalısın: Integer, Double, Boolean. Java auto-boxing ile dönüşümü otomatik yapar, ama farkında olman lazım.

ArrayList<int> yanlis = new ArrayList<>();     // DERLEME HATASI!
ArrayList<Integer> dogru = new ArrayList<>();  // doğru

Temel Metotlar

add() — Eleman Ekleme

ArrayList<String> meyveler = new ArrayList<>();

meyveler.add("Elma");       // sona ekler
meyveler.add("Armut");
meyveler.add("Portakal");

System.out.println(meyveler);  // [Elma, Armut, Portakal]

// Belirli indekse ekleme
meyveler.add(1, "Muz");    // 1. indekse Muz'u ekle, diğerleri kayar

System.out.println(meyveler);  // [Elma, Muz, Armut, Portakal]

add(eleman) sona ekler. add(indeks, eleman) belirtilen indekse ekler ve sonraki elemanları bir kaydırır.

get() — Eleman Okuma

ArrayList<String> meyveler = new ArrayList<>();
meyveler.add("Elma");
meyveler.add("Armut");
meyveler.add("Portakal");

String ilk = meyveler.get(0);     // "Elma"
String son = meyveler.get(2);     // "Portakal"

System.out.println(ilk);   // Elma

Tıpkı dizi[0] gibi, ama köşeli parantez yerine get(0) kullanıyorsun.

set() — Eleman Güncelleme

meyveler.set(1, "Kiraz");  // 1. indeksteki "Armut"u "Kiraz" yap

System.out.println(meyveler);  // [Elma, Kiraz, Portakal]

set() mevcut bir elemanı değiştirir. Yeni eleman eklemez.

remove() — Eleman Silme

ArrayList<String> meyveler = new ArrayList<>();
meyveler.add("Elma");
meyveler.add("Armut");
meyveler.add("Portakal");

// İndeksle silme
meyveler.remove(1);  // 1. indeksteki "Armut" silindi
System.out.println(meyveler);  // [Elma, Portakal]

// Değerle silme
meyveler.remove("Elma");  // "Elma" bulunup silindi
System.out.println(meyveler);  // [Portakal]

Integer listesinde dikkat:

ArrayList<Integer> sayilar = new ArrayList<>();
sayilar.add(10);
sayilar.add(20);
sayilar.add(30);

sayilar.remove(1);             // İNDEKSLE siler → 20 gider
sayilar.remove(Integer.valueOf(10)); // DEĞERLE siler → 10 gider

remove(1) yazınca Java bunu "1. indeksteki elemanı sil" diye anlar, "1 değerini sil" diye değil. Değerle silmek istersen Integer.valueOf() kullan.

size() — Eleman Sayısı

ArrayList<String> meyveler = new ArrayList<>();
meyveler.add("Elma");
meyveler.add("Armut");

System.out.println(meyveler.size());  // 2

Dizilerde length, ArrayList'te size(). Dikkat: size() bir metot (parantezli), length bir field (parantezsiz).

contains() — Eleman Var mı?

ArrayList<String> meyveler = new ArrayList<>();
meyveler.add("Elma");
meyveler.add("Armut");

System.out.println(meyveler.contains("Elma"));    // true
System.out.println(meyveler.contains("Portakal")); // false

indexOf() — Elemanın İndeksi

int indeks = meyveler.indexOf("Armut");  // 1
int yok = meyveler.indexOf("Portakal");  // -1 (bulunamadı)

isEmpty() ve clear()

ArrayList<String> liste = new ArrayList<>();

System.out.println(liste.isEmpty());  // true

liste.add("test");
System.out.println(liste.isEmpty());  // false

liste.clear();  // tüm elemanları sil
System.out.println(liste.isEmpty());  // true
System.out.println(liste.size());     // 0

ArrayList Üzerinde Gezinme

for Döngüsü

ArrayList<String> isimler = new ArrayList<>();
isimler.add("Ali");
isimler.add("Ayse");
isimler.add("Mehmet");

for (int i = 0; i < isimler.size(); i++) {
    System.out.println(i + ": " + isimler.get(i));
}

for-each Döngüsü

for (String isim : isimler) {
    System.out.println(isim);
}

for-each daha temiz ve okunabilir. Ama döngü içinde eleman silmeye çalışırsan ConcurrentModificationException alırsın!

// YANLIŞ — ConcurrentModificationException fırlatır!
for (String isim : isimler) {
    if (isim.equals("Ali")) {
        isimler.remove(isim);  // döngü sırasında silme YASAK
    }
}

⚠️ Dikkat: for-each döngüsü içinde add() veya remove() çağırma. Eleman silmek istiyorsan Iterator veya geriye doğru döngü kullan:

// Güvenli silme — geriye doğru döngü
for (int i = isimler.size() - 1; i >= 0; i--) {
    if (isimler.get(i).equals("Ali")) {
        isimler.remove(i);
    }
}

Generic Tipler

ArrayList'in en güçlü özelliklerinden biri generic tip desteği. <> içinde hangi tür elemanlar tutacağını belirtiyorsun.

ArrayList<String> stringler = new ArrayList<>();   // sadece String
ArrayList<Integer> intler = new ArrayList<>();     // sadece Integer
ArrayList<Double> doubler = new ArrayList<>();     // sadece Double

Generic sayesinde yanlış tip eklersen derleme zamanında hata alırsın:

ArrayList<String> isimler = new ArrayList<>();
isimler.add("Ali");
isimler.add(42);   // DERLEME HATASI! String listesine int eklenemez

Wrapper Tipleri

Primitive → Wrapper dönüşüm tablosu:

PrimitiveWrapper
intInteger
doubleDouble
booleanBoolean
charCharacter
longLong
floatFloat

Auto-boxing ve Unboxing

Java, primitive ve wrapper arasında otomatik dönüşüm yapar:

ArrayList<Integer> sayilar = new ArrayList<>();

sayilar.add(42);          // auto-boxing: int → Integer
int deger = sayilar.get(0);  // auto-unboxing: Integer → int

Arka planda 42 otomatik olarak Integer.valueOf(42)'ye dönüşüyor. Ve get() ile aldığında Integer otomatik olarak int'e dönüşüyor. Pratik!

ArrayList'i Başlangıç Değerleriyle Oluşturma

// Yol 1: Arrays.asList ile
ArrayList<String> meyveler = new ArrayList<>(Arrays.asList("Elma", "Armut", "Portakal"));

// Yol 2: List.of ile (Java 9+) — List.of immutable döner, ArrayList'e sarmalıyoruz
ArrayList<String> meyveler2 = new ArrayList<>(List.of("Elma", "Armut", "Portakal"));

// Yol 3: Tek tek add
ArrayList<String> meyveler3 = new ArrayList<>();
meyveler3.add("Elma");
meyveler3.add("Armut");
meyveler3.add("Portakal");

Pratik Örnekler

Örnek 1: Öğrenci Listesi

import java.util.ArrayList;

public class OgrenciListesi {
    public static void main(String[] args) {
        ArrayList<String> ogrenciler = new ArrayList<>();

        // Öğrenci ekleme
        ogrenciler.add("Ali");
        ogrenciler.add("Ayse");
        ogrenciler.add("Mehmet");
        ogrenciler.add("Zeynep");

        // Listeyi yazdır
        System.out.println("Tüm öğrenciler: " + ogrenciler);

        // Öğrenci ara
        String aranan = "Mehmet";
        if (ogrenciler.contains(aranan)) {
            System.out.println(aranan + " listede, indeks: " + ogrenciler.indexOf(aranan));
        }

        // Öğrenci çıkar
        ogrenciler.remove("Ayse");
        System.out.println("Ayse çıktıktan sonra: " + ogrenciler);

        // Toplam öğrenci
        System.out.println("Toplam: " + ogrenciler.size() + " öğrenci");
    }
}

Örnek 2: Sayı Filtreleme

ArrayList<Integer> sayilar = new ArrayList<>(Arrays.asList(15, 8, 23, 4, 42, 16, 7, 30));
ArrayList<Integer> ciftler = new ArrayList<>();
ArrayList<Integer> tekler = new ArrayList<>();

for (int sayi : sayilar) {
    if (sayi % 2 == 0) {
        ciftler.add(sayi);
    } else {
        tekler.add(sayi);
    }
}

System.out.println("Çiftler: " + ciftler);  // [8, 4, 42, 16, 30]
System.out.println("Tekler: " + tekler);     // [15, 23, 7]

Örnek 3: Tekrar Edenleri Bulma

ArrayList<String> kelimeler = new ArrayList<>(
    Arrays.asList("elma", "armut", "elma", "portakal", "armut", "elma")
);

ArrayList<String> tekrarlar = new ArrayList<>();

for (String kelime : kelimeler) {
    if (!tekrarlar.contains(kelime)) {
        int sayac = 0;
        for (String k : kelimeler) {
            if (k.equals(kelime)) sayac++;
        }
        if (sayac > 1) {
            tekrarlar.add(kelime);
        }
    }
}

System.out.println("Tekrar edenler: " + tekrarlar);  // [elma, armut]

ArrayList Sıralama

import java.util.Collections;

ArrayList<Integer> sayilar = new ArrayList<>(Arrays.asList(64, 25, 12, 22, 11));

// Küçükten büyüğe
Collections.sort(sayilar);
System.out.println(sayilar);  // [11, 12, 22, 25, 64]

// Büyükten küçüğe
Collections.sort(sayilar, Collections.reverseOrder());
System.out.println(sayilar);  // [64, 25, 22, 12, 11]

Dizilerde Arrays.sort() kullandık, ArrayList'te Collections.sort() kullanıyoruz.

💡 İpucu: Java 8+ ile doğrudan sayilar.sort(null) veya sayilar.sort(Collections.reverseOrder()) da yazabilirsin. Daha kısa.

ArrayList vs Array — Hızlı Karşılaştırma

ÖzellikArrayArrayList
BoyutSabitDinamik
Sözdizimidizi[i]liste.get(i)
TipPrimitive + ReferansSadece Referans (Wrapper)
Boyut bilgisidizi.lengthliste.size()
Eleman eklemeManuel (yeni dizi gerekir)add()
Eleman silmeManuel (kaydırma gerekir)remove()
PerformansDaha hızlıBiraz daha yavaş

Bu konuyu bir sonraki derste çok daha detaylı işleyeceğiz.

Yaygın Hatalar

Hata 1: Primitive tip kullanmak

ArrayList<int> liste = new ArrayList<>();     // HATA!
ArrayList<Integer> liste = new ArrayList<>(); // doğru

Hata 2: for-each içinde silmek

for (String s : liste) {
    liste.remove(s);  // ConcurrentModificationException!
}

Hata 3: Var olmayan indekse erişmek

ArrayList<String> liste = new ArrayList<>();
liste.add("tek eleman");
liste.get(5);  // IndexOutOfBoundsException!

Hata 4: Integer listede remove karışıklığı

ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(10, 20, 30));
nums.remove(1);              // indeks 1'deki elemanı siler (20)
nums.remove(Integer.valueOf(10)); // değer 10'u siler

Özet

  • ArrayList dinamik boyutlu listedir — eleman ekledikçe büyür, sildikçe küçülür

  • Generic tip (<String>, <Integer>) ile tür güvenliği sağlar

  • Temel metotlar: add(), get(), set(), remove(), contains(), size(), isEmpty(), clear()

  • Primitive tipler direkt kullanılamaz, wrapper sınıflar gerekir (int → Integer)

  • for-each döngüsü içinde eleman ekleme/silme yapma → ConcurrentModificationException

  • Sıralama için Collections.sort() kullanılır