Materi ini sangat penting di Dart/Flutter, karena Map hampir selalu muncul ketika kamu bekerja dengan JSON, API, Firebase, SQLite, konfigurasi, dan data berbentuk key-value.

Ada beberapa kesalahan speech-to-text di transcript yang perlu kita luruskan:

• list → List
• set/state → Set
• math/map → Map
• split tree map → SplayTreeMap
• put if upset → putIfAbsent()
• remover → removeWhere()
• map method → map()
• off → of()
• unmodified → unmodifiable()
• foreign loop → for / for-in loop

Saya akan menjelaskannya dari paling dasar sampai method-method pentingnya.

1. Apa itu Map?

Sebelumnya kita sudah belajar:

List

Menyimpan data berdasarkan urutan/index:

List<String> names = [
  'Budi',
  'Andi',
  'Citra',
];

Akses:

print(names[0]);

Hasil:

Budi

Set

Menyimpan data yang unik:

Set<String> names = {
  'Budi',
  'Andi',
  'Citra',
};

Duplicate tidak diperbolehkan.

Map

Nah, Map sedikit berbeda.

Map menyimpan data dalam bentuk:

key → value

Contoh:

Map<String, dynamic> person = {
  'name': 'Budi',
  'age': 25,
};

Bisa dibayangkan seperti tabel:

Jadi Map bukan sekadar kumpulan value.

Setiap data harus mempunyai key.

2. Analogi paling mudah

Bayangkan kamu mempunyai lemari dengan label.

+-----------------------+
| name   → Budi         |
| age    → 25           |
| salary → 5000000      |
+-----------------------+

Di sini:

name   = key
Budi   = value

age    = key
25     = value

salary = key
5000000 = value

Kalau kamu ingin mengambil Budi, kamu tidak mengatakan:

“Ambil data nomor 1.”

Tetapi:

“Ambil data dengan key name.”

Itulah konsep utama Map.

3. Setiap elemen Map harus punya key dan value

Ini tidak valid sebagai data Map:

25

Karena 25 hanya sebuah value.

Kita membutuhkan pasangan:

'age': 25

Sekarang:

'age' → key
25    → value

Atau:

'price': 25

berarti:

'price' → key
25      → value

4. Key harus unik

Ini salah satu aturan paling penting dari Map.

Misalnya:

Map<String, dynamic> person = {
  'name': 'Budi',
  'age': 25,
};

Key-nya:

name
age

Tidak boleh ada dua name yang berbeda sebagai dua entry terpisah.

Kalau kita melakukan:

person['name'] = 'Andi';

maka bukan membuat name kedua.

Yang terjadi adalah:

name → Budi

diganti menjadi:

name → Andi

Jadi:

Key yang sama akan menyebabkan value lama diganti dengan value baru.

5. Key dan value bisa memiliki berbagai tipe

Misalnya:

Map<String, dynamic> data = {
  'name': 'Budi',
  'age': 25,
  'height': 170.5,
  'isStudent': true,
};

Key semuanya String:

name
age
height
isStudent

Tetapi value-nya berbeda-beda:

String
int
double
bool

Karena kita menggunakan:

dynamic

6. Generic pada Map

Kita bisa menentukan tipe key dan value secara eksplisit.

Sintaks:

Map<KeyType, ValueType>

Contoh:

Map<String, int> scores = {
  'Budi': 90,
  'Andi': 85,
  'Citra': 95,
};

Artinya:

Key   harus String
Value harus int

Maka ini valid:

scores['Budi'] = 100;

Tetapi ini tidak valid:

scores[10] = 100;

Karena key harus String.

Dan:

scores['Budi'] = 'seratus';

juga tidak valid karena value harus int.

7. Kenapa Map<String, dynamic> sering digunakan?

Dalam aplikasi Flutter, kita sering mendapatkan data seperti:

{
  "name": "Budi",
  "age": 25,
  "city": "Madiun"
}

Data tersebut memiliki value dengan tipe berbeda.

name → String
age  → int
city → String

Karena itu:

Map<String, dynamic>

menjadi kombinasi yang sangat umum.

8. Cara membuat Map kosong

