Java’da ArrayList Nasıl Kullanılır? Ekleme, Silme ve Dolaşma Örnekleri

Java’da ArrayList kullanmak için java.util paketindeki ArrayList sınıfını içe aktarıp bir liste oluşturursun. Eleman eklendikçe boyutu büyüyebilen bu listeye add ile değer ekleyebilir, remove ile değer silebilir ve bir döngüyle elemanları sırayla inceleyebilirsin.

Java’da ArrayList nasıl oluşturulur?

Bir ArrayList oluşturmak için önce sınıfı içe aktarır, ardından listede tutacağın eleman türünü belirtirsin. Aşağıdaki örnek, öğrenci adlarını saklamak üzere boş bir liste oluşturur:

import java.util.ArrayList;

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

        System.out.println(ogrenciler.size());
    }
}

Beklenen çıktı:

0

İlk satırdaki import ifadesi, Java’ya ArrayList sınıfının hangi pakette bulunduğunu söyler. Liste oluşturulduğunda henüz eleman içermediği için size() metodu 0 döndürür.

ArrayList<String> ifadesindeki String, listede metinlerin tutulacağını belirtir. Bu kullanımda generic, koleksiyonda tutulacak eleman türünü String gibi bir tür parametresiyle belirtmene yarar. Böylece bu listeye yanlışlıkla farklı türde bir değer eklemeye çalıştığında Java derleme aşamasında hata verir.

Sağ taraftaki new ArrayList<>() yeni bir liste oluşturur. Köşeli ayraçlara benzeyen <> işaretleri, tür bilgisinin soldaki tanımdan anlaşılmasını sağlar.

Listedeki bir elemanın konumuna indeks denir. İndeksler sıfırdan başlar: İlk elemanın indeksi 0, ikinci elemanın indeksi 1 olur.

Eleman ekleme ve listeyi güncelleme

Listeye add ile eleman ekleyebilir, get ile bir elemanı okuyabilir ve set ile mevcut bir elemanı değiştirebilirsin. size ise listedeki eleman sayısını verir.

Aşağıdaki program, listeyi oluşturduktan sonra bu işlemleri sırayla uygular:

import java.util.ArrayList;

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

        ogrenciler.add("Ada");
        ogrenciler.add("Deniz");
        ogrenciler.add("Ece");

        System.out.println("İlk öğrenci: " + ogrenciler.get(0));

        ogrenciler.set(1, "Can");

        System.out.println("Güncel liste: " + ogrenciler);
        System.out.println("Eleman sayısı: " + ogrenciler.size());
    }
}

Beklenen çıktı:

İlk öğrenci: Ada
Güncel liste: [Ada, Can, Ece]
Eleman sayısı: 3

Her add çağrısı verilen adı listenin sonuna ekler. get(0) ilk eleman olan Ada’yı okur. Ardından set(1, "Can"), indeksi 1 olan Deniz’i Can ile değiştirir; listedeki eleman sayısı değişmez.

Bu listede üç eleman vardır ve geçerli indeksler 0, 1 ve 2 şeklindedir. Dolayısıyla liste boyutu 3, son geçerli indeks ise 2 olur. Boş olmayan bir listede son elemana ogrenciler.get(ogrenciler.size() - 1) ile erişebilirsin.

get veya set için negatif bir indeks ya da liste boyutuna eşit veya daha büyük bir indeks kullanırsan Java IndexOutOfBoundsException hatası üretir. Örneğin yukarıdaki üç elemanlı listede get(3) geçersizdir. Liste boşken de okunabilecek bir indeks bulunmadığından son elemana erişmeden önce isEmpty() ile boş olup olmadığını kontrol edebilirsin.

Eleman nasıl silinir ve aranır?

ArrayList içinde eleman silmek için remove, bir elemanın bulunup bulunmadığını kontrol etmek için contains, konumunu bulmak için ise indexOf kullanabilirsin. İndeks, elemanın listedeki konumunu gösterir ve sayım sıfırdan başlar.

remove("Ada"), listedeki ilk eşleşen Ada değerini siler. contains("Ada") değerin bulunmasına göre true veya false döndürür. indexOf("Ada") ilk eşleşmenin indeksini, değer bulunamazsa -1 döndürür.

import java.util.ArrayList;

public class ListeArama {
    public static void main(String[] args) {
        ArrayList<String> adlar = new ArrayList<>();
        adlar.add("Ada");
        adlar.add("Deniz");
        adlar.add("Ada");

        System.out.println(adlar.contains("Deniz"));
        System.out.println(adlar.indexOf("Ada"));

        adlar.remove("Ada");
        System.out.println(adlar);
        System.out.println(adlar.indexOf("Ece"));
    }
}

İlk Ada silindiği için listede ikinci Ada kalır. Beklenen çıktı şöyledir:

true
0
[Deniz, Ada]
-1

remove kullanırken sayı listelerinde dikkatli olmalısın. Integer, tam sayıları nesne olarak kullanmanı sağlayan bir sarmalayıcı sınıftır. Bir ArrayList<Integer> üzerinde sayilar.remove(1), değeri 1 olan elemanı değil, indeksi 1 olan elemanı siler. Değeri 1 olan ilk elemanı silmek için sayilar.remove(Integer.valueOf(1)) yazabilirsin.

ArrayList for, for-each ve forEach ile nasıl dolaşılır?

Bir ArrayList üzerinde klasik for, genişletilmiş for ve forEach metodu ile dolaşabilirsin. Klasik for, elemanın indeksine de ihtiyacın olduğunda kullanışlıdır; diğer iki yöntemle elemanlara doğrudan erişebilirsin.

