Tutorial Lengkap Penggunaan Map di Java

Dalam pemrograman Java, Map adalah salah satu bagian penting dari Java Collection Framework yang digunakan untuk menyimpan data dalam bentuk key-value pairs. Map sangat berguna untuk kasus-kasus seperti:

✔ Menyimpan data unik berdasarkan kunci, misalnya daftar pengguna dengan ID unik.
✔ Mencari data dengan cepat berdasarkan kunci, seperti kamus atau cache.
✔ Mengelola data tanpa memperdulikan urutan atau mempertahankan urutan tertentu.

Dalam artikel ini, kita akan membahas berbagai implementasi Map di Java, beserta contoh kode dan tips penggunaannya.

1. Apa Itu Map di Java?

Map<K, V> adalah interface dalam paket java.util yang digunakan untuk menyimpan pasangan key (kunci) dan value (nilai). Beberapa karakteristik utama Map:

✅ Key harus unik, tetapi value bisa duplikat.
✅ Tidak memiliki indeks seperti List.
✅ Mendukung berbagai implementasi dengan karakteristik berbeda.

2. Implementasi Map di Java

a) HashMap: Map dengan Performa Tinggi

HashMap adalah implementasi Map yang paling umum digunakan. Elemen disimpan dalam struktur hash table, sehingga akses data sangat cepat (O(1) dalam banyak kasus).

Contoh Penggunaan HashMap:

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");
        map.put(1, "Kotlin"); // Mengganti value pada key 1

        System.out.println(map); // Output: {1=Kotlin, 2=Python, 3=C++}
        System.out.println(map.get(2)); // Output: Python
    }
}

📌 Kelebihan: Cepat dalam put, get, dan remove (O(1)).
📌 Kekurangan: Tidak mempertahankan urutan elemen.

b) LinkedHashMap: Map dengan Urutan Terjaga

LinkedHashMap mirip dengan HashMap, tetapi mempertahankan urutan penambahan elemen.

Contoh Penggunaan LinkedHashMap:

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<>();
        map.put(3, "C++");
        map.put(1, "Java");
        map.put(2, "Python");

        System.out.println(map); // Output: {3=C++, 1=Java, 2=Python}
    }
}

📌 Kelebihan: Mempertahankan urutan penambahan elemen.
📌 Kekurangan: Sedikit lebih lambat dibandingkan HashMap.

c) TreeMap: Map dengan Key Terurut

TreeMap menyimpan elemen dalam urutan key yang terurut secara alami (ascending). Implementasi ini menggunakan struktur Red-Black Tree.

Contoh Penggunaan TreeMap:

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<>();
        map.put(3, "C++");
        map.put(1, "Java");
        map.put(2, "Python");

        System.out.println(map); // Output: {1=Java, 2=Python, 3=C++} (terurut ascending)
    }
}

📌 Kelebihan: Elemen terurut berdasarkan key.
📌 Kekurangan: Operasi put, get, dan remove lebih lambat (O(log n)) dibandingkan HashMap.

d) ConcurrentHashMap: Map untuk Multi-threading

Jika Anda bekerja dalam lingkungan multi-threading, gunakan ConcurrentHashMap, yang aman digunakan oleh banyak thread tanpa perlu sinkronisasi manual.

Contoh Penggunaan ConcurrentHashMap:

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new ConcurrentHashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");

        System.out.println(map); // Output: {1=Java, 2=Python}
    }
}

📌 Kelebihan: Thread-safe, lebih cepat dibanding Collections.synchronizedMap().
📌 Kekurangan: Lebih berat dibanding HashMap karena mekanisme concurrency.

3. Operasi Dasar pada Map

Berikut adalah operasi dasar yang bisa dilakukan pada Map:

import java.util.HashMap;
import java.util.Map;

public class MapOperations {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();

        // Menambahkan elemen
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 28);

        // Mengakses nilai berdasarkan key
        System.out.println(ages.get("Alice")); // Output: 25

        // Menghapus elemen
        ages.remove("Bob");

        // Mengecek apakah key ada
        System.out.println(ages.containsKey("Charlie")); // Output: true

        // Iterasi key-value
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
    }
}

✅ put(key, value) – Menambahkan atau memperbarui nilai.
✅ get(key) – Mengambil nilai berdasarkan key.
✅ remove(key) – Menghapus elemen berdasarkan key.
✅ containsKey(key) – Mengecek apakah key ada di dalam Map.
✅ containsValue(value) – Mengecek apakah value ada di dalam Map.
✅ size() – Mendapatkan jumlah elemen dalam Map.

4. Perbandingan Implementasi Map

Fitur	HashMap	LinkedHashMap	TreeMap	ConcurrentHashMap
Urutan Terjaga	❌	✅	✅ (sorted)	❌
Kecepatan Operasi	🔥 Cepat (O(1))	⚡ Sedikit lebih lambat	🐢 Lebih lambat (O(log n))	⚡ Cepat (thread-safe)
Struktur Data	Hash Table	Hash Table + Linked List	Red-Black Tree	Segmented Hash Table
Thread-Safe	❌	❌	❌	✅

🔥 Gunakan HashMap untuk performa terbaik jika urutan tidak penting.
🔄 Gunakan LinkedHashMap jika ingin mempertahankan urutan.
📈 Gunakan TreeMap jika ingin elemen selalu dalam keadaan terurut.
🛡 Gunakan ConcurrentHashMap jika bekerja dalam lingkungan multi-threading.

Kesimpulan

Map digunakan untuk menyimpan key-value pairs.
HashMap cepat tetapi tidak menjaga urutan.
LinkedHashMap mempertahankan urutan input.
TreeMap menyimpan elemen dalam urutan key ascending.
ConcurrentHashMap cocok untuk aplikasi multi-threading.

Sumber dan Referensi

https://docs.oracle.com/javase/8/docs/api/java/util/Map.html diakses 19 Maret 2025
https://www.geeksforgeeks.org/map-interface-java-examples/ diakses 20 Maret 2025

Lokasi:

Sufyan97