Cara paling sederhana:

Map<String, dynamic> person = {};

Artinya:

Buat sebuah Map dengan key String dan value dynamic, tetapi belum memiliki data.

Kita juga bisa menggunakan type inference:

var person = <String, dynamic>{};

9. Membuat Map dengan data langsung

Contoh:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
  'salary': 3000000,
  'position': 'Software Developer',
};

Perhatikan sintaksnya:

key : value

Bukan:

key = value

Jadi:

'name': 'Budi'

artinya:

key   = name
value = Budi

10. Mengapa Map<String, dynamic> cocok dengan contoh employee?

Karena:

'name': 'Budi'

value-nya String.

Sedangkan:

'age': 25

value-nya int.

Kemudian:

'salary': 3000000

value-nya juga int.

Kalau kita menggunakan:

Map<String, String>

maka:

'age': 25

akan error karena 25 bukan String.

11. Constructor Map()

Kita juga bisa membuat:

Map<String, int> numbers = Map();

Tetapi untuk membuat map kosong, bentuk literal:

{}

lebih umum dan lebih sederhana.

Misalnya:

Map<String, int> numbers = {};

12. Map.from()

Sekarang kita punya:

Map<String, dynamic> person1 = {
  'name': 'Alex',
  'age': 21,
  'status': 'single',
};

Kita ingin membuat Map baru berdasarkan Map tersebut.

Kita bisa menggunakan:

Map<String, dynamic> person2 =
    Map.from(person1);

Sekarang person2 berisi data dari person1.

13. Map.of()

Kita juga punya:

Map<String, dynamic> person3 =
    Map.of(person1);

Sekilas terlihat sama.

Tetapi ada perbedaan penting dalam type checking.

14. Perbedaan Map.from() dan Map.of()

Ini bagian yang agak teknis, tetapi penting.

Misalnya:

Map<String, dynamic> person1 = {
  'name': 'Alex',
  'age': 21,
};

Kemudian kita ingin membuat:

Map<String, String> person2 =
    Map.from(person1);

Map.from() dapat melakukan konversi runtime terhadap tipe yang diperlukan, sehingga ketidakcocokan tipe mungkin baru menjadi masalah ketika program dijalankan.

Sedangkan:

Map<String, String> person3 =
    Map.of(person1);

lebih ketat terhadap tipe map sumber.

Karena person1 adalah:

Map<String, dynamic>

bukan:

Map<String, String>

maka analyzer dapat menolak penggunaan tersebut.

Cara gampang mengingat:

Map.from()
→ membuat Map dari Map lain
→ melakukan pengecekan/konversi tipe saat runtime

Map.of()
→ mengharapkan tipe Map sumber yang sesuai
→ lebih ketat secara static typing

Jadi dalam kode yang menggunakan null safety dan generic modern Dart, perbedaan type safety ini penting.

15. Map.unmodifiable()

Ada juga:

Map.unmodifiable(person1);

Ini menghasilkan Map yang tidak bisa dimodifikasi melalui map tersebut.

Contoh:

final person = Map.unmodifiable({
  'name': 'Budi',
  'age': 25,
});

Kita tidak bisa:

person['age'] = 30; // ❌

dan:

person.remove('name'); // ❌

Tujuannya adalah membuat data menjadi read-only.

16. final vs unmodifiable

Ini juga penting.

Kalau kita menulis:

final person = {
  'name': 'Budi',
};

final berarti variabel person tidak boleh menunjuk ke object lain.

Tetapi isi Map masih bisa diubah:

person['name'] = 'Andi'; // ✅

Sedangkan:

final person = Map.unmodifiable({
  'name': 'Budi',
});

isinya juga tidak dapat dimodifikasi.

Jadi:

final
→ variable/reference tidak boleh diganti

unmodifiable
→ collection tidak bisa dimodifikasi

17. Membuat Map dari List

Ini menarik.

Misalnya kita mempunyai:

List<int> numbers = [
  10,
  20,
  30,
  40,
  50,
];

Kita bisa membuat Map menggunakan:

Map<int, int> map =
    Map.fromIterable(numbers);

