Java ArrayList remove(1): İndeks mi, Değer mi?

Java ArrayList remove(1) çağrısında 1, silinecek değeri değil, silinecek elemanın indeksini ifade eder. Çünkü sayı doğrudan bir int olarak yazıldığında Java, remove(int index) yöntemini seçer. İndeksler 0'dan başladığı için 1 numaralı indeks, listenin ikinci elemanıdır.

Bu davranışı ilk gördüğünde şaşırman oldukça normaldir; burada sorun dikkatsizlik değil, ArrayList sınıfında aynı ada sahip iki farklı remove yönteminin bulunmasıdır. Birebir Java yazılım eğitimi gibi çalışmalarda da bu ayrım, sözdiziminden önce çağrının hangi yöntemle eşleştiğini düşünerek daha kolay anlaşılır.

ArrayList<Integer> içinde remove(1) neden ikinci elemanı siler?

Örneğin elimizde aşağıdaki liste olsun:

Bu listede list.remove(1) yazıldığında Java, listedeki değeri 1 olan ilk elemanı aramaz. Çağrıdaki 1 bir int değeri olduğu için remove(int index) yöntemini seçer ve 1 numaralı indeksteki 7 değerini siler. İşlemden sonra liste [1, 1, 4] hâline gelir.

Buradaki temel kural şudur: 0 ilk elemanı, 1 ikinci elemanı, 2 üçüncü elemanı gösterir. Yani indeks ile değer aynı şey değildir. Bir listenin ikinci sırasında 7 bulunabilir; bu durumda remove(1) ifadesi 1 değerini değil, ikinci sıradaki 7 değerini hedefler.

remove(int index) ile remove(Object value) arasındaki fark

ArrayList üzerinde iki farklı remove yöntemi bulunur:

• remove(int index), belirtilen konumdaki elemanı siler ve silinen elemanı döndürür.
• remove(Object value), verilen değerin listedeki ilk örneğini siler ve işlemin gerçekleşip gerçekleşmediğini boolean olarak bildirir.

ArrayList<Integer> kullanırken önemli ayrım, int ile Integer arasındadır. remove(1) içindeki 1 doğrudan int olduğu için indeks yöntemi seçilir. Integer.valueOf(1) ise bir Integer nesnesi üretir ve çağrıyı değer silme yöntemine yönlendirir. Bu, Java'nın temel türlerle nesne türleri arasındaki autoboxing ilişkisinin pratikte görülen sonuçlarından biridir.

import java.util.ArrayList;

public class RemoveOrnegi {
    public static void main(String[] args) {
        ArrayList<Integer> indeksListesi = new ArrayList<>();
        indeksListesi.add(1);
        indeksListesi.add(7);
        indeksListesi.add(1);
        indeksListesi.add(4);
        indeksListesi.remove(1);

        ArrayList<Integer> degerListesi = new ArrayList<>();
        degerListesi.add(1);
        degerListesi.add(7);
        degerListesi.add(1);
        degerListesi.add(4);
        degerListesi.remove(Integer.valueOf(1));

        ArrayList<Integer> kosulListesi = new ArrayList<>();
        kosulListesi.add(1);
        kosulListesi.add(7);
        kosulListesi.add(1);
        kosulListesi.add(4);
        kosulListesi.removeIf(value -> value.equals(1));

        System.out.println(indeksListesi);
        System.out.println(degerListesi);
        System.out.println(kosulListesi);
    }
}

Çıktı sırasıyla [1, 1, 4], [7, 1, 4] ve [7, 4] olur. Kısaca karar akışı şöyledir: konum mu? remove(index); tek bir değer mi? remove(Integer.valueOf(value)); koşulu sağlayan tüm elemanlar mı? removeIf(...). removeIf, koşulu doğru olan tüm elemanları kaldırır.

Çalışan kod örneği: üç silme yönteminin çıktısı

Aşağıdaki örnekte liste her işlemden önce yeniden oluşturulur. Böylece bir silme işleminin sonucu, sonraki işlemi etkilemez.

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers;

        numbers = new ArrayList<>(List.of(1, 7, 1, 4));
        numbers.remove(1);
        System.out.println("remove(1): " + numbers);

        numbers = new ArrayList<>(List.of(1, 7, 1, 4));
        numbers.remove(Integer.valueOf(1));
        System.out.println("remove(Integer.valueOf(1)): " + numbers);

        numbers = new ArrayList<>(List.of(1, 7, 1, 4));
        boolean changed = numbers.removeIf(value -> value.equals(1));
        System.out.println("removeIf: " + numbers);
        System.out.println("Liste değişti mi: " + changed);
    }
}

Bu kodun beklenen konsol çıktısı şöyledir:

removeIf, koşulu sağlayan bütün elemanları kaldırır. Ayrıca listenin değişip değişmediğini belirten bir boolean sonuç döndürebilir. Bu örnekte changed değişkeninin değeri true olur; ancak asıl dikkat edilen sonuç listenin [7, 4] hâline gelmesidir.

Not listesi üzerinde çalışırken “belirli konumdaki notu silmek” ile “değeri 1 olan ilk notu silmek” aynı amaç değildir. Alışveriş sepetinde ise belirli bir koşulu karşılayan tüm kayıtları, örneğin miktarı sıfır olan ürünleri, removeIf ile birlikte ele alabilirsin.

Geçersiz indeks ve bulunamayan değer durumunda ne olur?

İndeksle silme işleminde geçerli aralık 0 ile size() - 1 arasındadır. Örneğin listenin dört elemanı varsa geçerli indeksler 0, 1, 2 ve 3 olur. Liste boşsa ya da verilen indeks mevcut son indexten büyük veya ona eşitse remove(int index) çağrısı çalışma zamanında IndexOutOfBoundsException oluşturabilir.

List<Integer> numbers = new ArrayList<>(List.of(1, 7));

numbers.remove(2); // IndexOutOfBoundsException

Değerle silmede aranan Integer listede yoksa liste değişmeden kalır. remove(Object value) bu durumda false döndürebilir. Değer listede varsa yalnızca ilk eşleşme kaldırılır ve sonuç true olur.

List<Integer> numbers = new ArrayList<>(List.of(1, 7, 4));

boolean removed = numbers.remove(Integer.valueOf(9));

System.out.println(numbers); // [1, 7, 4]
System.out.println(removed);  // false

• Liste boş mu?
• İndeks, sınırlar içinde mi?
• Gerçekten konum mu, yoksa değer mi siliniyor?
• Değer bulunamazsa dönüş değeri kontrol ediliyor mu?

Hangi durumda hangi silme yöntemini seçmelisin?

ArrayList içinden eleman silerken önce neyi hedeflediğini belirlemen yeterlidir: konum mu, tek bir değer mi, yoksa belirli bir koşulu sağlayan tüm elemanlar mı?

Üç adımlı karar çerçevesi:

1. Silmek istediğin şey indeks mi? Konumu biliyorsan remove(index) kullan. Örneğin liste.remove(1), indeks numarası 1 olan elemanı siler.
2. Silmek istediğin şey tek bir değer mi? Değeri hedefliyorsan Integer.valueOf(deger) veya doğrudan bir Integer değişkeni kullanarak remove(Object) çağrısını tercih et. Örneğin liste.remove(Integer.valueOf(1)), değeri 1 olan ilk elemanı siler.
3. Koşula uyan tüm elemanlar mı silinecek? Birden fazla elemanı kurala göre kaldırmak için removeIf kullan. Örneğin liste.removeIf(sayi -> sayi < 0), negatif olan tüm sayıları siler.

Sade akış şeması:

İndeks mi? → remove(index)
Değer mi? → remove(Integer.valueOf(...))
Koşula uyanların tümü mü? → removeIf(...)

String listelerinde remove("1") kullanımı daha sezgisel görünür. Bunun nedeni, "1" ifadesinin zaten String olması ve değer temelli remove(Object) çağrısının doğal biçimde seçilmesidir. ArrayList içinde ise remove(1) ifadesi int türündedir; bu nedenle Java bunu indeks olarak yorumlar.

Benzer tür ve metot ayrımlarını kendi başına denemek istersen Java bilgi testini kullanarak temel konulardaki yaklaşımını kontrol edebilirsin.

Sık Sorulan Sorular

ArrayList<Integer> içinde değeri silmek için neden doğrudan remove(1) kullanamıyorum?

Çünkü remove(1) ifadesindeki 1 bir int değeridir ve Java uygun metot olarak indeks alan remove(int index) seçimini yapar. Değeri silmek için remove(Integer.valueOf(1)) yazmalısın.

remove(Integer.valueOf(1)) hangi elemanı siler?

Listedeki değeri 1 olan ilk elemanı siler. Listede 1 değeri yoksa liste değişmeden kalır.

removeIf ile remove(Object) arasındaki temel fark nedir?

remove(Object) belirli bir değerin ilk eşleşmesini siler. removeIf ise verdiğin koşulu sağlayan tüm elemanları kaldırır.

ArrayList'te geçersiz bir indeks verirsem hangi durumla karşılaşırım?

İndeks, listenin geçerli aralığının dışındaysa Java IndexOutOfBoundsException hatası oluşturur. Bu nedenle silmeden önce indeksin listede gerçekten bulunduğundan emin olmalısın.

Doğru silme yöntemini seçmenin anahtarı, önce “konumu mu, değeri mi, yoksa koşulu mu hedefliyorum?” sorusunu yanıtlamaktır.

, eğitmenimiz Berk Keskin