Transcript ini membahas cara membuat Set di Dart tetap dalam urutan terurut (sorted). Ada beberapa bagian transcript yang salah karena kemungkinan hasil speech-to-text, misalnya:

• “state” → maksudnya Set
• “split reset / splayed reset / displayed reset” → maksudnya SplayTreeSet
• “least” → maksudnya List
• “compared to” → maksudnya compareTo()

Yang paling penting dari video ini adalah memahami 3 teknik untuk mengurutkan data Set.

1. Masalahnya: Set tidak punya method sort()

Kalau kita punya List, kita bisa langsung melakukan:

List<String> names = [
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
];

names.sort();

print(names);

Hasil:

[Alex, James, John, Mark, Sam]

Karena List memang memiliki method:

sort()

Sedangkan kalau kita punya:

Set<String> names = {
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
};

Kita tidak bisa melakukan:

names.sort(); // ❌ tidak ada

Jadi muncul pertanyaan:

Bagaimana kalau saya ingin memiliki data yang unik seperti Set, tetapi juga selalu dalam keadaan terurut?

Video memberikan 3 pendekatan.

2. Teknik pertama: Set → List → sort()

Ini adalah cara yang paling sederhana.

Misalnya kita punya:

Set<String> names = {
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
};

Kita ubah Set menjadi List menggunakan:

names.toList()

Jadi:

List<String> nameList = names.toList();

Sekarang nameList adalah List.

Kita bisa menggunakan:

nameList.sort();

Sehingga:

Set<String> names = {
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
};

List<String> nameList = names.toList();

nameList.sort();

print(nameList);

Hasil:

[Alex, James, John, Mark, Sam]

Kenapa cara ini berhasil?

Karena kita melakukan:

Set
 ↓
toList()
 ↓
List
 ↓
sort()
 ↓
List yang sudah terurut

Jadi sebenarnya kita tidak mengurutkan Set secara langsung.

Kita mengubahnya menjadi List, kemudian List tersebut yang diurutkan.

3. Kekurangan teknik pertama

Ini bagian yang sangat penting.

Misalnya kebutuhan program kita adalah:

“Saya membutuhkan collection yang elemennya unik DAN selalu terurut.”

Dengan teknik pertama, hasil akhirnya adalah:

List<String>

Padahal mungkin kita sebenarnya ingin:

Set<String>

Misalnya:

Set<String> names = {
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
};

Kemudian:

List<String> sortedNames = names.toList();

sortedNames.sort();

Sekarang:

sortedNames → List

Bukan lagi Set.

Kalau kita benar-benar membutuhkan Set, kita bisa saja melakukan:

Set<String> sortedNames = sortedList.toSet();

Tetapi ini bukan Set yang memiliki aturan sorting seperti SplayTreeSet. Kamu hanya membuat Set dari hasil List yang kebetulan sudah terurut.

Jadi kalau kebutuhanmu adalah:

“Saya ingin collection yang dari awal memang berupa Set dan selalu menjaga urutan sorted.”

Maka teknik pertama bukan pilihan terbaik.

4. Teknik kedua: menggunakan SplayTreeSet

Nah, ini bagian paling penting dari video.

Dart mempunyai class:

SplayTreeSet

SplayTreeSet adalah salah satu implementasi dari Set.

Secara sederhana:

Set
├── HashSet
├── LinkedHashSet
└── SplayTreeSet

Jadi SplayTreeSet tetap merupakan Set.

Artinya sifat uniknya tetap ada.

Misalnya kita memasukkan:

Alex
Alex
Alex

Tidak akan menjadi tiga elemen berbeda.

5. Keistimewaan SplayTreeSet

Keistimewaan SplayTreeSet adalah elemen-elemennya dipertahankan dalam urutan berdasarkan comparator.

Misalnya:

import 'dart:collection';

SplayTreeSet<String> names = SplayTreeSet.from({
  'Mark',
  'Alex',
  'John',
  'Sam',
  'James',
});

print(names);

Hasilnya:

{Alex, James, John, Mark, Sam}

