HashSet Java: Nilai Unik, Keanggotaan, dan Operasi Set

Set Menyimpan Nilai Unik

HashSet (dari java.util) adalah collection yang menyimpan setiap nilai paling banyak satu kali. Tidak ada key dan value yang dipasangkan seperti di HashMap, hanya sekumpulan elemen yang berbeda-beda. Tugas utamanya adalah menjawab satu pertanyaan dengan cepat: "apakah benda ini ada di sini?"

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");   // duplicate - ignored

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

Ada satu type parameter, <ElementType>. Sama seperti ArrayList dan HashMap, biasanya variabelnya diberi tipe interface Set, lalu yang dibuat adalah HashSet.

add Memberi Tahu Apakah Nilainya Baru

add tidak hanya menyimpan nilai: ia mengembalikan boolean yang memberi tahu apakah set-nya benar-benar berubah. Menambahkan nilai yang sudah ada akan mengembalikan false dan membiarkan set-nya tidak tersentuh.

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 was new
        System.out.println(seen.add(7));  // false - already there
        System.out.println(seen);
    }
}

Nilai return itu sangat berguna: if (!seen.add(x)) { /* x is a repeat */ } memungkinkanmu mendeteksi duplikat dalam satu baris sambil berjalan.

Menghapus Duplikat dari List

Karena set menolak nilai yang berulang, cara tercepat untuk membuang duplikat dari sebuah collection adalah memasukkannya ke dalam set. Constructor HashSet menerima collection lain apa pun:

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);          // each name once
        System.out.println(unique.size());   // 3

        // need a List back?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

Inilah alasan paling umum pemula memakai set. Ketahui saja bahwa urutan aslinya hilang dalam proses bolak-balik ini. Pakai LinkedHashSet kalau urutan itu penting (dibahas di bawah).

contains, remove, dan size

Operasi sehari-harinya mirip dengan collection lain:

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
    }
}

Keunggulan besarnya dibanding ArrayList ada pada contains. List harus menelusuri setiap elemen untuk menjawabnya (O(n)), sedangkan HashSet hampir langsung melompat ke jawabannya (kira-kira O(1)). Kalau kamu mendapati dirimu memanggil list.contains(...) di dalam loop, biasanya itu tanda untuk beralih ke set.

Operasi Set: Union, Intersection, Difference

Set paling bersinar saat digabungkan. Method-method ini mudah dibaca begitu kamu tahu mana yang mana:

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);            // everything in either set
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // only what's in both
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // in a but not b
        System.out.println(difference);   // 1 2
    }
}

Jebakan utamanya: addAll, retainAll, dan removeAll mengubah set tempat method itu dipanggil. Itulah sebabnya setiap contoh menyalin a ke HashSet baru terlebih dahulu; kalau tidak, set aslimu akan rusak. Buat set baru untuk setiap hasil.

HashSet Tidak Menjaga Urutan

Seperti HashMap, HashSet tidak menjanjikan urutan iterasi apa pun, dan urutannya bisa berbeda di antara satu eksekusi dan eksekusi berikutnya. Kalau kamu butuh urutan yang bisa diprediksi:

• LinkedHashSet menjaga urutan saat data dimasukkan, yaitu urutan kamu menambahkan elemen.
• TreeSet menjaga elemen tetap terurut berdasarkan urutan alaminya (atau Comparator yang kamu berikan).

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]
    }
}

Ketiganya mengimplementasikan interface Set, jadi menukar salah satunya cukup dengan mengubah satu baris di constructor.

Elemen Harus Bisa Di-hash

Di balik layar, HashSet didukung oleh HashMap, jadi aturan yang sama berlaku: ia menemukan elemen dengan melakukan hashing, artinya hashCode() dan equals() milik sebuah elemen harus selaras. Tipe bawaan seperti String dan Integer sudah melakukannya dengan benar, itulah sebabnya string "java" yang duplikat di atas tergabung dengan benar. Kalau kamu menyimpan instance dari class buatanmu sendiri, override equals dan hashCode sekaligus. Kalau tidak, dua objek yang maknanya "sama" akan dianggap berbeda, dan contains serta penghapusan duplikat akan gagal tanpa pemberitahuan.

Berikutnya: Iterasi Collection

Sekarang kamu sudah mengenal tiga collection andalan: ArrayList, HashMap, dan HashSet. Cara menelusuri masing-masing sedikit berbeda, dan ada jebakan yang halus (seperti mengubah collection saat sedang menelusurinya). Berikutnya kita akan merangkum semuanya dan membahas cara menelusuri collection dengan rapi memakai for-each loop, iterator, dan forEach.