Java HashSet: Benzersiz Değerler, Üyelik ve Küme İşlemleri

Bir Küme Benzersiz Değerleri Saklar

Bir HashSet (java.util paketinden) her değeri en fazla bir kez tutan bir koleksiyondur. HashMap'teki gibi eşleştirilmiş anahtarlar ve değerler yoktur; yalnızca farklı elemanlardan oluşan bir torba vardır. Tek işi bir soruyu hızlıca yanıtlamaktır: "bu şey burada mı?"

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // yinelenen - yok sayılır

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

Tek bir tip parametresi vardır, <ElementType>. ArrayList ve HashMap'te olduğu gibi, değişkeni genellikle Set arayüzü tipiyle tanımlar ve bir HashSet oluşturursunuz.

add, Değerin Yeni Olup Olmadığını Döndürür

add yalnızca değeri saklamakla kalmaz; kümenin gerçekten değişip değişmediğini söyleyen bir boolean döndürür. Zaten var olan bir değeri eklemek false döndürür ve kümeyi olduğu gibi bırakır.

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> seen = new HashSet<>();

        System.out.println(seen.add(7));  // true  - 7 yeniydi
        System.out.println(seen.add(7));  // false - zaten vardı
        System.out.println(seen);
    }
}

Bu dönüş değeri gerçekten kullanışlıdır: if (!seen.add(x)) { /* x bir tekrar */ } ilerlerken yinelenenleri tek satırda tespit etmenizi sağlar.

Bir Listeden Yinelenenleri Kaldırma

Bir küme tekrarları reddettiği için, bir koleksiyondaki yinelenenleri temizlemenin en hızlı yolu onu bir kümeye boşaltmaktır. HashSet yapıcısı başka herhangi bir koleksiyonu kabul eder:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Boris", "Ada", "Chen", "Boris"));

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // her isim bir kez
        System.out.println(unique.size());   // 3

        // tekrar bir List mi lazım?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

Bu, yeni başlayanların bir kümeye başvurmasının en yaygın nedenidir. Yalnızca şunu bilin: bu gidiş dönüşte orijinal sırayı kaybedersiniz; sıra önemliyse LinkedHashSet kullanın (aşağıda ele alınıyor).

contains, remove ve size

Günlük işlemler diğer koleksiyonlarınkini yansıtır:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

Bir ArrayList'e göre en büyük kazanım contains'tir. Bir liste bunu yanıtlamak için her elemanı dolaşmak zorundadır (O(n)); bir HashSet neredeyse doğrudan yanıta atlar (kabaca O(1)). Kendinizi bir döngü içinde list.contains(...) çağırırken bulduğunuzda, bu genellikle bir kümeye geçmenin işaretidir.

Küme İşlemleri: Birleşim, Kesişim, Fark

Kümeler onları birleştirdiğinizde parlar. Hangisinin hangisi olduğunu bildiğinizde yöntemler neredeyse günlük dil gibi okunur:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Set.of(1, 2, 3, 4));
        Set<Integer> b = new HashSet<>(Set.of(3, 4, 5, 6));

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // iki kümeden herhangi birindeki her şey
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // yalnızca ikisinde de olanlar
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // a'da olup b'de olmayanlar
        System.out.println(difference);   // 1 2
    }
}

Asıl tuzak: addAll, retainAll ve removeAll üzerinde çağrıldıkları kümeyi değiştirir. Her örneğin önce a'yı taze bir HashSet'e kopyalamasının nedeni budur; aksi takdirde orijinalinizi yok edersiniz. Her sonuç için yeni bir küme oluşturun.

HashSet Sırayı Korumaz

HashMap gibi, bir HashSet de hiçbir yineleme sırası garantisi vermez ve sıra çalıştırmadan çalıştırmaya değişebilir. Öngörülebilirliğe ihtiyacınız varsa:

• LinkedHashSet ekleme sırasını, yani elemanları eklediğiniz sırayı korur.
• TreeSet elemanları doğal sıralamaya göre (ya da sağladığınız bir Comparator'a göre) sıralı tutar.

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

Üçü de Set arayüzünü uygular, dolayısıyla aralarında geçiş yapmak yapıcıda tek satırlık bir değişikliktir.

Elemanlar Hash'lenebilir Olmalı

Bir HashSet arka planda bir HashMap ile desteklenir, dolayısıyla aynı kural geçerlidir: elemanları onların hash'ini hesaplayarak bulur, bu da bir elemanın hashCode() ve equals() metotlarının uyumlu olması gerektiği anlamına gelir. String ve Integer gibi yerleşik tipler bunu zaten doğru yapar; yukarıda yinelenen "java" dizgelerinin doğru şekilde birleşmesinin nedeni budur. Kendi sınıfınızın örneklerini saklarsanız, hem equals hem de hashCode'u geçersiz kılın; aksi takdirde anlam olarak "eşit" olan iki nesne farklı kabul edilir ve contains ile yinelenen temizleme sessizce başarısız olur.

Sıradaki: Koleksiyonları Dolaşma

Artık üç ana koleksiyonla tanıştınız: ArrayList, HashMap ve HashSet. Her birinde biraz farklı dolaşırsınız ve ince tuzaklar vardır (bir koleksiyonu üzerinde döngü kurarken değiştirmek gibi). Sırada her şeyi bir araya getirecek ve koleksiyonları for-each döngüsü, yineleyiciler ve forEach ile temiz bir şekilde dolaşmayı ele alacağız.