Hasil konsepnya:

10 → 10
20 → 20
30 → 30
40 → 40
50 → 50

Kenapa?

Karena pada bentuk default fromIterable, setiap item digunakan sebagai key sekaligus value.

18. Kalau ada duplicate?

Misalnya:

List<int> numbers = [
  10,
  20,
  20,
  30,
];

Ketika dibuat menjadi Map, key harus unik.

Jadi:

10 → 10
20 → 20
30 → 30

20 tidak bisa menjadi dua key berbeda.

Ini kembali ke aturan:

Map tidak mempunyai duplicate key.

19. Cara mengakses value pada Map

Ini sangat penting.

Misalnya:

Map<String, dynamic> person = {
  'name': 'Budi',
  'age': 25,
  'gender': 'Male',
};

Untuk mendapatkan nama:

print(person['name']);

Hasil:

Budi

Untuk mendapatkan umur:

print(person['age']);

Hasil:

25

Jadi sintaksnya:

map[key]

20. Kenapa harus menggunakan key?

Karena Map tidak menggunakan index seperti List.

Pada List:

names[0]

artinya:

Ambil data pada index 0.

Pada Map:

person['name']

artinya:

Ambil value yang memiliki key name.

Jadi:

List → index
Map  → key

21. Menambahkan data ke Map

Misalnya awalnya:

Map<String, dynamic> person = {};

Kemudian:

person['name'] = 'Budi';

Sekarang:

name → Budi

Kemudian:

person['age'] = 25;

Sekarang:

name → Budi
age  → 25

22. Mengubah value

Misalnya:

person['age'] = 25;

Kemudian:

person['age'] = 30;

Hasilnya:

age → 30

Bukan:

age → 25
age → 30

Karena key age sudah ada.

Jadi assignment pada Map bisa berfungsi sebagai:

key belum ada
→ tambah entry

key sudah ada
→ update value

Ini konsep yang sangat penting.

23. Iterasi Map dengan forEach()

Misalnya:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
  'salary': 3000000,
  'position': 'Developer',
};

Kita bisa:

employee.forEach((key, value) {
  print('$key = $value');
});

Hasil:

name = Budi
age = 25
salary = 3000000
position = Developer

24. Bagaimana forEach() bekerja?

Misalnya ada:

'name': 'Budi'

maka callback menerima:

key   = name
value = Budi

Iterasi berikutnya:

key   = age
value = 25

Kemudian:

key   = salary
value = 3000000

dan seterusnya.

Jadi:

(key, value)

adalah pasangan yang sedang diproses.

25. Property pada Map

Ada beberapa property penting.

length

print(employee.length);

Kalau ada 4 entry:

4

isEmpty

print(employee.isEmpty);

Kalau tidak kosong:

false

isNotEmpty

print(employee.isNotEmpty);

Kalau memiliki data:

true

26. keys

keys digunakan untuk mendapatkan seluruh key.

print(employee.keys);

Misalnya:

(name, age, salary, position)

Tipe hasilnya adalah Iterable.

Kita bisa melakukan:

for (var key in employee.keys) {
  print(key);
}

Hasil:

name
age
salary
position

27. values

values digunakan untuk mendapatkan semua value.

for (var value in employee.values) {
  print(value);
}

Hasil:

Budi
25
3000000
Developer

Jadi:

keys
→ semua key

values
→ semua value

28. entries

Kalau keys hanya key dan values hanya value, maka:

entries

memberikan pasangan key + value.

Contoh:

for (var entry in employee.entries) {
  print('${entry.key} = ${entry.value}');
}

Hasil:

name = Budi
age = 25
salary = 3000000
position = Developer

entry mempunyai:

entry.key

dan:

entry.value

29. Hubungan keys, values, dan entries

Ini cara paling gampang mengingatnya:

Map
│
├── keys
│   └── name, age, salary, position
│
├── values
│   └── Budi, 25, 3000000, Developer
│
└── entries
    ├── name → Budi
    ├── age → 25
    ├── salary → 3000000
    └── position → Developer

30. Method putIfAbsent()

Sekarang masuk ke method.

putIfAbsent() berarti:

Tambahkan key-value hanya jika key tersebut belum ada.

Contoh:

Map<String, dynamic> person = {
  'name': 'Budi',
};

person.putIfAbsent('age', () => 25);

Hasil:

name → Budi
age  → 25

31. Kalau key sudah ada?

Misalnya:

Map<String, dynamic> person = {
  'age': 25,
};

person.putIfAbsent('age', () => 30);

Apa hasilnya?

Tetap:

age → 25

Karena age sudah ada.

Jadi 30 tidak digunakan.

Bandingkan dengan:

person['age'] = 30;

Ini akan menghasilkan:

age → 30

Jadi:

person['age'] = 30
→ selalu set/update

putIfAbsent()
→ hanya menambahkan jika belum ada

32. Kenapa putIfAbsent() menggunakan function?

Sintaks:

map.putIfAbsent(
  'age',
  () => 25,
);

Function:

() => 25

adalah cara untuk mengatakan:

“Kalau key ini belum ada, gunakan hasil function ini sebagai value.”

Ini berguna ketika value membutuhkan proses tertentu.

33. addAll()

Kalau ingin memasukkan semua data dari Map lain:

Map<String, dynamic> person = {
  'name': 'Budi',
  'age': 25,
};

Map<String, dynamic> employee = {
  'salary': 3000000,
};

employee.addAll(person);

Sekarang:

employee
-----------------
salary → 3000000
name   → Budi
age    → 25

Jadi:

employee.addAll(person);

artinya:

Masukkan semua entry dari person ke employee.

34. Bagaimana kalau key-nya sama?

Ini penting.

Misalnya:

Map<String, int> first = {
  'age': 20,
};

Map<String, int> second = {
  'age': 30,
};

first.addAll(second);

Hasil:

age → 30

Karena age dari second menggantikan value yang sebelumnya ada di first.

35. remove()

Untuk menghapus entry tertentu:

employee.remove('age');

Yang dihapus adalah entry dengan key:

age

Jadi bukan berdasarkan value.

36. clear()

Untuk menghapus semuanya:

employee.clear();

Hasil:

{}

Perbedaannya:

remove(key)
→ hapus satu entry berdasarkan key

clear()
→ hapus semua entry

37. removeWhere()

Ini sangat berguna.

removeWhere() digunakan untuk menghapus entry berdasarkan kondisi.

Misalnya:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
  'salary': 3000000,
  'position': 'Developer',
};

Kita ingin menghapus semua value yang bertipe String.

employee.removeWhere(
  (key, value) => value is String,
);

Yang hilang:

name
position

Yang tersisa:

age
salary

38. Kenapa removeWhere() menerima key dan value?

Karena callback:

(key, value)

akan dijalankan untuk setiap entry.

Misalnya:

name → Budi

maka:

key = name
value = Budi

Kemudian:

age → 25

maka:

key = age
value = 25

Kita bisa membuat kondisi berdasarkan key atau value.

39. Contoh menghapus berdasarkan key

Misalnya kita ingin menghapus:

name
salary

Kita bisa:

employee.removeWhere(
  (key, value) =>
      key == 'name' || key == 'salary',
);

Hasilnya hanya:

age
position

40. containsKey()

Digunakan untuk mengecek apakah sebuah key ada.

print(employee.containsKey('salary'));

Kalau salary ada:

true

Kalau tidak ada:

false

41. containsValue()

Digunakan untuk mengecek apakah sebuah value ada.

print(employee.containsValue('Budi'));

Tidak peduli Budi berada pada key apa.

Yang dicek adalah:

Apakah ada value 'Budi' di dalam Map?

42. containsKey() vs containsValue()

Ingat ini:

containsKey()
→ cari berdasarkan key

containsValue()
→ cari berdasarkan value

Contoh:

employee.containsKey('name');

Artinya:

Apakah ada key name?

Sedangkan:

employee.containsValue('Budi');

Artinya:

Apakah ada value Budi?

43. Keduanya case-sensitive

Misalnya:

Map<String, String> person = {
  'name': 'Sam',
};

Maka:

person.containsValue('Sam');

hasilnya:

true

Tetapi:

person.containsValue('sam');

hasilnya:

false

Karena:

Sam

berbeda dengan:

sam

44. Method map()

Nah, ini perlu diperhatikan karena sebelumnya kita juga pernah belajar map() pada List dan Set.

Pada Map, map() digunakan untuk membuat Map baru dengan melakukan transformasi terhadap setiap entry.

Misalnya:

Map<String, String> employee = {
  'name': 'sam',
  'position': 'software developer',
  'location': 'london',
};

Kita ingin membuat semua value menjadi uppercase.

Map<String, String> result = employee.map(
  (key, value) {
    return MapEntry(
      key,
      value.toUpperCase(),
    );
  },
);

Hasil:

name     → SAM
position → SOFTWARE DEVELOPER
location → LONDON

45. Kenapa menggunakan MapEntry?

Karena hasil dari Map.map() harus berupa:

key + value

atau sebuah:

MapEntry

Contoh:

MapEntry(
  key,
  value.toUpperCase(),
)

Artinya:

key tetap sama
value diubah menjadi uppercase

46. Contoh lebih sederhana

Misalnya:

Map<String, int> scores = {
  'Budi': 80,
  'Andi': 90,
};

Kita ingin menambahkan 10 ke setiap nilai:

Map<String, int> newScores = scores.map(
  (key, value) {
    return MapEntry(key, value + 10);
  },
);

Hasil:

Budi → 90
Andi → 100

Perhatikan bahwa scores awal tidak kita ubah.

Kita membuat Map baru:

scores
   ↓
map()
   ↓
newScores

47. map() berbeda dengan updateAll()

Ini sangat penting.

map()

Membuat Map baru.

final newMap = oldMap.map(...);

Map lama tetap ada.

updateAll()

Mengubah Map yang sedang digunakan.

oldMap.updateAll(...);

Jadi:

map()
→ transformasi → Map baru

updateAll()
→ update Map yang sama

48. Method update()

Digunakan untuk mengubah value dari satu key tertentu.

Misalnya:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
};

Kita ingin menaikkan age:

employee.update(
  'age',
  (value) => value + 1,
);

Hasil:

age → 26

49. Bagaimana update() bekerja?

Sintaks:

map.update(
  key,
  (oldValue) {
    return newValue;
  },
);

Misalnya:

employee.update(
  'age',
  (oldValue) => oldValue + 1,
);

Dart mengambil value lama:

25

Kemudian function menerima:

oldValue = 25

Lalu:

oldValue + 1

menjadi:

26

Maka Map berubah:

age → 26

50. Contoh update String

employee.update(
  'name',
  (oldValue) => oldValue.toUpperCase(),
);

Jika sebelumnya:

name → budi

menjadi:

name → BUDI

51. Bagaimana kalau key belum ada?

Secara default, update() membutuhkan key yang sudah ada. Jika key tidak ditemukan, akan terjadi error.

Kalau ingin memberikan value default ketika key belum ada, update() memiliki parameter ifAbsent.

Contoh:

employee.update(
  'age',
  (value) => value + 1,
  ifAbsent: () => 1,
);

Jadi:

• kalau age sudah ada → update
• kalau age belum ada → gunakan 1

Ini sangat berguna.

52. updateAll()

Kalau:

update()

digunakan untuk satu key,

maka:

updateAll()

digunakan untuk semua entry.

Misalnya:

Map<String, int> scores = {
  'Budi': 80,
  'Andi': 90,
  'Citra': 70,
};

Kita ingin menambah 10 ke semua score:

scores.updateAll(
  (key, value) => value + 10,
);

Hasil:

Budi  → 90
Andi  → 100
Citra → 80

53. update() vs updateAll()

Cara mengingat:

update()
→ satu key

updateAll()
→ semua key

Contoh:

employee.update(
  'age',
  (value) => value + 1,
);

hanya age.

Sedangkan:

employee.updateAll(
  (key, value) {
    ...
  },
);

akan memproses semuanya.

54. Contoh updateAll() berdasarkan key

Misalnya:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
  'salary': 3000000,
  'position': 'Developer',
};