Perhatikan bahwa kita memasukkan:

Mark
Alex
John
Sam
James

Tetapi hasilnya:

Alex
James
John
Mark
Sam

Karena SplayTreeSet mengurutkan berdasarkan aturan pembandingnya.

6. Kenapa namanya SplayTreeSet?

Tidak perlu terlalu pusing dengan kata Splay Tree dulu.

Untuk tahap belajar Dart, cukup pahami:

SplayTreeSet adalah implementasi Set yang menyimpan elemen berdasarkan urutan sorting/comparator.

Jadi kamu bisa mengingat:

Set biasa
→ fokus pada uniqueness

SplayTreeSet
→ uniqueness + ordering berdasarkan comparator

7. SplayTreeSet tetap menghilangkan duplicate

Contoh:

import 'dart:collection';

SplayTreeSet<String> names = SplayTreeSet.from([
  'Mark',
  'Alex',
  'Alex',
  'John',
  'Mark',
  'James',
]);

print(names);

Hasil:

{Alex, James, John, Mark}

Alex hanya muncul sekali.

Mark juga hanya muncul sekali.

Jadi:

SplayTreeSet
= Set
+ sorting

8. Keuntungan besar SplayTreeSet

Sekarang bayangkan kita sudah memiliki:

SplayTreeSet<String> names = SplayTreeSet.from({
  'Mark',
  'Alex',
  'John',
});

Kemudian kita tambahkan:

names.add('Danish');

Kita tidak perlu melakukan:

names.sort();

Setiap kali selesai add().

Karena SplayTreeSet akan mempertahankan urutan berdasarkan comparator-nya.

Contoh:

import 'dart:collection';

SplayTreeSet<String> names = SplayTreeSet.from({
  'Mark',
  'Alex',
  'John',
});

names.add('Danish');

print(names);

Hasil:

{Alex, Danish, John, Mark}

Danish otomatis berada di posisi yang sesuai dengan urutan.

9. Ini perbedaan penting dengan List

Dengan List:

List<String> names = [
  'Mark',
  'Alex',
  'John',
];

names.add('Danish');

print(names);

Hasil:

[Mark, Alex, John, Danish]

Kalau ingin terurut:

names.sort();

Baru:

[Alex, Danish, John, Mark]

Sedangkan dengan SplayTreeSet:

names.add('Danish');

collection akan tetap mengikuti aturan ordering-nya.

10. Sorting default adalah ascending

Secara default, contoh string tadi akan menghasilkan urutan:

Alex
Danish
James
John
Mark
Sam

Ini disebut:

ascending order

Untuk angka:

1
2
3
4
5

Untuk huruf:

A
B
C
D

11. Bagaimana cara descending?

Nah, kita bisa memberikan comparator kepada SplayTreeSet.

Contohnya:

import 'dart:collection';

SplayTreeSet<String> names = SplayTreeSet.from(
  {
    'Mark',
    'Alex',
    'John',
    'Sam',
    'James',
  },
  (String left, String right) {
    return right.compareTo(left);
  },
);

print(names);

Hasil:

{Sam, Mark, John, James, Alex}

Sekarang urutannya descending.

12. Apa itu compareTo()?

Ini juga perlu dipahami.

Misalnya:

'Alex'.compareTo('Mark')

Dart akan membandingkan:

Alex
vs
Mark

Hasilnya berupa angka:

• nilai negatif → Alex dianggap lebih kecil dari Mark
• 0 → keduanya dianggap sama
• nilai positif → Alex dianggap lebih besar dari Mark

Jadi comparator bisa menggunakan hasil compareTo() untuk menentukan urutan.

13. Ascending dengan compareTo()

Misalnya:

(String left, String right) {
  return left.compareTo(right);
}

Artinya:

“Urutkan berdasarkan left terhadap right.”

Hasil:

Alex
James
John
Mark
Sam

14. Descending dengan membalik comparator

Untuk descending:

(String left, String right) {
  return right.compareTo(left);
}

Kita membalik:

left.compareTo(right)

menjadi:

right.compareTo(left)

