Containers.Map

Struct mengakses data lewat nama field, tetapi nama field harus literal di kode — S.(f) boleh dinamis, namun field tetap terikat aturan identifier dan seluruh array berbagi satu skema. Kasus seperti buku telepon, katalog produk, atau tabel cache menuntut lebih: data dinomori key bebas (teks maupun angka), dicari dalam sekejap, ditambah dan dihapus kapan saja tanpa memindahkan elemen lain. MATLAB menjawabnya dengan containers.Map — key-value store berbasis hash map. Chapter ini membahas pembuatan hingga iterasi, lalu menimbangnya melawan struct.

Membuat Map: keySet dan valueSet #

Aturannya: M = containers.Map(keySet, valueSet) memasangkan setiap elemen keySet dengan elemen valueSet pada posisi yang sama. Mekanismenya: MATLAB membangun struktur hash dari key; tiap key unik menunjuk satu value, dan pencarian key tidak perlu menelusuri seluruh data. Tiga properti dilaporkan setiap Map: Count (jumlah pasangan), KeyType, dan ValueType.

kodeBuku = {'B002'; 'B001'; 'B003'};
judul    = {'Kalkulus'; 'Algoritma'; 'Fisika'};
M = containers.Map(kodeBuku, judul)

Output yang Dihasilkan:

M =
  Map with properties:

    Count     : 3
    KeyType   : char
    ValueType : char

Mari kita bedah hasil tersebut:

1. keySet (cell of char): tiga key teks — urutan pemasukan sengaja tidak alfabetis untuk ditunjukkan bedanya nanti.
2. KeyType: char / ValueType: char: key teks dan value teks; kedua tipe ini tercatat permanen — Map dengan KeyType char menolak key numerik.
3. Count: 3: jumlah pasangan key-value saat ini, terbaca juga lewat M.Count.

Map kosong dengan tipe tertentu dibuat lewat pasangan nama-nilai:

Mkosong = containers.Map('KeyType', 'double', 'ValueType', 'char');

KeyType yang didukung antara lain char, double, single, dan integer; ValueType bisa 'any' (bawaan) atau kelas tertentu — Mkosong di atas hanya menerima key angka dan value teks.

Akses, Menambah, dan isKey #

Aturannya: nilai diambil dengan M(key), pasangan baru ditambah dengan assignment M(keyBaru) = nilai, dan keberadaan key dites dengan isKey. Mekanismenya: M(key) melakukan pencarian hash — mengambil key yang tak ada memicu galat Key not found, sehingga isKey adalah penjaga sebelum akses.

fprintf('M(B002)   : %s\n', M('B002'));

M('B004') = 'Statistika';
fprintf('Setelah tambah B004, Count : %d\n', M.Count);

fprintf('isKey B001 : %d\n', isKey(M, 'B001'));
cek = isKey(M, {'B001', 'B009'});
fprintf('isKey list : %d %d\n', cek);

Output yang Dihasilkan:

M(B002)   : Kalkulus
Setelah tambah B004, Count : 4
isKey B001 : 1
isKey list : 1 0

Mari kita bedah baris-baris kode di atas:

1. Baris 1 (M('B002')): key 'B002' dipetakan ke value 'Kalkulus' — akses konstan waktu, tidak peduli Map berisi 4 atau 4 juta pasangan.
2. Baris 3 (M('B004') = ...): key baru lahir sekali assignment; Count naik dari 3 ke 4. Assignment pada key lama menimpa value-nya.
3. Baris 6-7 (isKey dengan char dan cell): versi cell menguji banyak key sekaligus dan mengembalikan vektor logical — 'B009' memang belum terdaftar.

keys, values, dan remove #

Aturannya: keys(M) mengembalikan seluruh key dalam cell array terurut; values(M) mengembalikan value dalam urutan key yang sama; remove(M, keySet) menghapus pasangan langsung di dalam Map. Mekanismenya: remove memodifikasi Map di tempat (in-place) dan tidak mengembalikan Map baru — perilaku yang berbeda dari rmfield pada struct yang mengembalikan salinan.

k = keys(M);
fprintf('keys   : %s %s %s %s\n', k{:});
v = values(M);
fprintf('values : %s %s %s %s\n', v{:});

remove(M, 'B003');
fprintf('Setelah remove B003, Count : %d\n', M.Count);
k2 = keys(M);
fprintf('keys tersisa : %s %s %s\n', k2{:});

Output yang Dihasilkan:

keys   : B001 B002 B003 B004
values : Algoritma Kalkulus Fisika Statistika
Setelah remove B003, Count : 3
keys tersisa : B001 B002 B004

Mari kita bedah hasil tersebut:

1. keys(M): meskipun B002 dimasukkan lebih dulu, daftar key yang dikembalikan terurut menaik — B001 B002 B003 B004.
2. values(M): urutan value mengikuti urutan key terurut, sehingga pasangan tetap sejajar bila kedua cell dicetak bersama.
3. remove(M, 'B003'): Count turun menjadi 3 dan key B003 lenyap dari daftar — penghapusan tidak menggeser memori data lain, inilah keunggulan hash map.

Key Numerik dan Iterasi Map #

Key tidak harus teks — array numerik juga sah, dan KeyType-nya menjadi double:

ids  = [101; 102; 103];
nama = {'Kopi'; 'Teh'; 'Gula'};
Mnum = containers.Map(ids, nama);
fprintf('Key numerik: KeyType %s, Mnum(101) = %s\n', Mnum.KeyType, Mnum(101));

Output yang Dihasilkan:

Key numerik: KeyType double, Mnum(101) = Kopi

Map tidak mendukung for langsung; iterasinya menumpang keys(M):

for i = 1:numel(k2)
  fprintf('%s -> %s\n', k2{i}, M(k2{i}));
end

Output yang Dihasilkan:

B001 -> Algoritma
B002 -> Kalkulus
B004 -> Statistika

Mekanismenya: keys(M) menyerahkan daftar terurut; loop mengambil key satu per satu lalu memanggil M(key) untuk value-nya — pola tiga baris yang mencakup seluruh isi Map.

Map vs Struct: Kapan yang Mana #

Ketiga baris terakhir menyarankan aturan praktis: gunakan Map ketika key-nya data (nomor ID, kode produk, teks bebas) dan isi berubah sepanjang hidup program; gunakan struct ketika field-nya skema tetap yang dikenal kode (konfigurasi aplikasi, record mahasiswa) — apalagi bila kode harus tetap berjalan di Octave. Satu catatan evolusi: sejak R2022b MATLAB merekomendasikan tipe dictionary sebagai penerus containers.Map — key/value bertipe lebih beragam dan performa lebih baik; containers.Map tetap sah dan banyak dipakai di kode lama, tetapi proyek baru di MATLAB modern sebaiknya memakai dictionary.

Ringkasan #

containers.Map(keySet, valueSet) membangun hash map dengan properti Count, KeyType, dan ValueType; nilai diambil dengan M(key), ditambah dengan assignment, dan dihapus dengan remove(M, key) yang bekerja in-place. isKey wajib menjaga akses terhadap key asing, keys/values mengembalikan isi terurut, dan iterasi menumpang loop atas keys(M). Map unggul untuk key berupa data yang dinamis; struct menang untuk skema tetap dan kompatibilitas Octave. Berkas contoh.m menuntaskan seluruh operasi dalam satu skrip MATLAB.