Kita ingin:

• age + 1
• salary + 1000
• position menjadi Manager
• name tidak berubah

Bisa:

employee.updateAll((key, value) {
  if (key == 'age') {
    return value + 1;
  }

  if (key == 'salary') {
    return value + 1000;
  }

  if (key == 'position') {
    return 'Manager';
  }

  return value;
});

Hasil:

name     → Budi
age      → 26
salary   → 3001000
position → Manager

55. Map sangat penting di Flutter

Ini bagian yang menurut saya wajib kamu pahami dengan baik.

Kenapa?

Karena di aplikasi Flutter kamu akan sering bertemu data seperti:

{
  "id": 1,
  "name": "Budi",
  "age": 25
}

Ketika data JSON dibaca Dart, bentuk sederhananya sering direpresentasikan sebagai:

Map<String, dynamic>

Misalnya:

final data = {
  'id': 1,
  'name': 'Budi',
  'age': 25,
};

Kemudian:

print(data['name']);

menghasilkan:

Budi

56. Hubungan JSON dengan Map

Misalnya server mengirim:

{
  "name": "Budi",
  "age": 25
}

Secara konsep Dart bisa membacanya sebagai:

{
  'name': 'Budi',
  'age': 25,
}

Yaitu:

Map<String, dynamic>

Makanya ketika belajar Flutter dan API, kamu akan sering melihat:

Map<String, dynamic>

57. Hubungan Map dengan Firebase

Data dokumen Firestore juga sering kamu akses menggunakan pola key-value.

Misalnya secara konsep:

name → Budi
age → 25
city → Madiun

Itu sangat dekat dengan konsep Map.

Jadi kalau kamu sudah kuat memahami:

Map<String, dynamic>

nanti materi API/Firebase akan terasa jauh lebih mudah.

58. Tiga jenis Map yang disebut video

Transcript juga menyebut:

HashMap

Berbasis hash table.

LinkedHashMap

Berbasis hash table dan mempertahankan urutan insertion.

SplayTreeMap

Berbasis tree dan mengurutkan berdasarkan comparator/key ordering.

Secara sederhana:

HashMap
→ fokus pada key/value
→ tidak menjanjikan insertion order

LinkedHashMap
→ mempertahankan insertion order

SplayTreeMap
→ mempertahankan sorted order berdasarkan comparator

59. Map literal biasanya menjadi LinkedHashMap

Ketika kamu menulis:

Map<String, dynamic> employee = {
  'name': 'Budi',
  'age': 25,
};

implementasi default map literal di Dart umumnya adalah:

LinkedHashMap

Artinya urutan iterasinya mengikuti urutan insertion.

Misalnya:

final data = {
  'name': 'Budi',
  'age': 25,
  'salary': 3000000,
};

Ketika diiterasi, biasanya urutannya:

name
age
salary

sesuai urutan ketika dimasukkan.

60. SplayTreeMap

Kalau kamu membutuhkan Map yang terurut berdasarkan key, ada:

SplayTreeMap

Contoh:

import 'dart:collection';

final scores = SplayTreeMap<String, int>();

scores['Zaki'] = 90;
scores['Andi'] = 80;
scores['Budi'] = 85;

print(scores);

Secara konsep akan menghasilkan key dalam urutan:

Andi
Budi
Zaki

Jadi sama seperti SplayTreeSet, SplayTreeMap digunakan ketika ordering menjadi bagian dari kebutuhan collection.

61. Perbedaan besar List, Set, dan Map

Sekarang gabungkan materi sebelumnya.

Cara membayangkannya:

List
→ "data nomor berapa?"

Set
→ "apakah data ini sudah ada?"

Map
→ "data dengan key apa?"

62. Contoh kehidupan nyata

Misalnya kita ingin menyimpan daftar nama siswa.

Kalau menggunakan List

List<String> students = [
  'Budi',
  'Andi',
  'Budi',
];

Duplicate boleh.

Kalau menggunakan Set

Set<String> students = {
  'Budi',
  'Andi',
  'Budi',
};

Hasilnya:

Budi
Andi

Duplicate dihilangkan.

