Java ListIterator: Koleksiyonlarda Daha Güçlü ve Esnek Dolaşım

Java ListIterator: Koleksiyonlarda Daha Güçlü ve Esnek Dolaşım

Giriş

Java’da koleksiyonlar (Collections Framework), veri yapılarını depolamak ve yönetmek için temel bir araç setidir. Bu koleksiyonlar üzerinde dolaşmak, elemanları okumak, eklemek, silmek veya güncellemek için çeşitli mekanizmalar mevcuttur. Geleneksel for döngüleri veya gelişmiş for-each döngüsü bu işlemlerin çoğunu basitleştirse de, belirli senaryolarda daha güçlü ve esnek bir araca ihtiyaç duyulur. İşte tam bu noktada java.util.Iterator ve onun daha gelişmiş bir türevi olan java.util.ListIterator devreye girer.

Iterator, bir koleksiyon üzerinde tek yönlü (ileri doğru) dolaşım yapmaya ve elemanları güvenli bir şekilde silmeye olanak tanır. Ancak, ListIterator, yalnızca List arayüzünü uygulayan koleksiyonlar için tasarlanmış olup, Iterator‘ın sunduğu yeteneklere ek olarak çift yönlü dolaşım, eleman ekleme, değiştirme ve imlecin konumunu belirten indeks bilgisi gibi önemli özellikler sunar. Bu makale, ListIterator‘ın derinlemesine incelenmesini, temel metotlarını, çeşitli kullanım senaryolarını, Iterator ile farklarını ve performans mülahazalarını detaylı bir şekilde ele alacaktır. Amacımız, Java geliştiricilerinin ListIterator‘ın gücünü tam olarak anlamalarına ve koleksiyon yönetimi görevlerinde daha etkili olmalarına yardımcı olmaktır.

ListIterator Nedir?

ListIterator, Java Collections Framework’ünde java.util.List arayüzünü uygulayan koleksiyonlar (örneğin ArrayList, LinkedList, Vector) üzerinde gezinmek, elemanları eklemek, değiştirmek ve silmek için özel olarak tasarlanmış bir arayüzdür. java.util.Iterator arayüzünden türemiştir, bu da Iterator‘ın tüm özelliklerini miras aldığı anlamına gelir. Ancak ListIterator, Iterator‘ın tek yönlü (ileri doğru) ve sınırlı yeteneklerini aşarak, liste tabanlı koleksiyonlar için çok daha zengin bir işlevsellik seti sunar.

ListIterator‘ı diğer dolaşım mekanizmalarından ayıran en önemli özellikler şunlardır:

1. Çift Yönlü Dolaşım: Hem ileri (next()) hem de geri (previous()) yönde elemanlar arasında gezinme yeteneği sunar. Bu, belirli bir elemanı bulduktan sonra hem sonraki hem de önceki elemanlara kolayca erişim imkanı sağlar.
2. Eleman Manipülasyonu: Dolaşım sırasında koleksiyona yeni elemanlar ekleyebilir (add()), mevcut elemanları değiştirebilir (set()) veya kaldırabilir (remove()). Bu, for-each döngüsü veya standart for döngüsü ile doğrudan yapılamayan veya ConcurrentModificationException riskini taşıyan işlemleri güvenli bir şekilde gerçekleştirmeyi sağlar.
3. İndeks Bilgisi: İmlecin mevcut konumunu ve bir sonraki veya önceki elemanın indeksini (nextIndex(), previousIndex()) döndürebilir. Bu, elemanların liste içindeki konumları hakkında bilgi edinmek gerektiğinde oldukça kullanışlıdır.

ListIterator nesnesi, bir List implementasyonunun listIterator() metodu çağrılarak elde edilir. Örneğin, ArrayList liste = new ArrayList<>(); ListIterator it = liste.listIterator(); şeklinde bir ListIterator örneği oluşturulabilir. Başlangıçta imleç, listenin ilk elemanından önce konumlanır.

ListIterator’ın Ana Metotları