Aşağıdaki program aynı listeyi üç yöntemle yazdırır. Klasik döngüde size() eleman sayısını, get(i) ise ilgili indeksteki elemanı verir.

import java.util.ArrayList;

public class ListeDolas {
    public static void main(String[] args) {
        ArrayList<String> adlar = new ArrayList<>();
        adlar.add("Ada");
        adlar.add("Deniz");

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

        for (String ad : adlar) {
            System.out.println(ad);
        }

        adlar.forEach(ad -> System.out.println(ad));
    }
}

forEach içindeki ad -> ... ifadesi, her eleman için yapılacak işlemi belirtir. Programın çıktısında ilk iki satır indeksleri de gösterir:

0: Ada
1: Deniz
Ada
Deniz
Ada
Deniz

Genişletilmiş for döngüsü sırasında listeye doğrudan eleman eklemek veya listeden eleman silmek ConcurrentModificationException hatasına yol açabilir. Hata her durumda ortaya çıkmayabileceği için döngünün güvenli çalıştığını bu hatanın yokluğuna bakarak değerlendirme.

Dolaşırken eleman silmen gerekiyorsa Iterator kullanabilirsin. Aşağıdaki parça, önceki programdaki liste üzerinde çalışır; next() ile alınan elemanı iterator.remove() siler:

java.util.Iterator<String> iterator = adlar.iterator();

while (iterator.hasNext()) {
    String ad = iterator.next();
    if (ad.equals("Ada")) {
        iterator.remove();
    }
}

System.out.println(adlar);

Bu parçanın çıktısı [Deniz] olur. Silme işlemini doğrudan adlar.remove(ad) ile değil, dolaşmayı yöneten iterator üzerinden yapmış olursun.

Öğrenci adlarıyla çalışan konsol programı

Aşağıdaki program öğrenci adlarını bir ArrayList içine ekler, listede değişiklik ve arama yapar, ardından kalan adları üç farklı yöntemle yazdırır. ArrayList, eleman eklendikçe boyutu büyüyebilen bir listedir ve java.util paketinden içe aktarılır.

Kodda String, listenin metin tutacağını belirten generic tür parametresidir. İndeks ise bir elemanın listedeki konumunu gösterir ve sayım sıfırdan başlar.

import java.util.ArrayList;

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

        ogrenciler.add("Ada");
        ogrenciler.add("Deniz");
        ogrenciler.add("Ece");
        System.out.println("Eklenenler: " + ogrenciler);

        System.out.println("İlk öğrenci: " + ogrenciler.get(0));

        ogrenciler.set(1, "Can");
        System.out.println("Güncel liste: " + ogrenciler);
        System.out.println("Öğrenci sayısı: " + ogrenciler.size());

        System.out.println("Can listede mi? " + ogrenciler.contains("Can"));
        System.out.println("Ece'nin indeksi: " + ogrenciler.indexOf("Ece"));

        ogrenciler.remove("Ada");
        System.out.println("Silme sonrası: " + ogrenciler);

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

        System.out.println("for-each:");
        for (String ad : ogrenciler) {
            System.out.println(ad);
        }

        System.out.println("forEach:");
        ogrenciler.forEach(ad -> System.out.println(ad));
    }
}

Programın beklenen çıktısı şöyledir:

Eklenenler: [Ada, Deniz, Ece]
İlk öğrenci: Ada
Güncel liste: [Ada, Can, Ece]
Öğrenci sayısı: 3
Can listede mi? true
Ece'nin indeksi: 2
Silme sonrası: [Can, Ece]
for:
Can
Ece
for-each:
Can
Ece
forEach:
Can
Ece

get(0) ilk adı okur, set(1, "Can") ise ikinci sıradaki adı değiştirir. contains aranan adın bulunup bulunmadığını, indexOf ise ilk bulunduğu konumu gösterir; ad listede yoksa indexOf sonucu -1 olur.

Üç dolaşma yöntemi de silme işleminden sonra kalan adları sırayla yazdırır. Klasik for döngüsünde indeksi kendin kullanırsın; diğer iki yöntemde her ad üzerinden işlem yaparsın.

İlkel türler ve sık yapılan hatalar

ArrayList tanımlarken int ve double gibi ilkel türleri doğrudan generic tür parametresi olarak kullanamazsın. Bunun yerine, ilkel bir değerin nesne olarak kullanılmasını sağlayan sarmalayıcı sınıfları seçersin: int için Integer, double için Double kullanılır.

ArrayList<Integer> sayilar = new ArrayList<>();
sayilar.add(12);

ArrayList<Double> notlar = new ArrayList<>();
notlar.add(85.5);

System.out.println(sayilar);
System.out.println(notlar);

Bu satırlar, gerekli ArrayList içe aktarımı bulunan bir programın içinde çalıştırıldığında şu çıktıyı üretir:

[12]
[85.5]

Değerleri eklerken Java, 12 ve 85.5 gibi ilkel değerleri uygun sarmalayıcı türlere otomatik olarak dönüştürür. Bu işleme otomatik kutulama denir.

Kodunu kontrol ederken şu noktalara bakabilirsin:

• ArrayList<int> yerine ArrayList<Integer> yaz.
• Eleman sayısını öğrenmek için length yerine size() kullan.
• Geçerli indeksleri kullan: İlk indeks 0, son indeks size() - 1 değeridir.
• for-each ile dolaşırken liste üzerinden doğrudan eleman silme. Silme gerekiyorsa bir Iterator kullanıp onun remove() metodunu çağırabilirsin.

Bu örnekteki işlemleri farklı adlar ve arama değerleriyle deneyerek listenin her adımda nasıl değiştiğini inceleyebilirsin.