Kalau menggunakan Map

Kalau kita ingin menyimpan informasi siswa:

Map<String, dynamic> student = {
  'name': 'Budi',
  'age': 20,
  'major': 'Computer Science',
};

Sekarang kita bisa mengambil:

student['name'];
student['age'];
student['major'];

63. Cheat sheet method yang dipelajari

Ini bagian yang bagus untuk kamu jadikan catatan.

Menambahkan / mengubah

map[key] = value;

Tambahkan jika key belum ada

map.putIfAbsent(key, () => value);

Menambahkan banyak entry

map.addAll(otherMap);

Menghapus satu

map.remove(key);

Menghapus semua

map.clear();

Menghapus berdasarkan kondisi

map.removeWhere((key, value) => condition);

Cek key

map.containsKey(key);

Cek value

map.containsValue(value);

Transformasi menjadi Map baru

map.map((key, value) {
  return MapEntry(key, newValue);
});

Update satu key

map.update(
  key,
  (oldValue) => newValue,
);

Update semua

map.updateAll(
  (key, value) => newValue,
);

64. Cheat sheet property

map.length

→ jumlah entry.

map.isEmpty

→ apakah kosong?

map.isNotEmpty

→ apakah memiliki data?

map.keys

→ semua key.

map.values

→ semua value.

map.entries

→ semua pasangan key-value.

65. Satu contoh lengkap

Coba perhatikan contoh ini karena hampir semua konsep penting digabungkan:

void main() {
  Map<String, dynamic> employee = {
    'name': 'Budi',
    'age': 25,
    'salary': 3000000,
    'position': 'Developer',
  };

  // Mengakses
  print(employee['name']);

  // Menambah
  employee['city'] = 'Madiun';

  // Mengubah
  employee['age'] = 26;

  // putIfAbsent
  employee.putIfAbsent('gender', () => 'Male');

  // Cek key
  print(employee.containsKey('salary'));

  // Cek value
  print(employee.containsValue('Budi'));

  // Iterasi
  employee.forEach((key, value) {
    print('$key = $value');
  });

  // Update
  employee.update(
    'salary',
    (value) => value + 1000,
  );

  // Hapus
  employee.remove('city');

  print(employee);
}

Kalau kamu memahami contoh ini, berarti kamu sudah memahami sebagian besar konsep dasar Map.

🧠 Kesimpulan besar

Kalau semua materi video ini diringkas menjadi satu konsep:

Map adalah collection yang menyimpan data dalam pasangan key → value.

Contoh:

Map<String, dynamic> person = {
  'name': 'Budi',
  'age': 25,
};

Kemudian:

          Map
           │
    ┌──────┴──────┐
    │             │
   key          value
    │             │
  name           Budi
  age             25

Dan aturan yang paling penting adalah:

1. Setiap entry mempunyai key dan value.
2. Key harus unik.
3. Value boleh bermacam-macam tipe tergantung generic yang digunakan.
4. Akses Map menggunakan key, bukan index.
5. Key yang sudah ada ketika di-assignment akan mengubah value lama.
6. keys → semua key.
7. values → semua value.
8. entries → pasangan key-value.
9. putIfAbsent() → tambah hanya jika key belum ada.
10. addAll() → gabungkan Map lain.
11. remove() → hapus berdasarkan key.
12. removeWhere() → hapus berdasarkan kondisi.
13. clear() → hapus semuanya.
14. containsKey() → cek key.
15. containsValue() → cek value.
16. map() → buat Map baru hasil transformasi.
17. update() → ubah satu key.
18. updateAll() → ubah semua entry.

Dan untuk Flutter, ada satu hal yang benar-benar perlu kamu tanamkan:

Map<String, dynamic>

akan sering sekali kamu temui ketika berurusan dengan JSON/API, Firebase, database, dan data dari server.

Kalau List kamu bayangkan sebagai daftar bernomor, dan Set sebagai kumpulan data unik, maka Map paling mudah dibayangkan sebagai kamus:

kata       → arti
----------------------
name       → Budi
age        → 25
position   → Developer

Key adalah “nama/label” yang kamu gunakan untuk menemukan value.