ListIterator arayüzü, koleksiyonlar üzerinde güçlü ve esnek dolaşım ve manipülasyon sağlamak için bir dizi metot sunar. Bu metotlar, Iterator arayüzünde bulunan temel metotlara ek olarak, List‘e özgü yetenekleri de kapsar.

boolean hasNext()

Bu metot, imlecin ileri yönde bir elemanı daha olup olmadığını kontrol eder. Eğer varsa true, yoksa false döndürür. Genellikle bir while döngüsünün koşulu olarak kullanılırken, listenin sonuna kadar ileri doğru dolaşımı sağlar.

E next()

Bu metot, listedeki bir sonraki elemanı döndürür ve imleci bir pozisyon ileriye taşır. Eğer ileri yönde başka eleman yoksa (hasNext() metodu false döndürüyorsa) NoSuchElementException fırlatır. Bu metot, remove() ve set() metotlarının hangi elemanı etkileyeceğini belirler.

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

public class ListIteratorOrnek1 {
    public static void main(String[] args) {
        List diller = new ArrayList<>();
        diller.add("Java");
        diller.add("Python");
        diller.add("C++");

        ListIterator iterator = diller.listIterator();

        System.out.println("İleri Yönde Dolaşım:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

int nextIndex()

Bu metot, next() metodu tarafından döndürülecek olan elemanın indeksini döndürür. Eğer hasNext() false ise, listenin boyutunu döndürür. Bu metot, imlecin mantıksal konumunu anlamak için kullanışlıdır.

boolean hasPrevious()

Bu metot, imlecin geri yönde bir elemanı daha olup olmadığını kontrol eder. Eğer varsa true, yoksa false döndürür. previous() metoduyla birlikte, listenin başından sonuna veya sonundan başına dolaşım için kullanılır.

E previous()

Bu metot, listedeki bir önceki elemanı döndürür ve imleci bir pozisyon geriye taşır. Eğer geri yönde başka eleman yoksa (hasPrevious() metodu false döndürüyorsa) NoSuchElementException fırlatır. remove() ve set() metotları üzerinde de etkisi vardır.

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

public class ListIteratorOrnek2 {
    public static void main(String[] args) {
        List diller = new ArrayList<>();
        diller.add("Java");
        diller.add("Python");
        diller.add("C++");

        ListIterator iterator = diller.listIterator();

        // Önce listenin sonuna git
        while (iterator.hasNext()) {
            iterator.next();
        }

        System.out.println("\nGeri Yönde Dolaşım:");
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }
    }
}

int previousIndex()

Bu metot, previous() metodu tarafından döndürülecek olan elemanın indeksini döndürür. Eğer hasPrevious() false ise, -1 döndürür. nextIndex() gibi, imlecin konumunu indeks bazında anlamak için faydalıdır.

void remove()

Bu metot, next() veya previous() metotları tarafından en son döndürülen elemanı listeden kaldırır. remove() metodu, next() veya previous() çağrılmadan önce veya add() metodu çağrıldıktan sonra çağrılırsa IllegalStateException fırlatır. Ayrıca, her next() veya previous() çağrısından sonra yalnızca bir kez remove() çağrılabilir. Bu metot, koleksiyonun yapısını güvenli bir şekilde değiştirmenin ana yoludur.

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

public class ListIteratorOrnek3 {
    public static void main(String[] args) {
        List diller = new ArrayList<>();
        diller.add("Java");
        diller.add("Python");
        diller.add("C++");
        diller.add("JavaScript");

        ListIterator iterator = diller.listIterator();

        System.out.println("Önceki liste: " + diller);
        while (iterator.hasNext()) {
            String dil = iterator.next();
            if (dil.equals("C++")) {
                iterator.remove(); // "C++" elemanını listeden kaldır
            }
        }
        System.out.println("Sonraki liste (C++ kaldırıldı): " + diller);
    }
}

void set(E e)

Bu metot, next() veya previous() metotları tarafından en son döndürülen elemanı, belirtilen yeni eleman (e) ile değiştirir. remove() metodu gibi, set() de next() veya previous() çağrılmadan önce veya add() çağrıldıktan sonra çağrılırsa IllegalStateException fırlatır. Her next() veya previous() çağrısından sonra yalnızca bir kez set() çağrılabilir. Bu metot, mevcut elemanları dolaşım sırasında güncellemek için kullanılır.

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

public class ListIteratorOrnek4 {
    public static void main(String[] args) {
        List diller = new ArrayList<>();
        diller.add("Java");
        diller.add("Python");
        diller.add("C++");

        ListIterator iterator = diller.listIterator();

        System.out.println("Önceki liste: " + diller);
        while (iterator.hasNext()) {
            String dil = iterator.next();
            if (dil.equals("C++")) {
                iterator.set("C#"); // "C++" yerine "C#" koy
            }
        }
        System.out.println("Sonraki liste (C++ -> C#): " + diller);
    }
}

void add(E e)

Bu metot, imlecin şu anki konumuna, yani next() tarafından döndürülecek elemandan önce veya previous() tarafından döndürülecek elemandan sonra, belirtilen elemanı (e) ekler. Yeni eklenen eleman, next() çağrılırsa atlanır, ancak previous() çağrılırsa döndürülür. Bu metot, listeye dinamik olarak eleman eklemek için kullanılır ve remove() veya set() metotlarının aksine, bir next() veya previous() çağrısına ihtiyaç duymaz.

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

public class ListIteratorOrnek5 {
    public static void main(String[] args) {
        List diller = new ArrayList<>();
        diller.add("Java");
        diller.add("Python");
        diller.add("C++");

        ListIterator iterator = diller.listIterator();

        System.out.println("Önceki liste: " + diller);
        while (iterator.hasNext()) {
            String dil = iterator.next();
            if (dil.equals("Python")) {
                iterator.add("JavaScript"); // "Python"dan sonra "JavaScript" ekle
            }
        }
        System.out.println("Sonraki liste (JavaScript eklendi): " + diller);
    }
}

ListIterator ile Gelişmiş Kullanım Senaryoları

ListIterator‘ın sunduğu çift yönlü dolaşım ve eleman manipülasyonu yetenekleri, onu birçok karmaşık liste işleme senaryosunda vazgeçilmez kılar. İşte bazı örnekler:

İleriye ve Geriye Dolaşım

Bir listedeki tüm elemanları hem ileri hem de geri yönde işlememiz gerektiğinde ListIterator idealdir. Örneğin, bir liste elemanını ileri doğru tararken belirli bir elemana ulaşıldığında, o noktadan geri doğru taramaya başlamak.

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

public class ListIteratorSenaryo1 {
    public static void main(String[] args) {
        List sehirler = new ArrayList<>();
        sehirler.add("Ankara");
        sehirler.add("İstanbul");
        sehirler.add("İzmir");
        sehirler.add("Bursa");

        ListIterator iterator = sehirler.listIterator();

        System.out.println("İleriye doğru dolaşım:");
        while (iterator.hasNext()) {
            String sehir = iterator.next();
            System.out.println("Gidilen şehir: " + sehir + " (Index: " + iterator.previousIndex() + ")");
            if (sehir.equals("İzmir")) {
                System.out.println("İzmir bulundu! Geriye dönüyoruz...");
                break; // İzmir'i bulduktan sonra ileri dolaşımı durdur
            }
        }

        System.out.println("\nGeriye doğru dolaşım (İzmir'den itibaren):");
        while (iterator.hasPrevious()) {
            String sehir = iterator.previous();
            System.out.println("Geri gelinen şehir: " + sehir + " (Index: " + iterator.nextIndex() + ")");
        }
    }
}

Eleman Ekleme

Belirli bir koşula uyan bir elemandan sonra veya önce listeye yeni elemanlar eklemek için add() metodu kullanılır. Bu, for-each döngüsü ile doğrudan yapılamaz ve ConcurrentModificationException‘a yol açabilir.

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

public class ListIteratorSenaryo2 {
    public static void main(String[] args) {
        List meyveler = new ArrayList<>();
        meyveler.add("Elma");
        meyveler.add("Armut");
        meyveler.add("Muz");

        ListIterator iterator = meyveler.listIterator();

        System.out.println("Başlangıç listesi: " + meyveler);
        while (iterator.hasNext()) {
            String meyve = iterator.next();
            if (meyve.equals("Armut")) {
                iterator.add("Çilek"); // Armut'tan sonra Çilek ekle
            }
        }
        System.out.println("Güncel liste (Çilek eklendi): " + meyveler);
    }
}

Eleman Değiştirme

Dolaşım sırasında belirli bir koşulu sağlayan elemanları başka bir elemanla değiştirmek için set() metodu kullanılır.

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

public class ListIteratorSenaryo3 {
    public static void main(String[] args) {
        List sayilar = new ArrayList<>();
        sayilar.add(1);
        sayilar.add(2);
        sayilar.add(3);
        sayilar.add(4);

        ListIterator iterator = sayilar.listIterator();

        System.out.println("Başlangıç listesi: " + sayilar);
        while (iterator.hasNext()) {
            Integer sayi = iterator.next();
            if (sayi % 2 == 0) { // Çift sayıları 0 ile değiştir
                iterator.set(0);
            }
        }
        System.out.println("Güncel liste (Çift sayılar değiştirildi): " + sayilar);
    }
}

Eleman Silme

Belirli bir kritere uyan elemanları listeden güvenli bir şekilde kaldırmak için remove() metodu kullanılır.

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

public class ListIteratorSenaryo4 {
    public static void main(String[] args) {
        List urunler = new ArrayList<>();
        urunler.add("Laptop");
        urunler.add("Mouse");
        urunler.add("Klavye");
        urunler.add("Mouse"); // Duplicate

        ListIterator iterator = urunler.listIterator();

        System.out.println("Başlangıç listesi: " + urunler);
        while (iterator.hasNext()) {
            String urun = iterator.next();
            if (urun.equals("Mouse")) {
                iterator.remove(); // "Mouse" elemanlarını kaldır
            }
        }
        System.out.println("Güncel liste (Mouse kaldırıldı): " + urunler);
    }
}

Listeyi Tersten Yazdırma

ListIterator‘ın previous() metodunu kullanarak bir listeyi tersten yazdırmak oldukça kolaydır. Önce imleci listenin sonuna taşır, sonra geri doğru dolaşarak elemanları yazdırırız.

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

public class ListIteratorSenaryo5 {
    public static void main(String[] args) {
        List harfler = new ArrayList<>();
        harfler.add("A");
        harfler.add("B");
        harfler.add("C");
        harfler.add("D");

        ListIterator iterator = harfler.listIterator();

        // İmleci listenin sonuna taşı
        while (iterator.hasNext()) {
            iterator.next();
        }

        System.out.println("Listeyi tersten yazdırma:");
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }
    }
}

Iterator ve ListIterator Karşılaştırması

Iterator ve ListIterator her ikisi de Java koleksiyonları üzerinde dolaşım sağlamak için kullanılır, ancak yetenekleri ve kullanım alanları açısından önemli farklılıklar gösterirler.

| Özellik | Iterator | ListIterator |
| :—————— | :————————————- | :————————————— |
| Koleksiyon Tipi | Collection arayüzünü uygulayan tüm koleksiyonlar (Set, List, Queue vb.) | Sadece List arayüzünü uygulayan koleksiyonlar (ArrayList, LinkedList vb.) |
| Dolaşım Yönü | Tek yönlü (yalnızca ileri: hasNext(), next()) | Çift yönlü (ileri ve geri: hasNext(), next(), hasPrevious(), previous()) |
| Eleman Ekleme | Desteklemez (add() metodu yok) | Destekler (add(E e) metodu var) |
| Eleman Değiştirme | Desteklemez (set() metodu yok) | Destekler (set(E e) metodu var) |
| Eleman Silme | Destekler (remove() metodu var) | Destekler (remove() metodu var) |
| İndeks Bilgisi | Sağlamaz | Sağlar (nextIndex(), previousIndex()) |
| Başlangıç Konumu | Her zaman listenin başından başlar | Belirtilen bir indeksten başlatılabilir (list.listIterator(int index)) |

Özetle, genel bir koleksiyon üzerinde yalnızca ileri doğru dolaşım ve eleman silme yeterliyse Iterator tercih edilir. Ancak, List türündeki bir koleksiyon üzerinde daha karmaşık işlemler (çift yönlü dolaşım, ekleme, değiştirme, indeks bilgisi alma) gerekiyorsa, ListIterator çok daha güçlü ve uygun bir seçenektir.

Avantajlar ve Dikkat Edilmesi Gerekenler

ListIterator‘ın sunduğu yetenekler, Java koleksiyonları üzerinde çalışırken geliştiricilere önemli avantajlar sağlar, ancak bazı kısıtlamaları ve dikkat edilmesi gereken noktaları da vardır.

Avantajlar

* Esneklik: Çift yönlü dolaşım (ileri ve geri) sayesinde, listeler üzerinde daha karmaşık ve dinamik işlemler yapmak mümkündür. Bir elemanı bulduktan sonra hem ileri hem de geri yönde işlem yapma yeteneği büyük bir esneklik sunar.
* Güçlü Manipülasyon: add(), set(), ve remove() metotları sayesinde, koleksiyon elemanlarını dolaşım sırasında güvenli ve doğrudan bir şekilde ekleyebilir, değiştirebilir veya silebilirsiniz. Bu, for-each döngüsü veya for döngüsü ile dışarıdan koleksiyonu değiştirmeye çalışırken karşılaşılan ConcurrentModificationException riskini ortadan kaldırır.
* İndeks Bilgisi: nextIndex() ve previousIndex() metotları, imlecin ve elemanların liste içindeki konumları hakkında değerli indeks bilgileri sağlar. Bu, belirli konum tabanlı işlemler için önemlidir.
* Başlangıç Konumu: listIterator(int index) metodu ile dolaşımı listenin herhangi bir noktasından başlatabilme yeteneği, büyük listelerde performansı artırabilir ve belirli bir alt bölüm üzerinde odaklanmayı kolaylaştırır.

Dikkat Edilmesi Gerekenler

* Sadece List Türleri İçin: ListIterator, yalnızca java.util.List arayüzünü uygulayan koleksiyonlar için kullanılabilir. Set veya Queue gibi diğer koleksiyon türleri için kullanılamaz.
* IllegalStateException: remove() veya set() metotları, next() veya previous() metotları çağrılmadan önce veya add() metodu çağrıldıktan sonra çağrılırsa IllegalStateException fırlatır. Bu metotların her next() veya previous() çağrısından sonra yalnızca bir kez çağrılabileceği unutulmamalıdır.
* ConcurrentModificationException Riski: ListIterator kendi add(), remove(), set() metotlarını kullanarak listeyi değiştirdiğinde bu hatadan kaçınılır. Ancak, ListIterator oluşturulduktan sonra, listenin kendisi başka bir yolla (örneğin, list.add(), list.remove() veya başka bir Iterator/ListIterator örneği aracılığıyla) yapısal olarak değiştirilirse, ListIterator‘ın sonraki next(), previous(), remove(), set() veya add() çağrıları ConcurrentModificationException fırlatabilir. Bu, fail-fast (hata durumunda hızlıca durma) davranışının bir sonucudur.
* Performans Farklılıkları: ListIterator‘ın performansı, temel aldığı List implementasyonuna (örneğin ArrayList veya LinkedList) göre değişebilir. Özellikle add() ve remove() işlemleri, ArrayList için O(n) iken LinkedList için O(1) olabilir.

Performans ve ListIterator

ListIterator‘ın performansı, temel aldığı List implementasyonuna göre önemli farklılıklar gösterebilir. Java’daki en yaygın List implementasyonları ArrayList ve LinkedList‘tir ve her birinin ListIterator metotları üzerindeki etkileri farklıdır.

* ArrayList ile ListIterator:
* next() ve previous(): ArrayList dahili olarak bir dizi kullandığı için, elemanlara indeks üzerinden doğrudan erişim O(1) zaman karmaşıklığına sahiptir. ListIterator‘ın bu metotları da O(1) performans sunar, çünkü sadece dahili bir indeks işaretçisini güncellerler.
* add(E e): Bir eleman eklemek, o noktadan sonraki tüm elemanların kaydırılmasını gerektireceğinden O(n) zaman karmaşıklığına sahiptir.
* remove(): Bir eleman silmek de benzer şekilde, silinen elemandan sonraki tüm elemanların kaydırılmasını gerektirdiğinden O(n) zaman karmaşıklığına sahiptir.
* set(E e): Mevcut bir elemanı değiştirmek, doğrudan indeks üzerinden erişim olduğu için O(1) zaman karmaşıklığına sahiptir.

* LinkedList ile ListIterator:
* next() ve previous(): LinkedList dahili olarak çift bağlı bir liste yapısına sahiptir. ListIterator, listenin mevcut düğümüne bir referans tutar. Bu nedenle, next() ve previous() çağrıları sadece bu referansı bir sonraki veya bir önceki düğüme taşıdığından O(1) zaman karmaşıklığına sahiptir.
* add(E e): Bir eleman eklemek, sadece mevcut düğümün ve yeni düğümün referanslarını değiştirmeyi gerektirdiğinden O(1) zaman karmaşıklığına sahiptir.
* remove(): Bir eleman silmek de sadece ilgili düğümün referanslarını değiştirmeyi gerektirdiğinden O(1) zaman karmaşıklığına sahiptir.
* set(E e): Mevcut bir elemanın değerini değiştirmek, mevcut düğüme erişim O(1) olduğundan O(1) zaman karmaşıklığına sahiptir.

Sonuç: Eğer listenin ortasına sık sık eleman ekleme veya silme işlemleri yapmanız gerekiyorsa ve ListIterator kullanıyorsanız, LinkedList genellikle ArrayList‘ten daha iyi performans gösterecektir. Ancak, sadece elemanlar üzerinde dolaşım yapıp okuma veya set() ile değiştirme işlemleri çoğunluktaysa, her iki liste türü de next() ve previous() için iyi performans sunar. ArrayList, rastgele erişim (get(int index)) için daha hızlıdır, ancak ListIterator‘ın kendisi rastgele erişimden ziyade sıralı dolaşıma odaklanır.

Sonuç

java.util.ListIterator, Java Collections Framework’ünde List arayüzünü uygulayan koleksiyonlar için tasarlanmış güçlü ve esnek bir dolaşım ve manipülasyon aracıdır. Iterator‘ın temel tek yönlü dolaşım ve silme yeteneklerini aşarak, çift yönlü dolaşım, eleman ekleme, değiştirme ve indeks bilgisi sağlama gibi kritik özellikler sunar. Bu yetenekler, özellikle dinamik liste manipülasyonları, belirli bir noktadan hem ileri hem de geri yönde gezinme veya liste elemanlarını koşullu olarak güncelleme gibi karmaşık senaryolarda ListIterator‘ı vazgeçilmez kılar.

Makale boyunca ListIterator‘ın temel metotlarını (hasNext(), next(), hasPrevious(), previous(), add(), remove(), set(), nextIndex(), previousIndex()) detaylı örneklerle inceledik. Ayrıca, Iterator ile arasındaki temel farkları vurgulayarak, her birinin ne zaman tercih edilmesi gerektiğini belirttik. ListIterator‘ın avantajları, sağladığı esneklik ve güvenlik açısından önemliyken, IllegalStateException ve ConcurrentModificationException gibi potansiyel tuzaklara karşı dikkatli olunması gerektiği de belirtilmiştir. Performans mülahazaları bölümünde ise, ArrayList ve LinkedList gibi farklı List implementasyonları ile ListIterator metotlarının zaman karmaşıklıkları arasındaki farklara değinilmiştir.

Sonuç olarak, Java geliştiricileri, List koleksiyonları üzerinde ileri düzeyde kontrol ve manipülasyon gerektiren durumlarda ListIterator‘ı güvenle kullanabilirler. Doğru anlaşıldığında ve uygulandığında, ListIterator kodunuzu daha temiz, daha verimli ve daha az hataya açık hale getirecek güçlü bir araçtır.