EnumMap
Peta berkunci enum yang efisien.
EnumMap adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.
Apa Itu EnumMap?
EnumMap adalah Map khusus yang kuncinya merupakan konstanta dari satu tipe enumerasi.
Secara internal, EnumMap didukung oleh larik biasa yang diindeks berdasarkan ordinal konstanta. Ini membuat pencarian dan penyisipan sangat cepat tanpa hashing.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Day { MON, TUE, WED }
public static void main(String[] args) {
Map<Day, String> plan = new EnumMap<>(Day.class);
plan.put(Day.MON, "Gym");
plan.put(Day.WED, "Swim");
System.out.println(plan);
}
}Konstruksi Memerlukan Class
EnumMap harus mengetahui tipe kunci sejak awal, sehingga konstruktornya menerima objek Class: new EnumMap<>(Day.class).
Dengan cara ini, EnumMap dapat menentukan ukuran larik internal sesuai jumlah konstanta.
import java.util.EnumMap;
public class Main {
enum Priority { LOW, MEDIUM, HIGH }
public static void main(String[] args) {
EnumMap<Priority, Integer> counts = new EnumMap<>(Priority.class);
counts.put(Priority.HIGH, 5);
System.out.println(counts.get(Priority.HIGH));
}
}Kecepatan Berbasis Larik
Karena kunci disimpan di array[ordinal], get dan put merupakan akses langsung ke larik, lebih cepat daripada hashing dan penelusuran wadah milik HashMap.
Tidak ada pembungkusan kunci dan tidak ada pemanggilan hashCode.
import java.util.EnumMap;
public class Main {
enum Slot { A, B, C, D }
public static void main(String[] args) {
EnumMap<Slot, Integer> m = new EnumMap<>(Slot.class);
for (Slot s : Slot.values()) m.put(s, s.ordinal() * 10);
System.out.println(m.get(Slot.C));
}
}Iterasi dalam Urutan Kunci
EnumMap melakukan iterasi pada entri dalam urutan alami kunci, yaitu urutan deklarasinya.
Ini menghasilkan keluaran yang stabil dan dapat diprediksi, tidak seperti HashMap.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Phase { PLAN, BUILD, SHIP }
public static void main(String[] args) {
Map<Phase, Integer> hours = new EnumMap<>(Phase.class);
hours.put(Phase.SHIP, 3);
hours.put(Phase.PLAN, 8);
hours.put(Phase.BUILD, 20);
for (Map.Entry<Phase, Integer> e : hours.entrySet()) {
System.out.println(e.getKey() + " = " + e.getValue());
}
}
}Kunci Kosong Tidak Diizinkan
EnumMap tidak mengizinkan kunci kosong; kunci kosong akan melempar NullPointerException.
Nilai kosong diizinkan, seperti pada peta lainnya.
import java.util.EnumMap;
public class Main {
enum K { A, B }
public static void main(String[] args) {
EnumMap<K, String> m = new EnumMap<>(K.class);
m.put(K.A, null); // null value is fine
System.out.println("A -> " + m.get(K.A));
System.out.println("contains A: " + m.containsKey(K.A));
}
}Pengelompokan dengan EnumMap
Penggunaan yang umum adalah menghitung atau mengelompokkan berdasarkan kategori enumerasi. merge membuat penghitungan menjadi ringkas.
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
public class Main {
enum Type { FRUIT, VEG, MEAT }
record Item(String name, Type type) {}
public static void main(String[] args) {
List<Item> items = List.of(new Item("apple", Type.FRUIT), new Item("pear", Type.FRUIT), new Item("beef", Type.MEAT));
Map<Type, Integer> counts = new EnumMap<>(Type.class);
for (Item i : items) counts.merge(i.type(), 1, Integer::sum);
System.out.println(counts);
}
}getOrDefault dan computeIfAbsent
Semua metode bawaan Map standar dapat digunakan. getOrDefault menghindari pemeriksaan nilai kosong, sedangkan computeIfAbsent membuat nilai secara malas.
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
public class Main {
enum Group { A, B }
public static void main(String[] args) {
Map<Group, List<String>> m = new EnumMap<>(Group.class);
m.computeIfAbsent(Group.A, k -> new ArrayList<>()).add("first");
System.out.println(m);
System.out.println(m.getOrDefault(Group.B, List.of()));
}
}Konstruktor Penyalinan
EnumMap memiliki konstruktor penyalinan yang menerima Map lain. Jika sumbernya adalah EnumMap, tipe kuncinya disimpulkan dari sumber tersebut.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum K { X, Y }
public static void main(String[] args) {
EnumMap<K, Integer> a = new EnumMap<>(K.class);
a.put(K.X, 1);
EnumMap<K, Integer> b = new EnumMap<>(a);
b.put(K.Y, 2);
System.out.println("copy: " + b);
}
}EnumMap vs Larik ordinal
Sebelum EnumMap, orang menggunakan larik mentah yang diindeks berdasarkan ordinal(). Cara ini rapuh dan tidak aman.
EnumMap memberikan kecepatan larik yang sama, dengan keamanan tipe, keamanan batas, dan API Map yang bersih.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Season { SPRING, SUMMER, FALL, WINTER }
public static void main(String[] args) {
Map<Season, String> mood = new EnumMap<>(Season.class);
mood.put(Season.SUMMER, "sunny");
// Safer and clearer than String[] indexed by ordinal
System.out.println(mood.get(Season.SUMMER));
}
}EnumMaps Bertingkat
Anda dapat menyusun EnumMaps bertingkat untuk memodelkan matriks yang menggunakan dua enumerasi sebagai kunci, misalnya tabel transisi status.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum State { SOLID, LIQUID, GAS }
enum Transition { MELT, FREEZE }
public static void main(String[] args) {
Map<State, Map<Transition, State>> table = new EnumMap<>(State.class);
Map<Transition, State> solid = new EnumMap<>(Transition.class);
solid.put(Transition.MELT, State.LIQUID);
table.put(State.SOLID, solid);
System.out.println(table.get(State.SOLID).get(Transition.MELT));
}
}Memilih Type yang Tepat
Aturan praktis:
- Jika kuncinya adalah konstanta enumerasi dan Anda menginginkan peta, gunakan EnumMap.
- Jika Anda menginginkan himpunan enumerasi, gunakan EnumSet.
- Jika kuncinya adalah objek sembarang, gunakan HashMap.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Level { DEBUG, INFO, WARN, ERROR }
public static void main(String[] args) {
Map<Level, Integer> thresholds = new EnumMap<>(Level.class);
for (Level l : Level.values()) thresholds.put(l, l.ordinal() * 100);
System.out.println(thresholds);
}
}Pemeriksaan Cepat
Uji pengetahuan Anda tentang EnumMap.
Ringkasan
Anda telah mempelajari EnumMap:
- Map berbasis larik dengan kunci berupa konstanta enumerasi.
- Konstruktor menerima Class kunci; kunci kosong tidak diizinkan.
- Melakukan iterasi dalam urutan deklarasi.
- Pengganti yang aman dan cepat untuk larik yang diindeks berdasarkan ordinal.
Anda telah menyelesaikan kursus enumerasi tingkat lanjut.
import java.util.EnumMap;
public class Main {
enum K { A }
public static void main(String[] args) {
EnumMap<K, String> m = new EnumMap<>(K.class);
m.put(K.A, "done");
System.out.println("EnumMap course complete: " + m.get(K.A));
}
}Pertanyaan yang Sering Diajukan
Apakah pelajaran “EnumMap” gratis?
Ya — teks lengkap “EnumMap” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “EnumMap”?
Peta berkunci enum yang efisien. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Java Academy?
Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “EnumMap” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?
Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.