Sehingga hasilnya:

Sam
Mark
John
James
Alex

15. Transcript menyebut “bubble sort”

Ada sedikit hal yang perlu dikoreksi dari transcript.

Ketika video mengatakan:

“this is a kind of bubble sort technique”

sebaiknya jangan dipahami bahwa comparator tersebut adalah Bubble Sort.

Comparator:

(left, right) {
  return left.compareTo(right);
}

bukan implementasi Bubble Sort.

Comparator hanya memberitahu SplayTreeSet:

“Kalau dua elemen dibandingkan, mana yang dianggap lebih kecil, sama, atau lebih besar?”

Jadi bedakan:

Comparator

Menentukan aturan perbandingan.

left.compareTo(right)

Sorting algorithm

Algoritma internal yang digunakan collection untuk mengatur data.

Keduanya bukan hal yang sama.

16. Teknik ketiga: langsung menggunakan SplayTreeSet

Teknik ketiga sebenarnya sangat mirip dengan teknik kedua.

Bedanya adalah:

Teknik kedua

Kita sudah memiliki Set:

Set<String> names = {...};

Kemudian membuat SplayTreeSet dari Set tersebut:

SplayTreeSet<String> sortedNames =
    SplayTreeSet.from(names);

Alurnya:

Set
 ↓
SplayTreeSet.from()
 ↓
SplayTreeSet

Teknik ketiga

Kita langsung membuat SplayTreeSet dari awal.

Contoh:

import 'dart:collection';

SplayTreeSet<String> names = SplayTreeSet<String>();

names.add('Sam');
names.add('Mark');
names.add('Danish');
names.add('Alex');

print(names);

Hasil:

{Alex, Danish, Mark, Sam}

Kita tidak pernah membuat Set biasa terlebih dahulu.

17. Kapan teknik ketiga cocok?

Teknik ketiga cocok kalau dari awal kita memang tahu:

“Saya membutuhkan collection yang unik dan selalu mengikuti urutan tertentu.”

Misalnya aplikasi kita memiliki daftar username yang harus:

• tidak boleh duplicate
• selalu terurut

Kita bisa langsung menggunakan:

SplayTreeSet<String> usernames = SplayTreeSet();

Kemudian:

usernames.add('Budi');
usernames.add('Andi');
usernames.add('Citra');

Hasilnya akan mengikuti ordering comparator:

Andi
Budi
Citra

18. Contoh lengkap teknik ketiga

import 'dart:collection';

void main() {
  SplayTreeSet<String> names = SplayTreeSet<String>();

  names.add('Sam');
  names.add('Mark');
  names.add('Danish');
  names.add('Alex');

  print(names);

  names.remove('Mark');

  print(names);

  names.add('James');

  print(names);
}

Hasil kurang lebih:

{Alex, Danish, Mark, Sam}

{Alex, Danish, Sam}

{Alex, Danish, James, Sam}

Perhatikan:

Setiap kali kita:

add()

atau:

remove()

urutan tetap mengikuti aturan sorting.

19. Perbandingan ketiga teknik

Sekarang kita sederhanakan.

20. Analogi sederhana

Bayangkan kamu memiliki kumpulan nama.

List

Seperti daftar:

1. Mark
2. Alex
3. John
4. Alex

Boleh duplicate dan punya posisi/index.

Set

Seperti kotak yang mengatakan:

“Saya hanya mau satu dari setiap nama.”

Mark
Alex
John

Tidak boleh duplicate.

SplayTreeSet

Seperti kotak yang mengatakan:

“Saya hanya mau data yang unik, dan saya juga akan menjaga data berdasarkan urutan yang ditentukan.”

Misalnya:

Alex
John
Mark
Sam

Ketika kamu memasukkan:

Danish

hasilnya menjadi:

Alex
Danish
John
Mark
Sam

Kamu tidak perlu memanggil sort() pada collection tersebut.

21. Hal yang sangat penting: SplayTreeSet membutuhkan dart:collection

Untuk menggunakan SplayTreeSet, biasanya kita perlu:

import 'dart:collection';

Contoh:

import 'dart:collection';

void main() {
  SplayTreeSet<String> names = SplayTreeSet();

  names.add('Mark');
  names.add('Alex');
  names.add('John');

  print(names);
}

22. Bagaimana kalau datanya angka?

Lebih mudah lagi.

import 'dart:collection';

void main() {
  SplayTreeSet<int> numbers = SplayTreeSet();

  numbers.add(50);
  numbers.add(10);
  numbers.add(30);
  numbers.add(20);

  print(numbers);
}

Hasil:

{10, 20, 30, 50}

Kalau ingin descending:

import 'dart:collection';

void main() {
  SplayTreeSet<int> numbers = SplayTreeSet(
    (a, b) => b.compareTo(a),
  );

  numbers.add(50);
  numbers.add(10);
  numbers.add(30);
  numbers.add(20);

  print(numbers);
}

Hasil:

{50, 30, 20, 10}

23. Kenapa comparator sangat berguna?

Karena kita tidak terbatas pada:

ascending
descending

Kita bisa membuat aturan sorting sendiri.

Misalnya kita punya object:

class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

Kita bisa saja ingin:

umur paling kecil → paling besar

atau:

umur paling besar → paling kecil

atau:

nama A → Z

atau aturan lainnya.

Itulah alasan konsep comparator penting untuk dipahami.

24. Ringkasan paling mudah

Kalau kamu lupa semuanya, ingat tiga pola ini:

Cara 1 — ubah menjadi List

Set<String> names = {...};

List<String> list = names.toList();

list.sort();

Kelebihan: simpel.

Kekurangan: hasil akhirnya List, bukan sorted Set.

Cara 2 — Set yang sudah ada → SplayTreeSet

Set<String> names = {...};

SplayTreeSet<String> sortedNames =
    SplayTreeSet.from(names);

Hasilnya tetap berupa SplayTreeSet.

Cara 3 — langsung gunakan SplayTreeSet

SplayTreeSet<String> names = SplayTreeSet();

names.add('Sam');
names.add('Alex');
names.add('Mark');

Cocok kalau sejak awal memang membutuhkan Set + ordering.

25. Satu catatan penting tentang SplayTreeSet

Jangan menyimpulkan bahwa:

“Set tidak bisa terurut sama sekali.”

Yang lebih tepat:

Set sebagai interface tidak menyediakan method sort() seperti List. Tetapi Dart memiliki implementasi Set bernama SplayTreeSet yang menjaga elemen berdasarkan urutan comparator.

Jadi:

List
→ punya sort()

Set
→ tidak punya sort() seperti List

SplayTreeSet
→ merupakan Set
→ unik
→ memiliki ordering berdasarkan comparator

Ini adalah inti dari seluruh video.

🧠 Cara mengingat video ini

Bayangkan ada tiga jalan:

                 DATA SET
                    │
          ┌─────────┴─────────┐
          │                   │
       Butuh List?       Harus tetap Set?
          │                   │
          ▼                   ▼
       toList()          SplayTreeSet
          │              ┌────┴─────┐
          ▼              │          │
       sort()          from()    langsung
          │              │          │
          ▼              ▼          ▼
    Sorted List     Sorted Set   Sorted Set

Jadi kalau soal interview atau latihan bertanya:

“Bagaimana cara sorting Set di Dart?”

Jawabannya bisa:

1. Convert Set ke List, lalu gunakan sort().
2. Gunakan SplayTreeSet jika ingin tetap bekerja sebagai sorted set.
3. Jika sejak awal membutuhkan sorted set, langsung gunakan SplayTreeSet.

Dan kalau kamu ingin custom sorting, bagian paling penting yang harus kamu kuasai adalah:

(left, right) {
  return left.compareTo(right);
}

atau untuk membalik urutan:

(left, right) {
  return right.compareTo(left);
}

Itulah fondasi untuk masuk ke materi berikutnya: sorting object/class berdasarkan property tertentu, misalnya mengurutkan Person berdasarkan age, name, atau salary.