SKRIPSI

IMPLEMENTASI ALGORITMA K-MEANS DALAM DATA

MINING UNTUK PEMINATAN JURUSAN BAGI SISWA KELAS
X SMA NEGERI 29 JAKARTA

Sebagai Salah Satu Syarat Untuk Membuat Tugas Akhir

Oleh :

LUIGI AJENG PRATIWI

NIM. 109091000053

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI
UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH
JAKARTA
2013 M / 1434 H
Implementasi Algoritma K-Means dalam Data Mining untuk Peminatan

Jurusan Bagi Siswa Kelas X SMA Negeri 29 Jakarta

Skripsi

Sebagai Salah Satu Syarat untuk Memperoleh Gelar Sarjana Komputer

Fakultas Sains dan Teknologi

Universitas Islam Negeri Syarif Hidayatullah Jakarta

Oleh :

Luigi Ajeng Pratiwi

109091000053

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH JAKARTA

2013 M / 1434 H

ii
iii
iv
 PERNYATAAN

DENGAN INI SAYA MENYATAKAN BAHWA SKRIPSI INI BENAR-BENAR

HASIL KARYA SENDIRI YANG BELUM PERNAH DIAJUKAN SEBAGAI

SKRIPSI ATAU KARYA ILMIAH PADA PERGURUAN TINGGI ATAU

LEMBAGA MANAPUN

Jakarta, November 2013

Luigi Ajeng Pratiwi

109091000053

v
 ABSTRAKSI

Luigi Ajeng Pratiwi, Implementasi Algoritma K-Means dalam Data Mining untuk
Peminatan Jurusan Bagi Siswa Kelas X SMA Negeri 29 Jakarta, dibimbing oleh
Nurhayati, Ph.D dan Khodijah Hulliyah, M.Si

Saat ini SMA Negeri 29 Jakarta memiliki kesulitan dalam mengolah hasil prestasi
akademik siswa untuk proses peminatan bagi siswa kelas X SMA. Proses peminatan
siswa yang berjalan saat ini masih menggunakan sistem manual dengan menghitung
nilai mata pelajaran dari masing-masing siswa kemudian mengelompokkan hasil
penghitungan dari nilai masing-masing siswa ke dalam kelompok minat IPA atau IPS
sesuai dengan syarat yang diterapkan oleh SMA Negeri 29 Jakarta. Untuk itu
diperlukan solusi yang dapat mengatasi kesulitan tersebut. Penulis mengembangkan
aplikasi dengan metode Rapid Application Development (RAD) yang terdiri dari fase
perencaan syarat-syarat, fase perancangan, fase konstruksi dan fase pelaksanaan.
Pada tahap kostruksi diimplementasikan algoritma K-Means dalam teknologi data
mining untuk mengklaster hasil prestasi akademik siswa ke dalam kelompok minat
IPA dan IPS. Hasil pembuatan aplikasi ini diperuntukkan bagi pihak sekolah
khususnya wali kelas, sehingga bisa menjadi solusi alternatif atau saran dalam
memberikan keputusan bagi peminatan siswa SMA Negeri 29 Jakarta.

Kata Kunci : Peminatan Siswa, Data Mining, Klaster, Algoritma K-Means,

RAD.
Jumlah Pustaka : 36 (Tahun 2004 – Tahun 2013)
Jumlah Halaman : V Bab + 224 Halaman + 66 Gambar + 22 Tabel + Lampiran

vi
 KATA PENGANTAR

Assalamualaikum Wr. Wb

Puji dan syukur penulis panjatkan kepada Allah SWT yang telah
melimpahkan rahmat serta karunia-Nya sehingga penulis dapat menyelesaikan skripsi
ini dengan baik. Shalawat serta salam tak lupa penulis sanjungkan kepada Nabi
Muhammad SAW.
Skripsi ini berjudul “Implementasi Algoritma K-Means dalam Data
Mining untuk Peminatan Jurusan Bagi Siswa Kelas X SMA Negeri 29 Jakarta”.
Penyusunan skripsi ini bertujuan untuk memenuhi salah satu syarat dalam
menyelesaikan pendidikan S1 Program Studi Teknik Informatika di Universitas Islam
Negeri Syarif Hidayatullah Jakarta.
Pada kesempatan ini penulis mengucapkan terima kasih yang sebesar-
besarnya kepada pihak-pihak yang telah membantu dalam menyelesaikan skripsi ini,
yaitu :
1. Bapak Dr. Agus Salim, M.Si, selaku Dekan Fakultas Sains dan Teknologi
Universitas Islam Negeri Syarif Hidayatullah Jakarta
2. Ibu Nurhayati Ph.D, selaku Ketua Program Studi Teknik Informatika
3. Bapak Hendra Bayu Suseno, M.Kom selaku Sekretaris Program Studi Teknik
Informatika
4. Ibu Nurhayati Ph.D sebagai dosen pembimbing I dan Ibu Khodijah Hulliyah,
M.Si sebagai dosen pembimbing II yang senantiasa meluangkan waktunya
untuk membimbing dan memberikan arahan dalam proses pembuatan skripsi
ini.
5. Ibu Siti Ummi Masruroh, M.Sc sebagai pembimbing akademik yang telah
membimbing penulis selama menjadi mahasiswa Teknik Informatika.

vii
 6. Kedua orang tua penulis, Ibunda Titu Irawati dan Ayahanda Suhartono, yang
selalu memberikan do‟a terbaik, kasih sayang, materi, dukungan terhebat serta
semangat untuk menjadikan penulis sebagai manusia yang lebih baik. Umi Ida
Suhaida (Nenek), adik-adik serta keluarga besar penulis yang tidak bisa
penulis sebutkan satu persatu.
7. Seluruh guru dan staff SMAN 29 Jakarta atas bantuannya kepada penulis
8. Dosen-dosen Fakultas Sains dan Teknologi yang telah mengajarkan kepada
penulis berbagai ilmu yang dapat penulis terapkan dalam penelitian skripsi ini
dan dalam kehidupan penulis.
9. Teman-teman Teknik Informatika 2009, khususnya TI-B 2009 dan kelas SE.C
2009 yang selama ini bersama untuk selalu berbagi pengalaman, pengetahuan
dan saling memberikan dukungan.
10. Para sahabat yang tidak dapat disebutkan namanya satu persatu. Terima kasih
atas bantuan, dukungan, do‟a dan motivasinya selama ini.
11. Seluruh pihak yang telah membantu dan namanya tidak dapat disebutkan satu
persatu. Terima kasih atas dukungan dan motivasinya. Semoga Allah SWT
membalas segala kebaikan yang telah diberikan kepada penulis.

Penulis juga mengucapkan permohonan maaf kepada semua pihak yang

terkait, apabila selama ini ada hal-hal yang kurang berkenan. Penulis berharap skripsi
ini dapat bermanfaat bagi Universitas dan masyarakat luas. Penulis mengharapkan
saran dan kritik yang dapat menjadikan skripsi ini lebih baik lagi

Wassalaamualaikum, Wr. Wb

Jakarta, 15 November 2013

Luigi Ajeng Pratiwi

109091000053

viii
 DAFTAR ISI
Halaman
HALAMAN JUDUL ....................................................................................... ii

HALAMAN PENGESAHAN ........................................................................ iii

PENGESAHAN UJIAN................................................................................. iv

PERNYATAAN ....................................................................................... v

ABSTRAKSI ...................................................................................... vi

KATA PENGANTAR ................................................................................... vii

DAFTAR ISI................................................................................................... ix

DAFTAR TABEL ........................................................................................ xvi

DAFTAR GAMBAR .................................................................................. xviii

DAFTAR LAMPIRAN ............................................................................... xxii

BAB I. PENDAHULUAN ............................................................................ 1

1.1. Latar Belakang ....................................................................................... 1

1.2. Rumusan Masalah ..................................................................................... 4

1.3. Batasan Masalah ....................................................................................... 4

1.4. Tujuan dan Manfaat ................................................................................. 6

1.5. Metodologi penelitian ............................................................................... 7

1. Metode Pengumpulan Data ................................................................. 7

2. Metode Pengembangan Sistem............................................................ 8

1.6 Sistematika Penulisan .............................................................................. 10

ix
BAB II. LANDASAN TEORI .................................................................... 11

2.1. Data ..................................................................................... 11

2.1.1. Pengertian Data ........................................................................... 11

2.1.2. Pengertian Himpunan Data.......................................................... 11

2.2. Data Mining ..................................................................................... 12

2.2.1. Pengertian Data Mining ............................................................... 12

2.2.2. Knowledge Discovery in Database dan Data Mining ................. 13

2.2.3. Tujuan Data Mining .................................................................... 17

2.2.4. Pengelompokkan Data Mining .................................................... 17

2.3. Clustering ..................................................................................... 18

2.3.1. Pengertian Clustering .................................................................. 18

2.3.2. Konsep Clustering dalam Data Mining ....................................... 19

2.3.3. Algoritma Clustering ................................................................... 20

2.3.4. Pengukuran Kinerja Clustering ................................................... 22

2.4. Algoritma K-Means ................................................................................ 24

2.4.1. Pengertian K-Means .................................................................... 24

2.4.2. Pseudocode .................................................................................. 27

2.4.3. Karakteristik K-Means ................................................................ 28

2.5 Peminatan ..................................................................................... 29

2.5.1. Pengertian Peminatan .................................................................. 29

2.5.2. Tujuan Peminatan ........................................................................ 29

2.5.3. Kriteria Peminatan ....................................................................... 29

x
 1. Waktu Peminatan..................................................................... 29

2. Kriteria Peminatan Program Studi........................................... 29

3. Mekanisme Peminatan Bagi Peserta Didik Kelas X ............... 31

2.6. Konsep Dasar dan Analisis Desain Sistem ............................................. 32

2.6.1. Pengertian Analisis dan Desain Sistem ....................................... 32

2.6.2. Pendekatan-Pendekatan Analisis Sistem ..................................... 32

2.7. Analisis dan Desain Berorientasi Objek (Object Oriented Analysis and Design)
Menggunakan UML (Unified Modeling Language) ....................................... 34

2.7.1. Konsep Sistem untuk Pemodelan Objek ..................................... 35

2.7.2. Hubungan Objek/Kelas ............................................................... 36

2.7.3. Tools Pengembangan Sistem ....................................................... 37

2.8. Metode Pengembangan Sistem ............................................................... 42

2.8.1. Fase Perencanaan Syarat-Syarat .................................................. 43

2.8.2. Desain Workshop (Fase Perancangan) ........................................ 43

2.8.3. Fase Konstruksi ........................................................................... 44

2.8.4. Fase Pelaksanaan ......................................................................... 44

2.9. Bahasa Pemrograman .............................................................................. 44

2.9.1. Java ..................................................................................... 44

2.9.2. Karakteristik Java ........................................................................ 45

2.9.3. Fitur-Fitur Java ............................................................................ 46

2.10. MYSQL ..................................................................................... 48

xi
BAB III. METODOLOGI PENELITIAN .................................................. 49

3.1. Metode Pengumpulan Data ..................................................................... 49

3.1.1. Studi Pustaka ............................................................................... 49

3.1.2. Interview ..................................................................................... 50

3.1.3. Observasi ..................................................................................... 50

3.1.4. Studi Literatur Sejenis ................................................................. 50

3.2. Metode Pengembangan Sistem ............................................................... 53

3.2.1. Fase Menentukan Syarat-Syarat .................................................. 53

3.2.2. Fase Desain Workshop (Fase Perancangan) ................................ 54

3.2.3. Fase Konstruksi ........................................................................... 55

3.2.4. Fase Pelaksanaan ......................................................................... 56

3.3. Alasan Menggunakan RAD .................................................................... 56

3.4. Alur Kerangka Penelitian ........................................................................ 58

xii
BAB IV. HASIL DAN PEMBAHASAN ..................................................... 59

4.1. Profil Umum SMA Negeri 29 Jakarta..................................................... 59

4.1.1. Sejarah Singkat SMA Negeri 29 Jakarta ..................................... 59

4.1.2. Struktur Organisasi SMA Negeri 29 Jakarta ............................... 60

4.1.3. Visi dan Misi SMA Negeri 29 Jakarta ........................................ 61

4.2. Metode Pengumpulan Data ..................................................................... 62

4.2.1. Studi Pustaka ............................................................................... 62

4.2.2. Wawancara/Interview .................................................................. 62

4.2.3. Observasi ..................................................................................... 63

4.2.4. Studi Literatur Sejenis ................................................................. 63

4.3. Metode Pengembangan Sistem ............................................................... 65

4.3.1. Fase Menentukan Syarat-Syarat .................................................. 65

4.3.1.1 Analisis Kebutuhan Masalah ......................................... 65

4.3.1.2 Mendefinisikan Masalah .............................................. 66

4.3.1.3 Tujuan Informasi ........................................................... 66

4.3.1.4 Syarat-Syarat Informasi ................................................. 68

4.3.1.5 Knowledge Discovery in Database ............................... 69

4.3.1.6 Penerapan algoritma K-Means dalam Data Mining ...... 71

4.3.2. Desain Workshop (Fase Perancangan) ........................................ 81

4.3.2.1 Perancangan Use Case Diagram ................................... 81

a. Identifikasi Aktor .................................................. 81

xiii
 b. Identifikasi Use Case ............................................ 82

c. Use Case Diagram ................................................. 85

d. Narasi Use Case Diagram ..................................... 86

4.3.2.2 Activity Diagram .......................................................... 100

4.3.2.3 Sequence Diagram ....................................................... 117

4.3.2.4 Class Diagram ............................................................. 135

4.3.2.5 Desain Database.......................................................... 137

1. Daftar Tabel ........................................................ 137

2. Deskripsi Tabel ................................................... 138

4.3.2.6 Perancangan Desain Antar Muka (Interface) .............. 141

4.3.3. Fase Konstruksi ......................................................................... 149

4.3.3.1. Konstruksi Algoritma K-Means ................................. 149

4.3.3.2. Pengkodean................................................................. 150

4.3.4. Fase Pelaksanaan ....................................................................... 158

4.3.4.1. Implementasi User Interface Aplikasi........................ 158

4.3.4.2. Pengujian Aplikasi (Black-box Testing) ..................... 160

4.3.4.3. Uji Validasi Algoritma K-Means ............................... 167

xiv
BAB V. PENUTUP ................................................................................... 172

4.1. Kesimpulan ................................................................................... 172

4.2. Saran ..................................................................................................... 173

DAFTAR PUSTAKA ................................................................................. 174

LAMPIRAN

xv
 DAFTAR TABEL

Halaman

Tabel 2.1. Matriks konfusi untuk klustering ................................................... 23

Tabel 3.1. Perbandingan Literatur Sejenis ...................................................... 50

Tabel 4.1. Daftar Nilai .................................................................................... 76

Tabel 4.2. Identifikasi Aktor ........................................................................... 81

Tabel 4.3. Identifikasi Use Case ..................................................................... 82

Tabel 4.4. Deskripsi Tabel Login. ................................................................... 86

Tabel 4.5. Deskripsi Tabel Input User (Halaman Admin) .............................. 87

Tabel 4.6. Deskripsi Tabel Lihat User (Halaman Admin) .............................. 88

Tabel 4.7. Deskripsi Tabel Lihat Siswa (Halaman Admin) ............................ 89

Tabel 4.8. Deskripsi Tabel Nilai Siswa (Halaman Admin) ........................... 90

Tabel 4.9. Deskripsi Tabel Input Kelas (Halaman Admin) ............................ 91

Tabel 4.10. Deskripsi Tabel Lihat Kelas (Halaman Admin) .......................... 92

Tabel 4.11. Deskripsi Tabel Peminatan Siswa (Halaman Admin) ................. 93

Tabel 4.12. Deskripsi Tabel Input Data Siswa (Halaman User) ..................... 94

Tabel 4.13. Deskripsi Tabel Lihat Data Siswa (Halaman User) ..................... 95

Tabel 4.14. Deskripsi Tabel Input Nilai Siswa (Halaman User) .................... 96

Tabel 4.15. Deskripsi Tabel Lihat Nilai Siswa (Halaman User) .................... 97

Tabel 4.16. Deskripsi Tabel Peminatan Siswa (Halaman User) ..................... 98

xvi
Tabel 4.17. Deskripsi Tabel Logout ................................................................ 99

Tabel 4.18. Daftar Tabel Database .................................................................. 137

Tabel 4.19. Hasil Pengujian Black-Box ............................................................ 160

Tabel 4.20. Data Validasi.............................................................................. 167

Tabel 4.21. Hasil Pengujian Matriks Konfusi ............................................... 170

xvii
 DAFTAR GAMBAR

Halaman

Gambar 2.1. Tahap Knowledge Discovery in Database ................................. 14

Gambar 2.2. Bentuk Sebelum di Klaster ........................................................ 18

Gambar 2.3. Bentuk Setelah di Klaster ........................................................... 19

Gambar 2.4. Pembagian Algoritma Clustering ............................................... 20

Gambar 2.5. Dendogram ................................................................................. 21

Gambar 2.6. Model Use Case ......................................................................... 39

Gambar 2.7. Model Class Diagram ................................................................ 40

Gambar 2.8. Model Activity Diagram ............................................................. 41

Gambar 2.9. Model Sequence Diagram .......................................................... 41

Gambar 2.10. Alur Rapid Application Development (RAD) .......................... 43

Gambar 3.2. Alur Kerangka Penelitian ........................................................... 58

Gambar 4.1. Struktur Organisasi SMA Negeri 29 Jakarta .............................. 60

Gambar 4.2. Flowchart Algoritma K-Means .................................................. 75

Gambar 4.3. Use Case Diagram ..................................................................... 85

Gambar 4.4. Activity Diagram Login (Halaman Admin) .............................. 100

Gambar 4.5. Activity Diagram Input User (Halaman Admin)...................... 101

Gambar 4.6. Activity Diagram Lihat User (Halaman Admin)..................... 102

Gambar 4.7. Activity Diagram Siswa (Halaman Admin) ............................. 104

xviii
Gambar 4.8. Activity Diagram Nilai (Halaman Admin) ............................... 105

Gambar 4.9. Activity Diagram Input Kelas (Halaman Admin) .................... 106

Gambar 4.10. Activity Diagram Lihat Kelas (Halaman Admin) .................. 107

Gambar 4.11. Activity Diagram Peminatan Siswa (Halaman Admin) ......... 108

Gambar 4.12. Activity Diagram Input Siswa (Halaman User) .................... 110

Gambar 4.13. Activity Diagram Lihat Siswa (Halaman User) ..................... 111

Gambar 4.14. Activity Diagram Input Nilai (Halaman User) ....................... 112

Gambar 4.15. Activity Diagram Lihat Nilai (Halaman User) ....................... 113

Gambar 4.16. Activity Diagram Peminatan (Halaman User) ....................... 115

Gambar 4.17. Activity Diagram Logout ....................................................... 116

Gambar 4.18. Sequence Diagram Login ....................................................... 117

Gambar 4.19. Sequence Diagram Input User (Halaman Admin) ................. 118

Gambar 4.20. Sequence Diagram Lihat User (Halaman Admin) ................. 119

Gambar 4.21. Sequence Diagram Lihat Siswa (Halaman Admin) ............... 121

Gambar 4.22. Sequence Diagram Lihat Nilai (Halaman Admin)................. 122

Gambar 4.23. Sequence Diagram Input Kelas (Halaman Admin) ............... 123

Gambar 4.24. Sequence Diagram Lihat Kelas (Halaman Admin) ............... 124

Gambar 4.25. Sequence Diagram Peminatan (Halaman Admin) ................. 125

Gambar 4.26. Sequence Diagram Input Siswa (Halaman User) .................. 126

Gambar 4.27. Sequence Diagram Lihat Siswa (Halaman User) .................. 127

Gambar 4.28. Sequence Diagram Input Nilai (Halaman User) .................... 129

xix
Gambar 4.29. Sequence Diagram Lihat Nilai (Halaman User) .................... 130

Gambar 4.30. Sequence Diagram Peminatan (Halaman User) .................... 132

Gambar 4.31. Sequence Diagram Logout ..................................................... 134

Gambar 4.32. Class Diagram ....................................................................... 136

Gambar 4.33. Desain User Interface Login .................................................. 141

Gambar 4.34. Desain User Interface Halaman Admin ................................. 141

Gambar 4.35. Desain User Interface Input User (Halaman Admin) ............ 142

Gambar 4.36. Desain User Interface Lihat User (Halaman Admin) ............ 142

Gambar 4.37. Desain User Interface Lihat Siswa (Halaman Admin) .......... 143

Gambar 4.38. Desain User Interface Lihat Nilai (Halaman Admin) ............ 143

Gambar 4.39. Desain User Interface Input Kelas (Halaman Admin) .......... 144

Gambar 4.40. Desain User Interface Lihat Kelas (Halaman Admin) ........... 144

Gambar 4.41. Desain User Interface Peminatan (Halaman Admin) ........... 145

Gambar 4.42. Desain User Interface Halaman User .................................... 145

Gambar 4.43. Desain User Interface Input Siswa (Halaman User)............. 146

Gambar 4.44. Desain User Interface Lihat Siswa (Halaman User).............. 146

Gambar 4.45. Desain User Interface Input Nilai (Halaman User) .............. 147

Gambar 4.46. Desain User Interface Lihat Nilai (Halaman User) ............... 147

Gambar 4.47. Desain User Interface Peminatan (Halaman User)............... 148

Gambar 4.48. Desain User Interface Pengujian (Halaman User) ................ 148

Gambar 4.49. Pseudocode ............................................................................ 149

xx
Gambar 4.50. Syntax Code Hitung Hasil Peminatan .................................... 154

Gambar 4.51. Syntax Code Cari Siswa ......................................................... 156

Gambar 4.52. User Interface Login .............................................................. 158

Gambar 4.53. User Interface Halaman Admin ............................................. 159

Gambar 4.54. User Interface Halaman User ................................................ 159

Gambar 4.55. Grafik Perbandingan .............................................................. 171

xxi
 DAFTAR LAMPIRAN

Halaman

Lampiran 1. Surat Keterangan (SK) Dosen Pembimbing ........................... 178

Lampiran 2. Surat Keterangan (SK) Pelaksanaan Riset ............................. 180

Lampiran 3. Hasil Wawancara .................................................................... 182

Lampiran 4. Source Code............................................................................ 188

xxii
 BAB I

PENDAHULUAN

1.1. Latar Belakang

Berkembangnya teknologi informasi berakibat pada kebutuhan informasi

yang semakin meningkat. Untuk mendapatkan informasi, diperlukan data serta

cara yang tepat untuk mengolah data yang ada. Banyaknya data yang diolah

dapat menimbulkan kesulitan dalam hal pengelompokkan data. Namun dengan

perkembangan Teknologi Informasi (TI) terdapat berbagai macam solusi untuk

mengatasi kesulitan tersebut, salah satunya adalah dengan menggunakan

teknologi Data Mining. Teknologi data mining merupakan salah satu alat bantu

untuk penggalian data pada basis data berukuran besar dan dengan spesifikasi

tingkat kerumitan yang telah banyak digunakan pada banyak domain aplikasi

seperti perbankan maupun bidang telekomunikasi (Jananto, 2010). Larose

(2005) dalam buku karangan Kusrini dan Taufiq Luthfi (2009) berpendapat

bahwa data mining terbagi atas beberapa kelompok berdasarkan tugas yang

dapat dilakukan, salah satunya adalah clustering atau pengklasteran.

Algoritma K-Means merupakan algoritma teknik klustering yang

berulang-ulang. Algoritma ini mempartisi data ke dalam cluster/kelompok

sehingga data yang memiliki karakteristik yang sama (High intra class

similarity) dikelompokkan ke dalam satu cluster yang sama dan yang memiliki

1
 2

karakteristik yang berbeda (Law inter class similarity) dikelompokkan pada

kelompok yang lain (Giyanto, 2008).

Penggalian informasi pada sebuah data yang berukuran besar

(mempunyai jumlah record dan jumlah field yang cukup banyak) tidak dapat

dilakukan dengan mudah sehingga penerapan teknologi data mining diperlukan

untuk membantu sekolah dalam proses peminatan jurusan bagi siswa kelas X.

Sesuai dengan Surat Keputusan (SK) Dirjen Mandikdasmen Departemen

Pendidikan Nasional Nomor 12/C/KEP/TU/2008 dalam Juknis Penulisan

Laporan Hasil Belajar Peserta Didik diketahui bahwa penentuan jurusan sangat

diperlukan bagi siswa Sekolah Menengah Atas (SMA), begitu juga di SMA

Negeri 29 Jakarta. Peminatan dilakukan pada saat siswa berada di kelas X

(sepuluh) dan akan naik ke kelas XI (sebelas). Setelah wali kelas menerima

seluruh nilai semester maka wali kelas akan memutuskan apakah siswa tersebut

naik atau tidak. Jika siswa tersebut dinyatakan naik maka selanjutnya akan

dilakukan proses penjurusan. Untuk mengetahui pengambilan keputusan

tersebut akurat atau tidak, harus dilakukan penilaian dengan kriteria yang telah

ditentukan selain dari nilai semester kriteria lain yang dibutuhkan dalam sistem

penjurusan adalah minat dan hasil psikotest siswa yang bersangkutan. Sehingga

dari hasil penilaian tersebut pihak sekolah dapat mengambil sebuah keputusan

sebagai bahan evaluasi untuk menentukan jurusan yang tepat bagi siswanya.
 3

Proses penentuan jurusan bagi siswa SMA akan terjadi secara berulang setiap

tahun. Jumlah data yang banyak tersebut membuka peluang untuk

menghasilkan informasi yang berguna bagi pihak sekolah khususnya untuk

mengetahui proses peminatan siswa.

Dari hasil wawancara yang dilakukan terhadap guru SMA Negeri 29

Jakarta diketahui bahwa saat ini SMA Negeri 29 Jakarta memiliki kesulitan

untuk proses peminatan yang masih menggunakan sistem manual dalam

mengolah data akademik siswa yang berjumlah 253 orang sehingga

membutuhkan waktu yang lama untuk mengetahui hasil peminatan siswa. Hal

ini menarik untuk diselesaikan agar bisa diperoleh informasi mengenai siapa

saja siswa yang masuk peminatan IPA dan siapa saja siswa yang masuk

peminatan IPS serta jumlah siswa yang berada pada dua program peminatan

tersebut. Jumlah siswa dan nilai siswa yang ada, akan diolah dengan

menerapkan algoritma K-Means dalam teknologi data mining sehingga

diharapkan dapat diketahui jumlah siswa yang masuk jurusan IPA atau IPS

secara akurat.

Berdasarkan permasalahan-permasalahan dalam latar belakang di atas, maka

penulis berkeinginan untuk menyusun skripsi dengan judul “Implementasi

Algoritma K-Means dalam Data Mining untuk Peminatan Jurusan Bagi

Siswa Kelas X SMA Negeri 29 Jakarta”

 4

1.2. Rumusan Masalah

Berdasarkan latar belakang masalah di atas, maka rumusan masalah yang akan

dibahas adalah sebagai berikut :

1. Bagaimana menemukan informasi pengelompokkan siswa yang dapat

membantu guru dalam menentukan jurusan sesuai dengan kemampuan

akademik siswa?

2. Apakah algoritma K-Means dapat di implementasikan dalam teknologi

data mining untuk proses peminatan jurusan berdasarkan kemampuan

akademik bagi siswa kelas X di SMA?

3. Apakah sistem peminatan jurusan dapat membantu pihak sekolah dalam

menentukan minat bagi siswa kelas X secara lebih efektif dan efisien?

1.3. Batasan Masalah

Batasan masalah dalam penerapan data mining dalam pemilihan jurusan bagi

siswa kelas X SMA Negeri 29 Jakarta menggunakan algoritma K-Means

adalah:

1. Penelitian ini menggunakan metode pengembangan sistem RAD Rapid

Application Development.

2. Data yang digunakan untuk proses analisis algoritma K-Means adalah data

nilai akademik. Nilai yang diambil sebagai dasar untuk proses clustering
 5

adalah nilai semester II di kelas X (sepuluh) SMA Negeri 29 Jakarta tahun

ajaran 2012/2013.

3. Angket minat siswa tidak dijadikan sebagai atribut hitung dalam proses

algoritma K-Means.

4. Faktor yang dibandingkan adalah nilai peminatan IPA (Matematika,

Kimia, Fisika, Biologi) dan nilai peminatan IPS (Ekonomi, Sejarah,

Geografi, Sosiologi).

5. User yang dapat menggunakan aplikasi ini adalah wali kelas.

6. Penelitian ini terfokus pada algoritma cluster data yang memanfaatkan

fungsi tugas data mining, bukan kepada proses atau ruang lingkup data

mining.

7. Pengembangan aplikasi ini akan dititikberatkan pada implementasi

metode cluster data menggunakan algoritma K-Means

8. Dalam proses pengembangan aplikasi ini, bahasa pemrograman yang

digunakan adalah bahasa Java dan aplikasi server atau database

menggunakan MySQL.

9. Metode analisis yang digunakan dalam pembangunan sistem ini

berdasarkan data terstruktur yaitu menggunakan Unified Modeling

Language (UML) yang terdiri dari use case diagram, activity diagram,

sequence diagram dan class diagram.

 6

10. Fitur aplikasi yang diutamakan adalah proses peminatan bagi siswa kelas

X SMA Negeri 29 Jakarta tahun ajaran 2012/2013.

1.4. Tujuan dan Manfaat

1. Tujuan

Adapun tujuan dari penulisan skripsi ini antara lain:

1. Menemukan informasi yang dapat membantu pihak sekolah dalam

proses peminatan sesuai dengan kemampuan yang dimiliki siswa.

2. Mengimplementasikan algoritma k-means dalam data mining

untuk proses peminatan siswa kelas X.

3. Mengetahui apakah algoritma K-Means dapat membantu proses

peminatan siswa kelas X secara efektif, akurat dan efisien.

2. Manfaat

2.1. Bagi Peneliti

 Penulis dapat lebih mengetahui cara menerapkan ilmu-ilmu yang

telah dipelajari selama ini terutama dalam menerapkan metode

clustering algoritma K-Means dalam data mining.

 Membandingkan teori yang ada dengan masalah yang sebenarnya.

 7

2.2. Bagi Instansi

Dapat membantu pihak sekolah khususnya guru dalam menentukan

peminatan bagi siswa-siswi kelas X sesuai dengan kemampuan

akademik siswa.

2.3. Bagi Universitas

 Mengetahui kemampuan mahasiswa dalam menguasai materi

pelajaran yang diperoleh dibangku perkuliahan.

 Mengetahui kemampuan mahasiswa dalam menerapkan ilmunya

dan sebagai bahan evaluasi.

 Memberikan gambaran tentang kesiapan mahasiswa dalam

menghadapi dunia kerja yang sebenarnya.

1.5. Metodologi Penelitian

Metodologi penelitian yang digunakan dalam penulisan skripsi ini adalah

sebagai berikut :

1. Metode pengumpulan data

Metode pengumpulan data yang digunakan dalam penelitian ini adalah

sebagai berikut :
 8

 Studi pustaka

Pengumpulan data dengan cara mengumpulkan buku-buku

bacaan, bacaan dari situs internet, literatur, jurnal, paper dan

yang ada kaitannya dengan judul penelitian.

 Wawancara

Wawancara adalah proses memproleh keterangan untuk tujuan

penelitian dengan cara tanya jawab, sambil bertatap muka antara

pewawancara dengan responden (Nazir, 2005).

 Observasi

Teknik pengumpulan data dengan mengadakan penelitian dan

peninjauan langsung terhadap permasalahan yang diambil.

 Studi Literatur Sejenis

Studi literatur adalah metode pengumpulan data dengan cara

menganalisa penelitian sejenis untuk mencari kelebihan terhadap

penelitian yang peneliti lakukan sekarang dengan penelitian yang

sudah ada (Nazir, 2005).

2. Metode Pengembangan Sistem

Dalam pengembangan sistem, digunakan metode RAD (Rapid

Application Development). Metode RAD terdiri dari empat fase yang

terdiri dari (Kendall & Kendall, 2010) :

 9

1. Fase menentukan syarat-syarat yaitu menentukan tujuan dan

syarat-syarat informasi yang dibutuhkan dalam penelitian skripsi

ini.

2. Fase desain workshop atau fase perancangan merupakan tahap-

tahap merancang proses-proses yang akan terjadi didalam sistem,

perancangan basis data (database) dan perancangan antarmuka

(interface).

3. Fase konstruksi merupakan kegiatan membuat baris baris kode

dalam bahasa pemrograman tertentu terhadap rancangan-

rancangan yang telah dibuat.

4. Fase pelaksanaan merupakan tahapan untuk menguji dan

mengenal sistem yang telah jadi.

 10

1.6. Sistematika Penulisan

BAB I : PENDAHULUAN

Pendahuluan memberikan uraian mengenai alasan dalam memilih judul dan

latar belakang masalah dan dijelaskan pula mengenai perumusan masalah,

pembatasan masalah, serta metode pengumpulan data.

BAB II : LANDASAN TEORI

Landasan teori memberikan uraian mengenai teori-teori yang berhubungan

dengan permasalahan yang diambil penulis. Teori – teori tersebut diambil dari

literatur-literatur, dokumentasi, serta informasi dari pihak yang bersangkutan

baik offline atau online.

BAB III : METODOLOGI PENELITIAN

Metodologi penelitian memberikan gambaran mengenai metode yang

digunakan dalam skripsi ini, teknik pengumpulan data, teknik analisa data,

teknik pengembangan aplikasi, teknik testing aplikasi, dsb.

BAB IV : HASIL PEMBAHASAN

Bab ini mengimplementasikan aplikasi pada bidang pemilihan jurusan bagi

siswa kelas X SMA berdasarkan hasil penelitian penulis.

BAB V : PENUTUP

Berisi kesimpulan yang berhubungan dengan penulisan serta saran yang

diharapkan berguna bagi pengembangan aplikasi dimasa depan.

 BAB II

LANDASAN TEORI

Bab ini menjelaskan tentang dasar teori yang digunakan dalam

penyusunan tugas akhir ini. Dijelaskan pengertian tentang data, data mining beserta

macam-macamnya, database serta analisis perancangan perangkat lunak.

2.1. Data

2.2.1. Pengertian Data

Data adalah nilai yang merepresentasikan deskripsi dari suatu objek atau

kejadian (event) (Wawan dan Munir, 2006). Data menggambarkan sebuah

representasi fakta yang tersusun secara terstruktur, atau dengan kata lain

digambarkan bahwa “Generally, data represent a structured codification of

single primary entities, as well as of transactions involving two or more

primary entities” (Vercellis, 2009). Dengan demikian dapat dijelaskan kembali

bahwa data merupakan suatu objek, kejadian, atau fakta yang

terdokumentasikan dengan memiliki kodifikasi terstruktur untuk suatu atau

beberapa entitas. Sedangkan kumpulan dari objek-objek yang ada disebut

himpunan data (data-set).

2.2.2. Pengertian Himpunan Data

Himpunan data (data-set) adalah kumpulan dari objek dan atribut. Atribut

merupakan sifat atau karakteristik dari suatu objek. Atribut juga dikenal sebagai

11
 12

variabel, field, karakteristik atau fitur. Contohnya warna mata seseorang, suhu,

dsb. Sedangkan, kumpulan dari atribut menggambarkan sebuah objek. Objek juga

disebut dengan record, titik, kasus, sample, entitas, atau instance (Hermawati,

2013).

2.2. Data Mining

2.2.1. Pengertian Data Mining

Secara sederhana data mining adalah penambangan atau penemuan

informasi baru dengan mencari pola atau aturan tertentu dari sejumlah data yang

berukuran besar (Davies, 2004). Data mining juga disebut sebagai serangkaian

proses untuk menggali nilai tambah berupa pengetahuan yang selama ini tidak

diketahui secara manual dari suatu kumpulan data (Pramudiono, 2007). Data

mining adalah kegiatan menemukan pola yang menarik dari data dalam jumlah

besar, data dapat disimpan dalam database, data warehouse, atau penyimpanan

informasi lainnya. Data mining berkaitan dengan bidang ilmu – ilmu lain,

seperti database system, data warehousing, statistik, machine learning,

information retrieval, dan komputasi tingkat tinggi. Selain itu, data mining

didukung oleh ilmu lain seperti neural network, pengenalan pola, spatial data

analysis, image database, signal processing (Han, 2006). Data mining

didefinisikan sebagai proses menemukan pola-pola dalam data. Proses ini

otomatis atau seringnya semiotomatis. Pola yang ditemukan harus penuh arti
 13

dan pola tersebut memberikan keuntungan, biasanya keuntungan secara

ekonomi. Data yang dibutuhkan dalam jumlah besar (Witten, 2005).

2.2.2. Knowledge Discovery in Database dan Data Mining

Istilah data mining dan knowledge discovery in databases (KDD) sering

kali digunakan secara bergantian untuk menjelaskan proses penggalian

informasi tersembunyi dalam suatu kumpulan data yang besar. KDD sering

disebut-sebut memiliki kesamaan dengan data mining, akan tetapi data mining

dan KDD sesungguhnya memiliki konsep yang berbeda namun berkaitan satu

sama lain. Ada beberapa tahapan dalam proses KDD, salah satunya adalah data

mining. KDD adalah proses menentukan informasi yang berguna serta pola-

pola yang ada dalam data. Informasi ini terkandung dalam basis data yang besar

yang sebelumnya tidak diketahui dan potensial bermanfaat. Data mining

merupakan salah satu langkah dari serangkaian iterative KDD (Han & Kamber,

2006).
 14

Sebagai suatu rangkaian proses, KDD dapat dibagi menjadi beberapa tahap

yang diilustrasikan pada Gambar 2.1.

Gambar 2.1. Dalam Knowledge Discovery in Databases (KDD)

(Han, 2006)

Proses KDD secara garis besar dapat dijelaskan sebagai berikut:

1. Pembersihan Data (Data Cleaning)

Pembersihan data merupakan proses menghilangkan noise dan data yang

tidak konsisten atau tidak relevan. Pada umumnya data yang diperoleh,

baik dari database memiliki isian-isian yang tidak sempurna seperti data

yang hilang, data yang tidak valid atau juga hanya sekedar salah ketik.

Selain itu, ada juga atribut-atribut data yang tidak relevan dengan hipotesa

data mining yang dimiliki. Data-data yang tidak relevan itu juga lebih baik

dibuang. Pembersihan data juga akan mempengaruhi performasi dari teknik

data mining karena data yang ditangani akan berkurang jumlah dan

kompleksitasnya.
 15

2. Integrasi data (Data Integration)

Integrasi data merupakan penggabungan data dari berbagai database ke

dalam satu database baru. Tidak jarang data yang diperlukan untuk data

mining tidak hanya berasal dari satu database tetapi juga berasal dari

beberapa database atau file teks. Integrasi data dilakukan pada atribut-

aribut yang mengidentifikasikan entitas-entitas yang unik seperti atribut

nama, jenis produk, nomor pelanggan dan lainnya. Integrasi data perlu

dilakukan secara cermat karena kesalahan pada integrasi data bisa

menghasilkan hasil yang menyimpang dan bahkan menyesatkan

pengambilan aksi nantinya.

3. Seleksi Data (Data Selection)

Data yang ada pada database sering kali tidak semuanya dipakai, oleh

karena itu hanya data yang sesuai untuk dianalisis yang akan diambil dari

database.

4. Transformasi data (Data Transformation)

Data diubah atau digabung ke dalam format yang sesuai untuk diproses

dalam data mining. Beberapa metode data mining membutuhkan format

data yang khusus sebelum bisa diaplikasikan. Sebagai contoh beberapa

metode standar seperti analisis asosiasi dan clustering hanya bisa menerima

input data kategorikal. Karenanya data berupa angka numerik yang

 16

berlanjut perlu dibagi-bagi menjadi beberapa interval. Proses ini sering

disebut transformasi data.

5. Proses mining

Merupakan suatu proses utama saat metode diterapkan untuk menemukan

pengetahuan berharga dan tersembunyi dari data.

6. Evaluasi pola (Pattern Evaluation)

Untuk mengidentifikasi pola-pola menarik kedalam knowledge based yang

ditemukan. Dalam tahap ini hasil dari teknik data mining berupa pola-pola

yang khas maupun model prediksi dievaluasi untuk menilai apakah

hipotesa yang ada memang tercapai. Bila ternyata hasil yang diperoleh

tidak sesuai hipotesa ada beberapa alternatif yang dapat diambil seperti

menjadikannya umpan balik untuk memperbaiki proses data mining,

mencoba metode data mining lain yang lebih sesuai, atau menerima hasil

ini sebagai suatu hasil yang di luar dugaan yang mungkin bermanfaat.

7. Presentasi pengetahuan (Knowledge Presentation)

Merupakan visualisasi dan penyajian pengetahuan mengenai metode yang

digunakan untuk memperoleh pengetahuan yang diperoleh pengguna.

Tahap terakhir dari proses data mining adalah bagaimana

memformulasikan keputusan atau aksi dari hasil analisis yang didapat. Ada

kalanya hal ini harus melibatkan orang-orang yang tidak memahami data

mining. Karenanya presentasi hasil data mining dalam bentuk pengetahuan

 17

yang bisa dipahami semua orang adalah satu tahapan yang diperlukan

dalam proses data mining. Dalam presentasi ini, visualisasi juga bisa

membantu mengkomunikasikan hasil data mining (Han, 2006).

2.2.3. Tujuan Data Mining

Tujuan dari data mining (Baskoro, 2010) adalah :

a. Explanatory, yaitu untuk menjelaskan beberapa kegiatan observasi

atau suatu kondisi.

b. Confirmatory, yaitu untuk mengkonfirmasikan suatu hipotesis yang

telah ada.

c. Exploratory, yaitu untuk menganalisis data baru suatu relasi yang

janggal.

2.2.4. Pengelompokkan Data Mining

Secara garis besar data mining dapat dikelompokkan menjadi 2 kategori

utama sesuai tugasnya (Tan et. al, 2005) yaitu :

a. Descriptive mining, yaitu proses untuk menemukan karakteristik

penting dari data dalam suatu basis data. Teknik data mining yang

termasuk dalam descriptive mining adalah clustering, association, dan

sequential mining.

b. Predictive mining, yaitu proses untuk menemukan pola dari data

dengan menggunakan beberapa variabel lain di masa depan. Salah satu

teknik yang terdapat dalam predictive mining adalah klasifikasi.

 18

2.3. Clustering

2.3.1. Pengertian Clustering

Clustering atau clusterisasi adalah salah satu alat bantu pada data mining

yang bertujuan mengelompokkan obyek-obyek ke dalam cluster-cluster.

Cluster adalah sekelompok atau sekumpulan obyek-obyek data yang similar

satu sama lain dalam cluster yang sama dan dissimilar terhadap obyek-obyek

yang berbeda cluster. Obyek akan dikelompokkan ke dalam satu atau lebih

cluster sehingga obyek-obyek yang berada dalam satu cluster akan mempunyai

kesamaan yang tinggi antara satu dengan lainnya. Obyek-obyek tersebut

dikelompokkan berdasarkan prinsip memaksimalkan kesamaan obyek pada

cluster yang sama dan memaksimalkan ketidaksamaan pada cluster yang

berbeda. Kesamaan obyek biasanya diperoleh dari nilai-nilai atribut yang

menjelaskan obyek data, sedangkan obyek-obyek data biasanya

direpresentasikan sebagai sebuah titik dalam ruang multidimensi (Baskoro,

2010).

Gambar 2.2 Data Sebelum di Klasterisasi

 19

Gambar 2.3 Klasterisasi Berdasarkan Similaritas (Kesamaan) Bentuk

2.3.2. Konsep Clustering dalam Data Mining

Konsep dasar data mining adalah menemukan informasi tersembunyi

dalam sebuah basis data dan merupakan bagian dari Knowledge Discovery in

Database (KDD) untuk menemukan informasi dan pola yang berguna dalam

data (Dunham 2003). Data mining mencari informasi baru, berharga dan

berguna dalam sekumpulan data dengan melibatkan komputer dan manusia

serta bersifat iteratif baik melalui proses yang otomatis ataupun manual.

Clustering membagi data menjadi kelompok-kelompok atau cluster berdasarkan

suatu kemiripan atribut-atribut diantara data tersebut (Dunham, 2003).

Karakteristik tiap cluster tidak ditentukan sebelumnya, melainkan tercermin

dari kemiripan data yang terkelompok di dalamnya. Oleh sebab itu hasil

clustering seringkali perlu diinterprestasikan oleh pihak-pihak yang benar-benar

mengerti mengenai karakter mining, clustering juga digunakan dalam pra-

pemrosesan data sebelum data diolah dengan metode data mining yang lain

untuk meningkatkan pemahaman terhadap domain data. Karakteristik terpenting

 20

dari hasil clustering yang baik adalah suatu instance data dalam suatu cluster

lebih “mirip” dengan instance lain di dalam cluster tersebut daripada dengan

instance di luar dari cluster itu (Kantardzic, 2003). Ukuran kemiripan

(similarity measure) bisa bermacam-macam dan mempengaruhi perhitungan

dalam menentukan anggota suatu cluster. Jadi tipe data yang akan di-cluster

(kuantitatif atau kualitatif) juga menentukan ukuran apa yang tepat digunakan

dalam suatu algoritma. Selain kemiripan antar data dalam suatu cluster,

clustering juga dapat dilakukan berdasarkan jarak antar data atau cluster yang

satu dengan yang lainnya. Ukuran jarak (distance atau dissimilarity measure)

yang merupakan kebalikan dari ukuran kemiripan ini juga banyak ragamnya

dan penggunaannya juga tergantung pada tipe data yang akan di-cluster. Kedua

ukuran ini bersifat simetris, dimana jika A dikatakan mirip dengan B maka

dapat disimpulkan bahwa B mirip dengan A.

2.3.3. Algoritma Clustering

Pembagian clustering (Bahar, 2011) dapat digambarkan sebagai berikut :

Gambar 2.4 Pembagian Algoritma Clustering (Bahar, 2011)

 21

Hierarchical clustering menentukan sendiri jumlah cluster yang

dihasilkan. Hasil dari metode ini adalah suatu struktur data berbentuk pohon

yang disebut dendogram dimana data dikelompokkan secara bertingkat dari

yang paling bawah dimana tiap instance data merupakan satu cluster sendiri,

hingga tingkat paling atas dimana keseluruhan data membentuk satu cluster

besar berisi cluster-cluster (Bahar, 2011).

Gambar 2.5 Dendogram

Divisive hierarchical clustering mengelompokkan data dari kelompok

yang terbesar hingga ke kelompok yang terkecil, yaitu masing-masing instance

dari kelompok data tersebut. Sebaliknya, agglomerative hierarchical clustering

mulai mengelompokkan data dari kelompok yang terkecil hingga kelompok

yang terbesar (Kantardzic, 2003). Beberapa algoritma yang menggunakan

metode ini adalah: RObust Clustering Using LinKs (ROCK), Chameleon,

Cobweb, Shared Nearest Neighbor (SNN) (Bahar, 2011).

Partitional clustering yang mengelompokkan data ke dalam k cluster

dimana k adalah banyaknya cluster dari input user. Kategori ini biasanya
 22

memerlukan pengetahuan yang cukup mendalam tentang data dan proses bisnis

yang memanfaatkannya untuk mendapatkan kisaran nilai input yang sesuai.

Beberapa algoritma yang masuk dalam kategori ini antara lain: K-Means, Fuzzy

C-Means, Clustering Large Aplications (CLARA), Expectation Maximation

(EM), Bond Energy Algorithm (BEA), algoritma Genetika, Jaringan Saraf

Tiruan (Bahar, 2011).

Clustering Large Data, dibutuhkan untuk melakukan clustering pada

data yang volumenya sangat besar sehingga tidak cukup ditampung dalam

memori komputer pada suatu waktu. Biasanya untuk mengatasi masalah

besarnya volume data, dicari teknik-teknik untuk meminimalkan berapa kali

algoritma harus membaca seluruh data. Beberapa algoritma yang masuk dalam

kategori ini antara lain: Balanced Iteratif Reducing and clustering using

hierarchies (BIRCH), Density Based Spatial Clustering of Application With

Noise (DCSCAN), Clustering Categorical Data Using Summaries (CACTUS)

(Bahar, 2011).

2.3.4. Pengukuran Kinerja Clustering

Menurut Eko Prasetyo (2012), sebuah sistem klustering juga harus diukur

kinerjanya guna melihat tingkat akurasi dan kesalahan dari sistem tersebut.

Umumnya, pengukuran kinerja klustering dilakukan dengan matriks konfusi

(confusion matrix). Matriks konfusi merupakan tabel pencatat hasil kerja

klustering. Tabel 2.1 merupakan contoh matriks konfusi yang melakukan

 23

klasifikasi masalah biner pada dua kelas yaitu kelas 0 dan 1. Setiap sel fij dalam

matriks menyatakan jumah rekord/data dari kelas i yang hasil prediksinya

masuk ke kelas j. Misalnya, sel f11 adalah jumlah data dalam kelas 1 yang

secara benar dipetakan ke kelas 1, dan f10 adalah data dalam kelas 1 yang

dipetakan secara salah ke kelas 0.

Tabel 2.1 Matriks konfusi untuk klustering dua kelas

Kelas hasil prediksi (j)
fij
Kelas = 1 Kelas = 0
Kelas = 1 f11 f10
Kelas asli (i) Kelas = 0 f01 f00

Berdasarkan isi matriks konfusi, dapat diketahui jumlah data dari

masing-masing kelas yang dikluster secara benar, yaitu (f11+f00), dan data

yang dikluster secara salah, yaitu (f10+f01). Kuantitas matriks konfusi dapat

diringkas menjadi dua nilai, yaitu akurasi dan laju error. Dengan mengetahui

jumlah data yang dikluster secara benar, dapat diketahui akurasi hasil prediksi,

dan dengan mengetahui jumlah data yang dikluster secara salah, dapat diketahui

laju error dari prediksi yang dilakukan. Dua kuantitas ini digunakan sebagai

matrik kinerja kluster.

Untuk menghitung akurasi kluster digunakan formula :

Untuk menghitung laju error (kesalahan prediksi) digunakan formula :

 24

2.4. Algoritma K-Means

2.4.1. Pengertian K-Means

K-Means merupakan algoritma yang umum digunakan untuk clustering

dokumen. Prinsip utama K-Means adalah menyusun k prototype atau pusat

massa (centroid) dari sekumpulan data berdimensi n (Aryan, 2010). Sebelum

diterapkan proses algoritma K-means, data akan di preprocessing terlebih

dahulu. Algoritma K-Means termasuk dalam partitioning clustering yang

memisahkan data ke k daerah bagian yang terpisah. Algoritma K-Means sangat

terkenal karena kemudahan dan kemampuannya untuk mengklaster data besar

dan outlier dengan sangat cepat. Menurut Ediyanto dan rekan (2013) algoritma

K-Means cukup efektif diterapkan dalam proses pengelompokkan karakteristik

terhadap objek penelitian. Menurut MacQueen J.B (1967) K-Means merupakan

metode klasterisasi yang paling terkenal dan banyak digunakan di berbagai

bidang karena sederhana, mudah diimplementasikan, memiliki kemampuan

untuk mengklaster data yang besar, mampu menangani data outlier, dan

kompleksitas waktunya linear O(nKT) dengan n adalah jumlah dokumen, K

adalah jumlah kluster, dan T adalah jumlah iterasi. K-means merupakan metode

pengklasteran secara partitioning yang memisahkan data ke dalam kelompok

yang berbeda. Dengan partitioning secara iteratif, K-Means mampu

meminimalkan rata-rata jarak setiap data ke klasternya.

 25

Dalam algoritma K-Means, setiap data harus termasuk ke cluster tertentu pada

suatu tahapan proses, pada tahapan proses berikutnya dapat berpindah ke cluster

yang lain. Pada dasarnya penggunaan algoritma K-Means dalam melakukan

proses clustering tergantung dari data yang ada dan konklusi yang ingin dicapai.

Untuk itu digunakan algoritma K-Means yang didalamnya memuat aturan

sebagai berikut :

a. Jumlah cluster yang perlu di inputkan

b. Hanya memiliki attribut bertipe numeric

Algoritma K-Means pada awalnya mengambil sebagian dari banyaknya

komponen dari populasi untuk dijadikan pusat cluster awal. Pada step ini pusat

cluster dipilih secara acak dari sekumpulan populasi data. Berikutnya K-Means

menguji masing-masing komponen didalam populasi data dan menandai

komponen tersebut ke salah satu pusat cluster yang telah di definisikan

tergantung dari jarak minimum antar komponen dengan tiap-tiap pusat cluster.

Posisi pusat cluster akan dihitung kembali sampai semua komponen data

digolongkan kedalam tiap-tiap cluster dan terakhir akan terbentuk posisi cluster

baru.

Algoritma K-Means pada dasarnya melakukan 2 proses yakni proses

pendeteksian lokasi pusat cluster dan proses pencarian anggota dari tiap-tiap

cluster. Proses klustering dimulai dengan mengidentifikasi data yang akan

dikluster, Cij (i=1,...,n; j=1,...,m) dengan n adalah jumlah data yang akan
 26

dikluster dan m adalah jumlah variabel. Pada awal iterasi, pusat setiap kluster

ditetapkan secara bebas (sembarang), Ckj (k=1,...,k; j=1,...,m). Kemudian

dihitung jarak antara setiap data dengan setiap pusat kluster. Untuk melakukan

penghitungan jarak data ke-I (xi) pada pusat kluster ke-k (ck), diberi nama

(dik), dapat digunakan formula Euclidean. Suatu data akan menjadi anggota

dari kluster ke-k apabila jarak data tersebut ke pusat kluster ke-k bernilai paling

kecil jika dibandingkan dengan jarak ke pusat kluster lainnya. Kita bisa

menghitungnya dengan persamaan 2. Selanjutnya, kelompokkan data-data yang

menjadi anggota pada setiap kluster. Nilai pusat kluster yang baru dapat

dihitung dengan cara mencari nilai rata-rata dari data data yang menjadi anggota

pada kluster tersebut, dengan menggunakan rumus pada persamaan 3.

Proses dasar algoritma K-Means (Santosa, 2007) :

1. Tentukan k sebagai jumlah cluster yang ingin dibentuk. Tetapkan pusat

kluster sembarang.

2. Hitung jarak setiap data ke pusat kluster menggunakan persamaan

Euclidean

.............................................. (1)

3. Kelompokkan data ke dalam kluster yang dengan jarak yang paling

pendek menggunakan persamaan

.................................(2)
 27

4. Hitung pusat kluster yang baru menggunakan persamaan

............................................................(3)

Dimana :

P = banyaknya anggota kluster ke k

5. Ulangi langkah 2 sampai dengan 4 hingga sudah tidak ada lagi data yang

berpindah ke kluster yang lain.

2.4.2. Pseudocode

Pseudo berarti imitasi atau mirip atau menyerupai dan code menunjukkan

kode dari program, berarti pseudocode adalah kode yang mirip dengan

instruksi kode program sebenarnya (Utami dan Raharjo, 2004).

Pseudocode ditulis berbasis bahasa pemrograman seperti BASIC,

PASCAL dan C, sehingga lebih tepat digunakan untuk menggambarkan

algoritma yang akan dikomunikasikan kepada programmer (Sutedjo dan

Michael, 2004).

Pseudocode akan memudahkan pemrogram untuk memahami dan

menggunakan, karena mirip dengan kode-kode program sebenarnya.

Pseudocode menjelaskan juga tentang pemberian nilai awal dari suatu

 28

variable, membuka dan menutup file, subscript atau tipe-tipe data yang

digunakan (misalnya real, integer, Boolean).

2.4.3. Karakteristik K-Means

Berdasarkan cara kerjanya, algoritma K-Means memiliki karakteristik

(wijaya, 2010):

1. K-Means sangat cepat dalam proses clustering

2. K-Means sangat sensitif pada pembangkitan centroids awal secara

random

3. Memungkinkan suatu cluster tidak mempunyai anggota

4. Hasil clustering dengan K-Means bersifat unik (Selalu berubah-

ubah) – terkadang baik, terkadang jelek.

Adapun tujuan dari data clustering ini adalah untuk meminimalisasikan

objective function yang diset dalam proses clustering, yang pada umumnya

berusaha meminimalisasikan variasi di dalam suatu cluster dan

memaksimalisasikan variasi antar cluster. Ada dua cara pengalokasian data

kembali ke dalam masing-masing cluster pada saat proses iterasi clustering.

 29

2.5. Peminatan

2.5.1. Pengertian Peminatan

Pada saat seorang siswa masuk ke jenjang SMA dan mulai belajar di

kelas X, seorang siswa dapat memilih program peminatan bidang IPA atau IPS

sesuai dengan kriteria mata pelajaran yang telah ditentukan dan dapat diketahui

berdasarkan nilai raport semester ganjil dan genap pada saat siswa tersebut

dinyatakan naik ke kelas XI.

2.5.2. Tujuan Peminatan

1. Mengelompokkan siswa sesuai kecakapan, kemampuan, dan

bakat yang relatif sama.

2. Membantu mempersiapkan siswa dalam melanjutkan studi dan

memilih dunia kerja.

3. Membantu memperkokoh keberhasilan dan kecocokan atas yang

akan dicapai di waktu mendatang.

2.5.3. Kriteria Peminatan

1. Waktu Peminatan

1.1 Penentuan peminatan program studi IPA dan IPS dilakukan

mulai dari semester 1 (ganjil) kelas X

1.2 Pelaksanaan peminatan program studi di semester 1 kelas XI

2. Kriteria Peminatan Program Studi Meliputi :

2.1 Nilai Akademik

 30

Siswa yang naik kelas XI dan akan mengambil program studi

tertentu, yaitu : Ilmu Pengetahuan Alam dan Ilmu Pengetahuan

Sosial boleh memiliki nilai yang tidak tuntas paling banyak 3

mata pelajaran pada mata pelajaran yang bukan jadi ciri khas

program studi tersebut. Siswa naik kelas XI dan yang

bersangkutan mendapatkan nilai tidak tuntas 3 mata pelajaran,

maka nilai tersebut harus dijadikan dasar untuk menentukan

program studi yang dapat dimasukkan ke program studi yang

dapat diikuti oleh siswa.

Program Studi Ilmu Program Studi Ilmu

Pengetahuan Alam Pengetahuan Sosial

Matematika Ekonomi

Fisika Sosiologi

Kimia Sejarah

Biologi Geografi

2.2 Minat Siswa

Untuk dapat mengetahui minat siswa dapat dilakukan angket,

kuesioner atau wawancara.

 31

3. Mekanisme Peminatan Bagi Peserta Didik Kelas X

 Angket Minat Siswa

 Nilai prestasi akademis raport semester 1 dan 2 kelas X

program peminatan IPA atau IPS

 Standar Nilai KKM yang menjadi acuan sekolah di Indonesia

adalah :

1. Nilai ketuntasan belajar untuk aspek pengetahuan dan

praktik dinyatakan dalam bentuk bilangan bulat dengan

skala 0-100

2. Ketuntasan belajar setiap indikator yang telah

ditetapkan dalam suatu kompetensi dasar berkisar

anatara 0-100%. Kriteria ideal ketuntasan untuk masing

masing indikator adalah 75%

3. Satuan pendidikan dapat menentukan Kriteria

Ketuntasan minimal (KKM) dibawah nilai ketuntasan

belajar ideal. Satuan pendidikan diharapkan

meningkatkan kriteria ketuntasan belajar secara terus

menerus untuk mencapai kriteria ketuntasan ideal.

4. KKM ditetapkan oleh forum guru pada awal tahun

pelajaran.
 32

5. KKM tersebut dicantumkan ke dalam LHB dan

diinformasikan kepada seluruh warga sekolah dan

orangtua siswa.

2.6. Konsep Dasar Analisis dan Desain Sistem

2.6.1. Pengertian Analisis dan Desain Sistem

Analisis Sistem merupakan sebuah teknik pemecahan masalah yang

menguraikan sebuah sistem menjadi bagian- bagian komponen dengan tujuan

mempelajari seberapa bagus bagian-bagian komponen tersebut bekerja dan

berinteraksi untuk meraih tujuan mereka. (Whitten et.al, 2004).

Sedangkan Sistem desain adalah sebuah teknik pemecahan masalah yang saling

melengkapi (dengan Analisis Sistem) yang merangkai kembali bagian-baagian

relatif pada sistem yang diperbaiki. Hal ini melibatkan penambahan,

penghapusan dan perubahan bagian-bagian relatif pada sistem aslinya

(awalnya).

2.6.2. Pendekatan-Pendekatan Analisis Sistem

Analisis Sistem merupakan pemecahan dari suatu masalah, banyak

pendekatan dalam menghadapi masalah, oleh karena itu Analisis Sistem

mempunyai beberapa pendekatan masalah, berikut ini adalah pendekatan

masalah dari Analisis Sistem :

1. Analisis Terstruktur(structured Analysis)

 33

Analisis Terstruktur merupakan sebuah teknik model-driven dan

berpusat pada proses yang digunakan untuk menganalisis sistem yang

ada, mendefinisikan persyaratan-peryaratan bisnis untuk sebuah sistem

baru, atau keduanya (Whitten, 2004).

2. Teknik Informasi(Information Engineering)

Merupakan sebuah teknik model-driven dan berpusat pada data, tetapi

sensitif pada proses. Teknik ini digunakan untuk merencanakan,

menganalisa, dan mendesain Sistem Informasi. Model-model ini adalah

gambaran yang mengilustrasikan dan menyesuaikan data dan proses-

proses sistem (Whitten, 2004).

3. Discovery Prototyping

Discovery Prototyping adalah sebuah teknik yang digunakan untuk

mengidentifikasikan persyaratan-persyaratan bisnis pengguna dengan

membuat para pengguna dengan membuat para pengguna bereaksi pada

implementasi quick end dirt (bijaksana dan efektif tapi tanpa cacat atau

efek samping yang tidak diinginkan) persyaratan-persyaratan tersebut

(Whitten, 2004).

4. Analisis Berorientasi Objek (Object Orientasi Analysis)

Analisis Berorientasi Objek adalah sebuah teknik yang mengintegrasikan

data dan proses kedalam konstruksi yang disebut object. Model-model

OOA (Object Orientasi Analysis) adalah gambar-gambar yang

 34

mengilustrasikan objek-objek sistem dari berbagai macam perspektif,

seperti struktur, kelakuan, dan interaksi objek-objek (Whitten, 2004).

2.7. Analisis dan Desain Berorientasi Objek (Object Oriented Analysis and

Design) Menggunakan UML (Unified Modeling Language)

Teknik analisis berorientasi objek merupakan alat terbaik yang dapat di

gunakan untuk sebuah proyek yang akan mengimplementasikan sistem yang

menggunakan teknologi objek untuk membangun, mengelola, dan merakit objek-

objek itu menjadi aplikasi yang berguna. Teknik pemodelan objek menyajikan

penggunaan metodologi dan notasi diagram yang sama sekali berbeda dengan teknik

lainnya yang biasa digunakan untuk pemodelan data dan pemodelan proses.

Pada akhir tahun 80-an dan awal 90-an, di gunakan beberapa metode

berorientasi objek yang berbeda-beda. Yang paling terkenal adalah metode Booch

dari Grady Booch Object Modeling Technique (OMT) dari James Rumbaugh (OMT),

dan Object Oriented Software Engineering (OOSE) dari Ivar Jacobson. Banyaknya

teknik yang di gunakan membatasi kemampuan untuk memakai model-model pada

proyek lain (mengurangi reuse) dan tim pengembang. Konsekuesinya, teknik ini

menghambat komunikasi antara anggota tim dan pengguna, yang mengakibatkan

banyak terjadi error di dalam proyek. Masalah ini dan lainnya mendorong di

lakukannya usaha untuk mendesain bahasa pemodelan standar (Whitten et al. 2004).
 35

Pada tahun 1994, Grady Booch dan James Rumbaugh sepakat bergabung untuk

menggunakan metode pengembangan berorientasi objek dengan tujuan membuat

proses standar tunggal untuk mengembangkan sistem berorientasi objek. Ivar

Jacobson bergabung pada tahun 1995, dan mereka bertiga fokus membuat sebuah

bahasa pemodelan objek standar sebagai ganti dari pendekatan atau metode

berorientasi objek standar. Berdasarkan keja mereka dan hasil kerja lainnya pada

industri, Unified Modeling Language (UML) versi 1.0 di rilis pada tahun 1997

(Whitten et.al, 2004).

Unified Modeling Language (UML) adalah satu kumpulan konvensi pemodelan

yang di gunakan untuk menentukan atau menggambarkan sebuah sistem software

yang terkait dengan objek (Whitten et.al, 2004).

2.7.1. Konsep Sistem untuk Pemodelan Objek

Analisis sistem berorientasi objek di dasarkan beberapa konsep. Sebagian

konsep ini membutuhkan cara pemikiran baru untuk sistem dan proses

pengembangannya (Whitten et.al, 2004).

1. Object adalah sesuatu yang ada atau dapat di lihat, di sentuh, atau di

rasakan dan user menyimpan data serta mencatat perilaku mengenai

sesuatu itu.

2. Attribute adalah data yang mewakili karakteristik interes tentang sebuah

objek.
 36

3. Object instance adalah setiap orang khusus, tempat, sesuatu, atau

kejadian, dan juga nilai untuk atribut dari objek.

4. Behavior adalah kumpulan dari sesuatu yang dapat di lakukan oleh objek

dan terkait dengan fungsi-fungsi yang bertindak pada data objek (atau

atribut). Pada siklus berorientasi objek, perilaku objek merujuk kepada

metode, operasi, atau fungsi (istila ini di gunakan berganti-ganti di

sepanjang buku ini).

5. Encapsulation adalah pengemasan beberapa item ke dalam satu unit.

Konsep penting lain mengenai pemodelan objek adalah konsep

pengkategorian objek menjadi class/kelas yaitu sebagai berikut (Whitten

et.al, 2004) :

1. Class adalah satu set objek yang memiliki atribut dan behavior yang

sama. Kadang-kadang di sebut object class.

2. Generalization/specialization adalah sebuah teknik di mana atribut

dan behavior yang umum pada beberapa tipe kelas objek, di

kelompokkan (atau di abstraksi) ke dalam kelasnya sendiri di sebut

supertype. Atribut dan metode kelas objek supertype kemudian di

wariskan oleh kelas objek tersebut (subtype).

2.7.2. Hubungan Objek/Kelas

Object/class relationship adalah asosiasi bisnis yang ada di antara satu

atau lebih objek dan kelas. Multiplicity adalah jumlah kejadian minimum dan
 37

maksimum dari satu objek/kelas untuk satu kejadian tunggal dari objek/kelas

yang terkait. Aggregation adalah sebuah hubungan di mana satu kelas “whole”

yang lebih besar berisi satu atau lebih kelas “part” yang lebih kecil. Atau, kelas

“part” yang lebih kecil adalah bagian dari kelas “whole” yang lebih besar.

Composition adalah hubungan agregasi di mana “whole” bertanggungjawab

atas pembuatan dan perusakan “bagian-bagian”. Jika “whole” rusak, maka

“part” juga akan rusak (Whitten et.al, 2004).

2.7.3. Tools Pengembangan Sistem

Unified Modeling Language (UML) adalah salah satu alat bantu yang

sangat handal di dunia pengembangan sistem yang berorientasi obyek. Hal ini

di sebabkan karena UML menyediakan bahasa pemodelan visual yang

memungkinkan bagi pengembang sistem untuk membuat cetak biru atas visi

mereka dalam bentuk yang baku, mudah di mengerti, serta di lengkapi dengan

mekanisme yang efektif untuk berbagi (sharing) dan mengkomunikasikan

rancangan mereka dengan yang lain (Munawar, 2005).

UML merupakan kesatuan dari bahasa pemodelan yang di kembangkan

oleh Booch, Object Modeling Technique (OMT) dan Object Oriented Software

Engineering (OOSE). Metode Booch dari Grady Booch sangat terkenal dengan

nama metode Design Object Oriented. Metode ini menjadikan proses analisis

dan design ke dalam 4 (empat) tahapan iterative, yaitu: identifikasi kelas-kelas

dan obyek-obyek, identifikasi semantik dari hubungan obyek dan kelas tersebut,
 38

perincian interface dan implementasi. Keunggulan metode Booch adalah pada

detil dan kayanya dengan notasi dan elemen. Pemodelan OMT yang di

kembangkan oleh Rumbaugh di dasarkan pada analisis terstruktur dan

pemodelan entity-relationship.

Desain sistem pada UML di susun oleh simbol-simbol yang terbentuk

menjadi sebuah diagram model. Berikut adalah simbol yang digunakan pada

desain sistem ini.

Unified Modeling Language (UML) memiliki beberapa diagram di

antaranya (Munawar, 2005):

1. Use Case Diagram

Use case adalah deskripsi fungsi dari sebuah sistem dari perspektif

pengguna. Use case bekerja dengan cara mendeskripsikan tipikal

interaksi antara user (pengguna) sebuah sistem dengan sistemnya sendiri

melalui sebuah cerita bagaimana sebuah sistem di pakai. (Munawar,

2005)

Dalam sebuah pembicaraan tentang use case, pengguna biasanya di sebut

dengan actor. Actor adalah sebuah peran yang bisa di mainkan oleh pengguna

dalam interaksinya dengan sistem. Use case adalah alat bantu terbaik guna

menstimulasi pengguna potensial untuk mengatakan tentang suatu sistem dari

sudut pandangnya. Diagram use case mempunyai 3 notasi yang menunjukkan

aspek dari sistem (Munawar, 2005):

 39

a. Actor (Pengguna) yaitu abstraksi dari orang dan sistem lain yang

mengaktifkan fungsi dari target sistem. Actor mewakili peran orang,

sistem yang lain atau alat ketika berkomunikasi dengan use case.

b. Use Case adalah abstraksi dari interaksi antara sistem dan actor. Use

case di buat berdasarkan keperluan actor. Use Case harus merupakan

“apa” yang di kerjakan software aplikasi, bukan “bagaimana” software

aplikasi mengerjakannya. Setiap use case harus di beri nama yang

menyatakan apa hal yang di capai dari hasil interaksinya dengan actor.

c. Relationship (hubungan) yaitu hubungan antara actor/pelaku dengan

use case di mana terjadi interaksi di antara mereka.

System

Use Case 1

Use Case 2
Actor 1 Actor 2

Use Case 3

Actor 3

Gambar 2.6 Contoh Diagram Model Use Case

2. Class Diagram

Class dalam notasi UML di gambarkan dengan kotak. Nama class

menggunakan huruf besar di awal kalimatnya dan di letakkan di atas

kotak. Bila class mempunyai nama yang terdiri dari 2 (dua) suku kata
 40

atau lebih, maka semua suku kata di gabungkan tanpa spasi dengan huruf

awal tiap suku kata menggunakan huruf besar. Atribute adalah property

dari sebuah class. Attribute ini melukiskan batas nilai yang mungkin ada

pada obyek dari class. Sebuah class mungkin mempunyai nol atau lebih

attribute (Munawar, 2005).

Operation adalah sesuatu yang bisa di lakukan oleh sebuah class atau

yang anda (atau class yang lain) dapat lakukan untuk sebuah class.

Responsibility adalah keterangan tentang apa yang akan di lakukan class

yaitu apa yang akan di capai oleh attribute dan operation (Munawar,

2005).

Class1 Class3
Class2
-Attribute 1 -Attribute 1
-Attribute 1
-Attribute 2 -Attribute 2
-Attribute 2 1 1
-Attribute 3 -Attribute n
-Attribute n * *
-Attribute n +Operation 1()
+Operation 1()
+Operation 1() +Operation n()
+Operation n()
+Operation 2()
+Operation n()

Gambar 2.7 Contoh Model Class Diagram

3. Activity Diagram

Activity Diagram adalah teknik untuk mendeskripsikan logika

procedural, proses bisnis dan aliran kerja dalam banyak kasus. Activity

diagram mempunyai peran seperti halnya flowchart, akan tetapi

perbedaannya dengan flowchart adalah activity diagram bisa mendukung

perilaku paralel sedangkan flowchart tidak bisa (Munawar, 2005).

 41

Start

Control Flow

ActionState1

If True

ActionState2

Finish

Gambar 2.8 Contoh Model Activity Diagram

4. Sequence Diagram

Sequence diagram di gunakan untuk menggambarkan perilaku pada

sebuah scenario. Diagram ini menunjukkan sejumlah contoh obyek dan

message (pesan) yang di letakkan di antara obyek-obyek ini di dalam use

case. Komponen utama sequence diagram terdiri atas obyek yang di

tuliskan dengan kotak segiempat bernama. Message di wakili oleh garis

dengan tanda panah dan waktu yang di tunjukkan dengan progress

vertical (Munawar, 2005).

Object 1

Actor

Message 1

Message Call 1

Reply Message 1

Gambar 2.9 Contoh Model Sequence Diagram

 42

2.8. Metode Pengembangan Sistem

Metode adalah suatu cara atau metode yang disarankan untuk melakukan

sesuatu hal. Pendekatan sistem merupakan metode dasar untuk memecahkan masalah.

Metode yang digunakan oleh penulis dalam pembuatan sistem pemilihan jurusan

menggunakan algoritma K-Means bagi siswa kelas X ini adalah penulis

menggunakan metode RAD (Rapid Application Develompement) dimana penulis

akan menyelesaikan sistem dengan terus menerus melakukan perbaikan jika ada suatu

fungsi yang tidak berhasil dijalankan. Metode ini sangat baik digunakan dalam

pengembangan suatu sistem dengan waktu yang singkat.

Rapid Application Development atau Pengembangan Aplikasi Cepat adalah

suatu pendekatan berorientasi objek terhadap pengembangan sistem yang mencakup

suatu metode pengembangan serta perangkat-perangkat lunak (Kendall & Kendall,

2010).

Pada Rapid Application Development (RAD) terdapat tiga fase yang

melibatkan penganalisis dan pengguna dalam tahap penilaian, perancangan dan

penerapan, yaitu :

1. Fase Perencanaan Syarat-syarat

2. Desain Workshop (Fase Perancangan)

3. Fase Kontruksi

4. Fase Pelaksanaan
 43

Gambar 2.10 RAD (Rapid Application Development)

2.8.1. Fase Perencanaan Syarat-Syarat

Dalam fase ini, pengguna dan penganalisis bertemu untuk

mengidentifikasikan tujuan-tujuan aplikasi atau sistem serta untuk

mengidentifikasi syarat-syarat informasi yang ditimbulkan dari tujuan-tujuan

tersebut. Pada fase ini penulis melakukan analisis kebutuhan

2.8.2. Desain Workshop (Fase Perancangan)

Fase ini adalah fase merancang dan memperbaiki yang bisa

digambarkan sebagai workshop. Pada tahap inilah dilakukan proses desain

dan melakukan perbaikan-perbaikan apabila masih terdapat ketidaksesuaian

desain antara user dan perancang sistem. Untuk tahap ini, keaktifan user yang

terlibat sangat menentukan untuk mencapai hasil yang maksimal, karena user

akan memberikan komentar langsung apabila terdapat ketidaksesuaian pada

desain.

Pada fase ini, penulis akan melakukan beberapa perancangan, seperti

perancangan proses, pemodelan data dan perancangan user interface.

 44

2.8.3. Fase Konstruksi

Pada tahap ini, dilakukan pengkodean terhadap rancangan-rancangan

yang telah didefinisikan dengan baris-baris program. Disini penulis

menggunakan bahasa pemrograman Java. Dan untuk perancangan database,

penulis menggunakan MySQL.

2.8.4. Fase Pelaksanaan

Pada tahap ini dilakukan pengujian terhadap sistem yang telah dibuat.

Dalam penelitian ini, penulis menggunakan metode pengujian black box yaitu

pengujian perangkat lunak dari jalannya aplikasi. Pengujian pertama

dilakukan oleh penulis sebagai pembuat aplikasi dan pengujian kedua

dilakukan oleh user sebagai pengguna aplikasi.

2.9. Bahasa Pemrograman

2.9.1. Java

Java ditemukan oleh James Gosling, Patrick Naughton, Chris Warth,

Ed Frank, dan Mike Sheridan dibawah Sun Microsystem, inc pada 1991.

Bahasa pemrograman ini awalnya diberi nama Oak tapi kemudian diganti Java

pada 1995 (Prasetio, 2010). Sun merilis versi awal Java secara resmi pada awal

tahun 1996 yang kemudian berkembang menjadi JDK 1.1 kemudian JDK 1.2

yang mulai disebut sebagai versi Java2 karena semakin ditingkatkan dan

diperbaiki. Perubahan utama jadi adalah adanya Swing yang merupakan

 45

teknologi GUI (Graphical User Interface) yang mampu menghasilkan window

portable. Hingga saat ini Java sendiri memiliki beberapa edisi untuk keperluan

pengembang perangkat lunak yaitu J2SE, J2EE, J2ME dan yang terakhir

JavaFX.

2.9.2. Karakteristik Java

Sintaks Java merupakan pengembangan dari bahasa C/C++. Berikut

adalah beberapa hal tentang pemrograman Java (Somantri, 2004) :

1. Bersifat portable dan platform independent. Program java yang

telah ditulis akan dapat dieksekusi di mesin ataupun sistem

operasi apapun tanpa harus mengubah sedikitpun dari program

tersebut.

2. Memiliki garbage collection yang dapat mendealokasikan

memori secara otomatis.

3. Menghilangkan pewarisan berganda yang terdapat pada C++

4. Mengurangi pointer aritmetika. Pengaksesan lokasi memori

secara langsung dengan menggunakan pointer memungkinkan

program untuk melakukan suatu tindakan yang tidak seharusnya

atau tidak boleh dilakukan. Untuk mengurangi kemungkinan

kesalahan seperti ini penggunaan pointer pada java telah dibatasi

dengan menggunakan reference.

5. Memiliki array sejati

 46

6. Mengurangi kerancuan antara pemberian nilai pada statement

conditional.

7. Sederhana

8. Free atau bebas license

9. Berkinerja Tinggi

10. Dinamis

2.9.3. Fitur-fitur Java

Beberapa fitur yang ditawarkan Java API (Cahyono, 2006) antara lain

sebagai berikut :

1. Applet

Program Java yang dapat berjalan diatas browser, yang dapat

membuat HTML lebih dinamis dan menarik.

2. Java Networking

Sekumpulan API (Application Programming Interface) yang

menyediakan fungsi-fungsi untuk aplikasi jaringan, seperti

penyediaan akses untuk TCP, UDP, IP Address dan URL. Tetapi

Java Networking tidak menyediakan akses untuk ICMP

dikarenakan security dan pada kondisi umum hanya administrator

(root) yang bisa memanfaatkan protokol ICMP.

 47

3. Java Database Connectivity (JDBC)

JDBC menyediakan kumpulan API yang dapat digunakan untuk

mengakses mengakses database seperti Oracle, MySQL,

PostgreSQL, Microsoft SQL Server.

4. Java Security

Java security menyediakan sekumpulan API untuk mengatur

security dari aplikasi Java baik secara high level atau low level

seperti public/private key management dan certificates.

5. Java Swing

Java swing menyediakan sekumpulan API untuk membangun

aplikasi GUI (Graphical User Interface) dan model GUI yang

diinginkan bisa bermacam-macam, bisa model Java, model

motif/CDE atau model yang dependent terhadap platform yang

digunakan.

6. Java RMI

Java RMI menyediakan sekumpulan API untuk membangun

aplikasi-aplikasi Java yang mirip dengan model RPC.

 48

2.10. MYSQL

MySQL adalah sebuah program database server yang mampu menerima

dan mengirimkan datanya dengan sangat cepat, multi user serta menggunakan

perintah standar SQL (Structure Query Language) (Nugroho, 2005). MySQL

adalah salah satu jenis database server yang sangat terkenal, disebabkan

MySQL menggunakan SQL sebagai bahasa dasar untuk mengakses database.

SQL merupakan bahasa terstruktur yang digunakan untuk interaksi antara script

program dengan database server dalam hal pengolahan data. MySQL pertama

kali dirilis oleh seorang programmer database bernama Michael Widenius.

 BAB III

METODOLOGI PENELITIAN

Pada BAB III ini akan dijelaskan tentang metode penelitian yang terdiri

dari metode pengumpulan data dan pengembangan sistem. Dalam metode

pengumpulan data dilakukan studi literatur dan studi lapangan, sedangkan dalam

pengembangan sistem akan dijelaskan fase-fase pembentuknya. Dalam penelitian ini

penulis menggunakan model proses RAD, dan pada bab ini juga akan dijabarkan

mengenai alasan menggunakan model proses tersebut.

3.1. Metode Pengumpulan Data

Pada bab ini penulis melakukan pengumpulan data atau informasi yang di

perlukan pada penelitian tugas akhir ini. Data yang diperoleh dalam penulisan

ini didapatkan dengan cara sebagai berikut.

3.1.1. Studi Pustaka

Sebagai landasan yang digunakan dalam penulisan tugas akhir ini penulis

memperoleh data atau informasi yang digunakan untuk merancang aplikasi

pemilihan jurusan dengan membaca dan mempelajari literatur, buku-buku dan

browsing di internet yang berhubungan dengan penelitian dan mendukung topik

yang akan dibahas dalam penyusunan skripsi. Sumber data yang dipakai adalah

data-data dari hasil literatur yang penulis dapatkan dari jurnal dan penelitian

49
 50

sejenis yang berhubungan dengan implementasi algoritma K-Means dalam data

mining untuk pemilihan jurusan bagi siswa kelas X SMA.

3.1.2 Interview

Penulis melakukan wawancara dengan Ibu Afrianti Z. Sani, Spd selaku

guru Bimbingan Konseling (BK) dan Ibu Dra.Sri Widayati selaku wali kelas

yang dilakukan di SMA Negeri 29 Jakarta untuk memperoleh informasi dan

data-data yang diperlukan dalam pembuatan aplikasi pada peminatan.

3.1.3. Observasi

Dalam melakukan metode observasi penulis melakukan pengamatan dan

peninjauan langsung untuk mendapatkan informasi dan data siswa kelas X

angkatan 2012/2013 SMA Negeri 29 Jakarta.

3.1.2. Studi Literatur Sejenis

Penulis melakukan evaluasi terhadap pengembangan aplikasi peminatan

yang pernah dibuat sebelumnya. Evaluasi dilakukan dengan studi kasus

terhadap 3 jenis karya ilmiah sejenis sebagai pembanding untuk mengetahui

kelebihan dan kekurangan karya ilmiah dalam pembuatan aplikasi peminatan

yang sudah ada.

Tabel 3.1 Perbandingan Literatur Sejenis

No Judul Nama Peneliti Tahun Kelebihan Kekurangan
Peminatan Siswa Membahas tentang Tidak menggunakan

1 Berdasarkan Minat Ade Amalia Nazri 2011 rekomendasi algoritma dalam

dan Kemampuan peminatan bagi siswa proses perhitungan

 51

Akademik Siswa kelas X SMA melalui nilai akademik siswa.

Berbasis Web proses komputerisasi

 Menggunakan
Penelitian tidak
algoritma Fuzzy
dilakukan sampai
C-Means untuk
tahap pembuatan
menentukan
aplikasi, penulis
jurusan bagi
Penentuan Jurusan hanya menggunakan
siswa kelas X.
Sekolah Menengah
2 Bahar 2011
Atas dengan software matlab
algoritma Fuzzy C-  Memiliki tingkat
Means untuk menguji coba
keakurasian

sekitar 78,39% tingkat akurasi

dengan data algoritma Fuzzy C-

sampel 81 siswa Means

 Penelitian ini

membahas

tentang
Aplikasi K-Means Penelitian tidak
untuk implementasi
pengelompokkan Tedy Rismawan, Sri dilakukan sampai
3 mahasiswa 2008 algoritma K-
berdasarkan nilai Kusumadewi tahap pembuatan
Body Mass Index Means dalam
(BMI) & ukuran aplikasi.
kerangka menentukan

Body Mass

Index (BMI) dan

 52

ukuran kerangka

mahasiswa

 Penelitian ini

menghasilkan

informasi nilai

pusat cluster &

jumlah

mahasiswa pada

BMI Normal &

Kerangka Besar,

BMI obesitas

sedang &

Kerangka

sedang, BMI

obesitas berat &

Kerangka kecil

 Menjelaskan

secara lebih

terperinci cara

menghitung

jarak terhadap

masing-masing

cluster.
 53

3.2. Metode Pengembangan Sistem

Pengembangan sistem dapat diartikan sebagai sebuah proses

pengembangan terstandarisasi yang mendefinisikan satu set aktifitas, metode,

praktik terbaik dan perangkat terotomatisasi yang akan digunakan oleh para

pengembang sistem dan manajer proyek untuk mengembangkan dan

berkesinambungan memperbaiki sistem informasi dan perangkat lunak

(Whitten, 2004). Metode pengembangan sistem yang digunakan penulis dalam

penelitian skripsi ini adalah dengan model RAD (Rapid Application

Development). Model perancangan RAD memiliki empat fase , yaitu fase

perencanaan syarat-syarat, fase perancangan, fase konstruksi, dan fase

pelaksanaan (Kendall & Kendall, 2008). Berikut ini penjelasan masing-masing

fase dalam penelitian ini :

3.2.1. Fase Menentukan Syarat-Syarat

Pada tahap ini dilakukan pengidentifikasian tujuan aplikasi atau sistem

serta untuk mengidentifikasikan syarat-syarat informasi yang ditimbulkan dari

tujuan-tujuan tersebut. Apabila pengetahuan diformulasikan secara lengkap,

maka tahap implementasi dapat dimulai dengan membuat garis besar masalah,

kemudian memecahkan masalah kedalam modul-modul. Orientasi utama dari

fase ini adalah menyelesaikan masalah-masalah yang ada.

 54

Untuk memudahkan, maka harus diidentifikasikan hal-hal berikut ini :

a. Identifikasi masalah

Saat ini SMA 29 Jakarta masih menggunakan sistem perhitungan manual

dalam menentukan proses pemilihan jurusan bagi siswa-siswi kelas X,

sehingga waktu yang diperlukan untuk proses pemilihan jurusan sangat

lama dan kurang efisien.

b. Analisis kebutuhan masalah

Berdasarkan permasalahan yang ada, maka di butuhkan sebuah sistem

yang mudah digunakan dan bisa membantu pihak sekolah untuk proses

menentukan peminatan/pemilihan jurusan bagi siswa kelas X SMA.

c. Tujuan informasi

Berdasarkan permasalahan dan kebutuhan yang telah diuraikan, penulis

bertujuan untuk mengimplementasikan algoritma K-Means pada sistem

pemilihan jurusan bagi siswa kelas X SMA, sehingga diharapkan dapat

mempermudah dan mempercepat proses pemilihan jurusan dengan

menggunakan komputer dan memperoleh hasil yang akurat.

3.2.2. Fase Desain Workshop (Fase Perancangan)

Fase ini adalah fase merancang dan memperbaiki yang bisa digambarkan

sebagai workshop. Pada tahap ini dilakukan perancangan proses, yaitu

perancangan proses-proses yang akan terjadi dalam sistem.

 55

a. Perancangan Proses

Pada tahap ini dilakukan perancangan proses implementasi algoritma K-

Means dalam Data Mining untuk Pemilihan Jurusan bagi Siswa Kelas X

SMA secara konseptual menggunakan usecase digram, class diagram,

activity diagram, sequence diagram.

b. Pemodelan Data

Dalam tahap ini dibuat perancangan basis data. Perancangan tabel-tabel

yang akan digunakan untuk pengolahan data (input data). Dan kemudian

akan diimplementasikan database tersebut kedalam bentuk program.

c. Perancangan Antar muka Pemakai (User Interface)

Antar muka pemakai memberikan fasilitas komunikasi antar pemakai dan

sistem, memberikan berbagai fasilitas informasi dan berbagai keterangan

yang bertujuan untuk membantu mengarahkan alur penelusuran masalah

sampai ditemukannya solusi. Antar muka dirancang sebagai gambaran

pada saat pembuatan sistem pada fase konstruksi.

3.2.3. Fase Konstruksi

Pada tahap ini, dilakukan pengkodean terhadap rancangan-rancangan

yang telah didefinisikan dengan baris-baris program. Disini penulis

menggunakan bahasa pemrograman Java, dan untuk database penulis

menggunakan MySQL. Program dalam sistem ini terdiri dari :

 56

1. Transaction program adalah program-program untuk melakukan tugas

penanganan akses data ke atau dari database, seperti menambah data

(add/create), melihat data (view), dan menghapus data (delete).

2. Proses program adalah program-program yang melakukan tugas-tugas

(proses) tertentu, misalnya proses laporan peminatan.

3.2.4. Fase Pelaksanaan

Pada tahap ini dilakukan pengujian terhadap sistem yang telah dibuat.

Dalam penelitian ini penulis menggunakan metode pengujian black box. Black

box testing merupakan suatu pengujian perangkat lunak tentang cara

pengoperasian, serta apa input dan output yang dihasilkan sistem.

3.3. Alasan Menggunakan RAD

Dari lima macam model-model perangkat lunak yang dikemukakan oleh Roger

S. Pressman, yaitu Model Sekuensial Linear, Model Prototype, Model RAD

(Rapid Application Development), Model Evolusioner, Model Formal, penulis

memlih model RAD sebagai metode pengembangan sistem dengan alasan

berikut :

1. Salah satu fase dalam model sekuensial adalah fase pemeliharaan

(Pressman, 2002). Aplikasi yang akan dibuat ini tidak memerlukan fase

pemeliharaan dalam pengimplementasiannya.

 57

2. Dengan menggunakan metode RAD akan dicapai suatu sistem fungsional

yang utuh dalam periode waktu yang sangat pendek jika kebutuhan dapat

dipahami dengan baik (Pressman, 2002)

3. Kekurangan dalam metode formal lainnya adalah banyak memakan

waktu dan biaya (Pressman, 2002) karena aplikasi yang akan dibuat

adalah aplikasi sederhana.

4. Aplikasi ini tidak memerlukan tahapan yang panjang. Hal ini tidak sesuai

dengan model spiral yang merupakan salah satu model evolusioner yang

memiliki waktu yang cukup panjang dalam pengembangan software

(Proboyekti, 2004).
 58

3.4. Alur Kerangka Penelitian

Gambar 3.2 Alur Kerangka

 BAB IV

HASIL DAN PEMBAHASAN

Bab ini berisi penjelasan mengenai proses atau tahapan-tahapan dalam membangun

aplikasi implementasi algoritma K-Means dalam data mining untuk peminatan bagi

siswa SMA serta perangkat pendukung perancangan tersebut. Tahapan perancangan

aplikasi dimulai dari fase perencanaan syarat-syarat (proses requirements gathering

atau pengumpulan data), fase perancangan (perancangan aplikasi), fase konstruksi

(pengkodingan) dan fase pelaksanaan (uji coba aplikasi).

4.1. Profil Umum SMA Negeri 29 Jakarta

4.1.1. Sejarah Singkat SMA Negeri 29 Jakarta

Pada awal bulan September 1966, atas prakarsa Bapak Camat Kebayoran

Lama yang pada saat itu dijabat oleh M.T. Koesnadi, merasa tergugah serta

terpanggil untuk mendirikan dan merintis sebuah lembaga pendidikan tingkat

atas yang berada di wilayah Kebayoran Lama, yang pada saat itu belum ada

sekolah setingkat SLTA. Sehingga dengan adanya sekolah ini akan

mempermudah bagi siswa SLTP untuk melanjutkan ke jenjang SLTA tanpa

mengeluarkan biaya tinggi dan jauh dari domisili tempat tinggalnya. Setelah

melalui beberapa kali proses konsultasi dengan para tokoh pendidik dan ulama

serta bekerja sama dengan SMA VI Bulungan Jakarta Selatan, maka akhirnya

pada tanggal 5 Januari 1967 berhasil didirikan SMA VI Filial di Kebayoran

59
 60

Lama yang dipimpin oleh Drs. Sunardi dengan menempati gedung bekas SD Sie

Ming Wie di Jalan Kebayoran Lama. Pada saat kunjungan kerja Bapak Gubernur

DKI Ali Sadikin ke Kebayoran Lama, beliau sangat memperhatikan akan kesulitan

tidak adanya sekolah setingkat SLTA di wilayah Kebayoran Lama. Kemudian beliau

menginstruksikan kepada bawahannya untuk segera membongkar gedung SD tersebut

diperuntukan SLTP dan SLTA untuk sementara waktu, disusul instruksi segera

membangun gedung baru baru bagi SMA VI Filial pada sebidang tanah seluas

3800m2 dekat Komplek Polri di Jalan Kramat No. 6, Kebayoran Lama, Jakarta

Selatan. Pada tahun 1973, SMA VI Filial yang merupakan cabang dari SMA VI

Bulungan, akhirnya tepat pada bulan Juni 1973 melepaskan diri dari induknya dan

statusnya menjadi SMA 29 Jakarta.

4.1.2. Struktur Organisasi SMA Negeri 29 Jakarta

Gambar 4.1 Struktur Organisasi SMA N 29

 61

4.1.3. Visi dan Misi SMA Negeri 29 Jakarta

Visi dan Misi SMA Negeri 29 Jakarta adalah :

a. Visi SMA Negeri 29 Jakarta

Mewujudkan Institusi Pendidikan Berkualitas Berlandaskan

Keimanan dan Ketaqwaan Kepada Tuhan Yang Maha Esa yang

Unggul dalam IPTEK, Berpretasi Tinggi, dan Siap berkompetisi

dalam Era Globalisasi

b. Misi SMA Negeri 29 Jakarta :

 Meningkatkan keselarasan kemampuan intelektual, emosional

dan spiritual untuk mewujudkan situasi yang kondusif terhadap

terwujudnya tujuan pendidikan nasional.

 Menyelenggarakan ibadah keagamaan dalam meningkatkan

ketaqwaan guna membentuk anak didik yang bermartabat.

 Disiplin dalam bertindak

 Meningkatkan kemampuan IPTEK di lingkungan sekolah.

 Meningkatkan kemampuan berbahasa asing.

 Meningkatkan prestasi akademik dan non akademik.

 Melestarikan 5 S (salam, sapa, senyum, sopan dan santun) dan

7K (keamanan, kebersihan, keindahan, kekeluargaan,

kenyamanan dan kerindangan).

 Menghasilkan lulusan yang berakhlak dan berilmu.

 62

4.2. Metode Pengumpulan Data

Untuk mengumpulkan data-data dari sampel penelitian, dilakukan dengan

berbagai metode tertentu sesuai dengan tujuan penelitiannya. Ada berbagai metode

yang telah kita kenal antara lain wawancara dan studi pustaka. Metode pengumpulan

data yang digunakan dalam penelitian ini adalah :

4.2.1. Studi Pustaka

Data–data dan informasi yang di gunakan berupa buku referensi, hasil

penelitian sejenis dengan penelitian implementasi algoritma k-means dalam

sistem peminatan pada SMA yang akan dibuat, jurnal-jurnal hasil penelitian dan

situs internet yang dapat dijadikan acuan pembahasan dalam masalah ini.

4.2.2. Wawancara/Interview

Wawancara ini dilakukan dengan cara melakukan diskusi dengan Ibu

Afrianti Z. Sani, Spd selaku guru Bimbingan Konseling (BK), pada tanggal 13

Juni 2013, bertempat di ruang Bimbingan Konseling (BK) dan dengan Ibu

Dra.Sri Widayati selaku walikelas di SMA Negeri 29 Jakarta. Wawancara ini

berguna untuk memperoleh data-data yang diperlukan dalam perancangan

sistem.

Hasil dari wawancara menyatakan bahwa proses peminatan masih dilakukan

secara manual dimana walikelas menghitung rata-rata nilai akademik siswa

yang kemudian disesuaikan dengan minat siswa tersebut. Karena hal tersebut

kurang efisien, maka diusulkan pembuatan aplikasi pendukung peminatan.

 63

Dimana pada aplikasi peminatan tersebut, disesuaikan dari nilai akademik,

minat siswa, hasil cluster dan ketentuan yang telah ditetapkan, dimana batasan

nilai untuk tiap minat/jurusan bukan dari nilai rata-rata siswa. Syarat tiap

peminatan berbeda-beda, untuk peminatan IPA nilai minimum untuk tiap mata

pelajaran IPA adalah 78 dan untuk peminatan IPS nilai minimum untuk tiap

mata pelajaran IPS nya adalah 78. Siswa diperbolehkan memiliki memiliki 1

nilai mata pelajaran dibawah nilai minimum, dan jika lebih dari 1 nilai mata

pelajaran yang dibawah nilai minimum, maka siswa tersebut tidak lulus

peminatan yang diinginkan dan akan masuk ke dalam peminatan IPS.

4.2.3. Observasi

Observasi dilakukan penulis dengan melakukan pengamatan langsung

pada SMA Negeri 29 Jakarta, Jl. Kramat No. 6 Kebayoran Lama, Jakarta

Selatan selama 2 bulan, terhitung dari 15 Mei – 30 Juli 2013. Kegiatan ini

dilakukan untuk mengetahui masalah apa saja yang dialami oleh SMA Negeri

29 Jakarta. Hasil dari observasi ini, penulis menerima 253 data siswa kelas X,

dari kelas X-1 sampai X-7 yang berisikan minat yang diinginkan beserta nilai

akademik yang nantinya akan diproses pada aplikasi ini.

4.2.4. Studi Literatur Sejenis

Berdasarkan hasil dari studi literatur sejenis yang digunakan oleh

penulis maka didapat beberapa informasi pendukung dan pembanding dalam

penelitian ini yang dapat dijadikan sebagai bahan acuan untuk meningkatkan
 64

kelebihan penelitian ini. Adapun perbedaan yang dapat dideskripsikan dalam

penelitian ini antara lain, yaitu:

1. Menggunakan algoritma K-Means dalam proses penghitungan

kluster terhadap nilai akademik siswa.

2. Menggunakan matriks konfusi untuk mengukur tingkat akurasi

algoritma K-Means.

3. Melakukan proses cleaning sehingga terhadap data nilai akademik

siswa sehingga tingkat akurasi menjadi lebih tinggi dikarenakan

data training dan test tidak memiliki nilai kosong.

4. Membangun aplikasi tersendiri yang mengimplementasikan

algoritma K-Means sehingga proses klustering menjadi lebih

terperinci untuk atribut yang telah disediakan. Aplikasi yang dibuat

cukup sederhana sehingga lebih mudah dipakai.

5. Membagi menjadi dua menu yaitu admininstrator dan user.

 65

4.3. Metode Pengembangan Sistem

Dalam penyusunan laporan penelitian ini, penulis menggunakan metode

pengembangan sistem RAD (Rapid Application Development), dan pemodelan objek

dengan mengunakan tools UML. Sepeti yang telah dijelaskan pada bab sebelumnya,

metode ini merupakan suatu pendekatan berorientasi objek yang menekankan pada

siklus pengembangan yang pendek/singkat dengan menerapkan component based

construction. Tahapan metodologi pengembangan sistem dengan Rapid Application

Development yang dilakukan adalah sebagai berikut :

4.3.1. Fase Menentukan Syarat-Syarat

4.3.1.1. Analisis Kebutuhan Masalah

Menganalisis kebutuhan sistem adalah menganalisis maksud,

tujuan dan sasaran sistem. Pada tahap ini, penulis melakukan

pengamatan lapangan pada SMA Negeri 29 Jakarta dan melakukan

wawancara langsung kepada guru Bimbingan Konseling (BK) dan wali

kelas SMA Negeri 29 Jakarta.

Dari hasil observasi dan wawancara yang dilakukan, maka

penulis dapat menganalisis bahwa belum efektifnya pemanfaatan

teknologi untuk proses peminatan pada siswa kelas X SMA Negeri 29

Jakarta. Pihak sekolah khususnya wali kelas masih menggunakan sistem

peminatan secara manual dalam menghitung nilai akademik masing-

masing siswa, kemudian mengelompokkan siswa ke dalam kelompok

 66

minat IPA atau IPS jika hasil nilai akademik yang dimiliki siswa

tersebut sudah sesuai dengan kriteria peminatan siswa yang diterapkan

oleh SMA Negeri 29 Jakarta. Untuk membantu permasalahan tersebut,

penulis menerapkan salah satu tugas dari teknologi data mining yaitu

clustering untuk proses peminatan jurusan bagi siswa kelas X. Untuk

proses pengklasteran, penulis menggunakan algoritma K-Means.

Menurut Ediyanto dan rekan (2013) algoritma K-Means cukup efektif

diterapkan dalam proses pengelompokkan karakteristik terhadap objek

penelitian.

4.3.1.2. Mendefinisikan Masalah

Tahap mendefinisikan masalah adalah tahap menentukan

masalah apa yang harus diselesaikan dengan menggunakan sistem

aplikasi yang akan dibuat (Kendall & Kendall, 2006).

Masalah yang harus diselesaikan dengan sistem ini adalah bagaimana

membuat aplikasi peminatan siswa dengan mengimplementasikan

algoritma k-means dalam data mining yang berbasis java dan terhubung

dengan database sehingga dapat membantu pihak sekolah dalam

menentukan minat siswa kelas X.

4.3.1.3. Tujuan Informasi

Berdasarkan aturan pada pendefinisian kebutuhan diatas, maka

penulis bertujuan untuk mengimplementasikan algoritma k-means dalam

 67

teknik data mining untuk peminatan bagi siswa kelas X sesuai dengan

nilai akademik siswa, dan diharapkan dapat membantu pihak sekolah

untuk mengetahui hasil peminatan siswa kelas X dengan lebih mudah

dan tepat.

Penulis bermaksud mengusulkan aplikasi untuk peminatan bagi

siswa SMA kelas X menggunakan bahasa pemrograman Java. Bahasa

pemrograman Java dipilih oleh penulis karena bahasa pemrograman

Java lebih mudah untuk di gunakan dalam berbagai jenis komputer

maupun sistem operasi, sehingga memudahkan pihak sekolah untuk

menggunakan aplikasi ini. Usulan aplikasi yang dimaksud adalah

sebagai berikut :

1. Aplikasi berupa simulasi peminatan bagi siswa SMA kelas

X dengan mengolah data nilai akademik siswa

menggunakan algoritma k-means.

2. Pembuatan menu peminatan digunakan untuk melakukan

proses penghitungan nilai akademik siswa dengan

menerapkan fungsi algoritma k-means dalam teknik data

mining.

3. Pembuatan aplikasi ini didukung oleh bahasa pemrograman

Java agar mudah untuk di gunakan pada komputer yang

tersedia di SMA 29 Jakarta.

 68

4.3.1.4. Syarat-Syarat Informasi

Pembuatan aplikasi peminatan bagi siswa SMA kelas X harus

memenuhi syarat-syarat yang meliputi kelengkapan data, software dan

hardware.

1. Kelengkapan Data

a. Hasil Wawancara

Penulis melakukan wawancara terhadap guru BK

dan salah satu wali kelas SMA Negeri 29 Jakarta.

Melalui hasil wawancara ini diketahuilah bahwa

pihak sekolah masih kesulitan dalam proses

peminatan bagi siswa kelas X. Hasil wawancara

terlampir.

b. Data Siswa dan Nilai Akademik

Data nilai akademik siswa kelas X semester genap

diperoleh dari hasil observasi langsung ke

lapangan. Penulis mendapatkan 253 data siswa dari

7 kelas yang ada. Nilai akademik yang diperoleh

adalah nilai Agama, PPKn, Bahasa Indonesia,

Matematika, Bahasa Inggris, Kimia, Fisika, Biologi,

Sejarah, Ekonomi, Sosiologi, Geografi, Seni, Pend.

 69

Jasmani, Bahasa Jepang, TIK, Elektronika semester

genap.

2. Kelengkapan Software yang digunakan

a. Sistem Operasi Windows (Minimal Windows XP

SP 3)

b. JDk versi 7 sebagai Java Platform

c. Netbeans IDE versi 7.01 sebagai editor program

dalam proses pengkodean (coding) aplikasi.

d. Xampp versi 1.4.16 untuk database MYSQL

3. Kelengkapan Hardware yang digunakan

a. Satu buah PC dengan spesifikasi sebagai berikut :

1) Processor 1.6GHz

2) Memory 2GB

3) Harddisk 320 GB

4) Monitor

5) Keyboard

6) Mouse

b. Printer

4.3.1.5. Knowledge Discovery in Database

Data yang digunakan dalam penelitian ini adalah data siswa dan nilai

akademik siswa kelas X semester 2. Data didapat dari hasil observasi

 70

langsung ke SMA Negeri 29 Jakarta. Data hasil penelitian akan

disimpan ke dalam database yang digunakan data testing penelitian.

Data yang didapat merupakan data mentah yang masih memiliki

redudansi data, kesalahan dan kekosongan data. Data-data tersebut

terdiri dari 8 atribut variabel uji seperti nilai Matematika, Fisika, Kimia,

Biologi, Sejarah, Geografi, Ekonomi dan Sosiologi.

Data yang tidak lengkap dan inkonsisten sering terjadi pada database,

data yang tidak lengkap dapat disebabkan oleh berbagai sebab, seperti

field yang tidak terisi dengan data yang sesuai dengan atribut.

Demikian pula dengan database data siswa dan nilai akademik siswa,

ada sebagian field yang tidak terisi dengan atribut yang sesuai, untuk

mengurangi hal tersebut maka dilakukan tahap Knowledge Discovery in

Database (KDD) agar database sesuai dengan ketentuan yang

diperlukan oleh aplikasi.

Tahap-tahap Knowledge Discovery in Database (KDD) adalah sebagai

berikut :

a. Data Cleaning

Tahap pertama yang dilakukan dalam teknik data mining adalah

proses data cleaning. Penulis akan menghilangkan data-data atau

nilai akademik siswa yang tidak terpakai, seperti nilai mata

 71

pelajaran selain Matematika, Fisika, Kimia, Biologi, Sejarah,

Geografi, Ekonomi, dan Sosiologi.

b. Data Integration

Tahap data integration ini mengkombinasikan berbagai sumber

data yang ada.

c. Data Transformation

Dalam proses ini, data ditransformasikan ke dalam bentuk yang

sesuai untuk proses clustering dalam data mining. Nilai yang

ditransformasikan adalah nilai yang berasal dari atribut „C1‟ dan

„C2‟.

Jarak dengan pusat cluster dijadikan dasar untuk menentukan

peminatan. Jika jarak terhadap C1 lebih kecil dari jarak terhadap

C2 maka siswa tersebut masuk kelompok peminatan IPA.

Jika jarak terhadap C2 lebih kecil dari jarak terhadap C1 maka

siswa tersebut masuk kelompok peminatan IPS.

4.3.1.6. Penerapan algoritma K-Means dalam Data Mining

Secara umum algoritma K-Means sering digunakan untuk

mengklaster jumlah data yang banyak secara cepat. Algoritma K-Means

pada awalnya mengambil sebagian dari banyaknya komponen dari

populasi untuk dijadikan pusat cluster awal. Pada step ini pusat cluster

dipilih secara acak dari sekumpulan populasi data. Berikutnya K-Means

 72

menguji masing-masing komponen didalam populasi data dan menandai

komponen tersebut ke salah satu pusat cluster yang telah di definisikan

tergantung dari jarak minimum antar komponen dengan tiap-tiap pusat

cluster. Posisi pusat cluster akan dihitung kembali sampai semua

komponen data digolongkan kedalam tiap-tiap cluster dan terakhir akan

terbentuk posisi cluster baru.

Proses Clustering Algoritma K-Means :

Pada tahap ini akan dilakukan proses utama yaitu segmentasi data nilai

yang diakses dari database yaitu sebuah metode clustering algoritma K-

Means. Berikut ini merupakan diagram flowchart dari algoritma K-

Means dengan asumsi bahwa parameter Input adalah jumlah data set

sebanyak n data dan jumlah inisialisasi centroid K=2 sesuai dengan

jumlah jurusan yang ada di SMA 29 Jakarta yaitu IPA dan IPS.

Pada diagram flowchart pada gambar 3.2 dapat dijelaskan beberapa

langkah yang dilalui oleh clustering algoritma K-Means memuat bagian-

bagian sebagai berikut ini :

1. N data : data set yang akan diolah sebanyak N data dimana

N data tersebut terdiri dari atribut-atributnya

N(Matematika, Fisika, Kimia, Biologi, Sejarah, Geografi,

Ekonomi, Sosiologi) yang berarti data N memiliki atribut

sebanyak 8.
 73

2. K centroid : Inisialisasi dari pusat cluster data adalah

sebanyak K dimana pusat-pusat awal tersebut digunakan

sebagai banyaknya kelas yang akan tercipta. Centroid

didapatkan secara random dari N data set yang ada dengan

syarat nilai minimal 78 untuk masing-masing mata

pelajaran pada kelompok peminatan IPA dan kelompok

peminatan IPS.

3. Euclidian Distance: merupakan jarak yang didapat dari

perhitungan antara semua N data dengan K centroid

dimana akan memperoleh tingkat kedekatan dengan kelas

yang terdekat dengan populasi data tersebut.

Jarak euclidian untuk menandai adanya persamaan antar

tiap cluster dengan

jarak minimum dan mempunyai persamaan yang lebih

tinggi.

Cij : Titik Data Pertama

Ckj : Titik Data Kedua
Dik : Euclidian distance yaitu jarak antara data
pada titik x dan titik y menggunakan kalkulasi
matematika
 74

4. Pengelompokkan data: setelah sejumlah populasi data

tersebut menemukan kedekatan dengan salah satu centroid

yang ada maka secara otomatis populasi data tersebut

masuk kedalam kelas yang memiliki centroid yang

bersangkutan.

5. Update centroid baru: tiap kelas yang telah tercipta tadi

melakukan update centroid baru. Hal ini dilakukan dengan

menghitung nilai rata-rata dari kelas masing-masing.

Apabila belum memenuhi optimal hasil proses pengukuran

ecluidian distance dilakukan kembali.

6. Batas iterasi: apabila dalam proses clustering belum

optimal namun sudah memenuhi batas iterasi maksimum,

maka proses dihentikan.

 75

Gambar 4.2 Flowchart K-Means

 76

b. Berikut ini contoh dari fungsi algoritma k-means yang penulis

gunakan :

Dari banyak siswa diambil 12 siswa sebagai contoh untuk penerapan

algoritma k-means dalam peminatan siswa. Percobaan dilakukan dengan

menggunakan parameter-parameter berikut :

Jumlah cluster : 2

Jumlah data :12

Jumlah atribut :8

Tabel 4.1 merupakan data yang digunakan untuk melakukan percobaan

perhitungan manual.

Tabel 4.1 Daftar Nilai

NO NIS NAMA MTK Fisika Biologi Kimia Sejarah Geografi Ekonomi Sosiologi
1 16705 ABRAR 79 75 75 85 76 78 76 80
SUMANGERUKKA
SUWANDAKUSUMAH
2 16706 ADZKIA 84 76 79 77 76 77 75 81
RAHMATILLAH
3 16707 AHMAD RISQI 77 84 78 85 92 89 77 82
SABILAL RASYAD
4 16708 AMBAR 78 86 84 77 78 77 75 75
PURWANTININGSIH
5 16709 ANDIKA SYAHALAM 82 82 81 91 90 82 79 91

6 16515 ANGGIE SURYO 75 75 70 82 75 75 79 75

PRAKOSO
7 16710 ANISAH DIYANTI 77 75 75 89 80 80 75 75

8 16711 ARIANSYAH 77 76 70 77 77 80 75 80
PRABOWO
9 16712 AUDI NADYA 79 76 75 84 77 81 76 77
 77

10 16717 DIMAS MURYA 80 75 75 75 75 78 77 79

PERDANA
11 16718 ELISABETH GULTOM 76 71 75 75 77 81 79 84

12 16719 GALUH ADE YOSHE 80 77 75 78 78 77 77 80

Iterasi ke-1

1. Penentuan pusat awal cluster

Untuk penentuan awal di asumsikan:

Diambil data ke- 2 sebagai pusat Cluster Ke-1: (84, 76, 79, 77, 76, 77, 75, 81)

dengan batas nilai minimal 75 untuk mata pelajaran Matematika, Fisika,

Biologi, Kimia.

Diambil data ke- 5 sebagai pusat Cluster Ke-2: (82, 82, 81, 91, 90, 82, 79, 91)

dengan batas nilai minimal 75 untuk mata pelajaran Sejarah, Geografi,

Ekonomi, Sosiologi.

2. Perhitungan jarak pusat cluster

Untuk mengukur jarak antara data dengan pusat cluster digunakan Euclidian

distance, kemudian akan didapatkan matrik jarak sebagai berikut :

Rumus Euclidian distance :

Cij : Pusat Cluster

Ckj : Data

Sebagai contoh, perhitungan jarak dari data ke-1 terhadap pusat cluster adalah :
 78

Dan seterusnya dilanjutkan untuk data ke 2, 3, … n

Kemudian akan didapatkan matrik jarak sebagai berikut :

1 2 3 4 5 6 7 8 9 10 11 12

10.4 0 24.1 14.1 24.02 15.6 16.4 11.8 11,1 6,8 12,2 6,5 C1

21.7 24.02 14.5 26.03 0 28.8 22.1 26.2 22,4 27,09 25,8 22,9 C2

Setiap kolom pada matrik menunjukkan nilai jarak data terhadap pusat cluster. Baris

pertama pada matrik menunjukkan nilai jarak data terhadap titik pusat cluster pertama,

baris kedua pada matrik menunjukkan nilai jarak data terhadap titik pusat cluster kedua

dan seterusnya.

3. Pengelompokkan data

Jarak hasil perhitungan akan dilakukan perbandingan dan dipilih jarak terdekat antara

data dengan pusat cluster, jarak ini menunjukkan bahwa data tersebut berada dalam

satu kelompok dengan pusat cluster terdekat. Berikut ini akan ditampilkan data

matriks pengelompokkan group, nilai 1 berarti data tersebut berada dalam group.
 79

1 2 3 4 5 6 7 8 9 10 11 12

1 1 0 1 0 1 1 1 1 1 1 1 C1

0 0 1 0 1 0 0 0 0 0 0 0 C2

Keterangan :

Jika jarak data ke-1 (D1) dengan pusat cluster ke-1 (C1) atau pusat cluster ke-2 (C2)

lebih dekat, maka G1 bernilai 1 dan termasuk grup atau kelompok cluster baru.

Jika jarak data ke-1 (D1) dengan pusat cluster ke-1 (C1) atau pusat cluster ke-2 (C2)

lebih jauh, maka G1 bernilai 0 dan tidak termasuk grup atau kelompok cluster baru.

4. Penentuan pusat cluster baru

Setelah diketahui anggota tiap-tiap cluster kemudian pusat cluster baru dihitung

berdasarkan data anggota tiap-tiap cluster sesuai dengan rumus pusat anggota cluster.

Sehingga didapatkan perhitungan sebagai berikut :

Karena C1 memiliki 10 anggota maka perhitungan cluster baru menjadi :

C1 =

C1 = (79.5; 83; 79.5; 88; 91; 85.5; 78; 86.5)

 80

Karena C2 hanya mempunyai 2 anggota maka cluster baru menjadi :

C2=

C2 = (78.5; 76.2; 75.3; 79.9; 76.9; 78.4; 76.4; 78.6)

Iterasi ke-2

5. Ulangi langkah ke 2 (kedua) hingga posisi data tidak mengalami perubahan.

1 2 3 4 5 6 7 8 9 10 11 12

5,5 7,9 21,1 14,08 23,3 9 10,6 6,7 5,1 5,6 10 3,4 C1

20,5 22,9 7,2 23,13 7,2 26,6 19,5 23,3 19,8 24,9 23,8 21 C2

Langkah selanjutnya sama dengan langkah pada nomor 3 jarak hasil perhitungan

akan dilakukan perbandingan dan dipilih jarak terdekat antara data dengan pusat

cluster, jarak ini menunjukkan bahwa data tersebut berada dalam satu kelompok

dengan pusat cluster terdekat. Berikut ini akan ditampilkan data matriks

pengelompokkan group, nilai 1 berarti data tersebut berada dalam group.

1 2 3 4 5 6 7 8 9 10 11 12

1 1 0 1 0 1 1 1 1 1 1 1 C1

0 0 1 0 1 0 0 0 0 0 0 0 C2
 81

Karena G2 = G1 memiliki anggota yang sama maka tidak perlu dilakukan iterasi /

perulangan lagi. Hasil clustering telah mencapai stabil dan konvergen.

4.3.2. Desain Workshop (Fase Perancangan)

Desain sistem dirancang sebagai penggambaran model sistem untuk

mendokumentasikan aspek teknis dan implementasi dari sebuah sistem yang

akan dibangun (Whitten et.al, 2004).

Pada tahap ini, akan di buat desain sistem dari sistem yang akan dibangun,

meliputi perancangan sistem, perancangan database, dan perancangan layout

aplikasi. Proses desain akan menggunakan perancangan sistem notasi UML dan

database yang digambarkan dalam Rational Rose sebagai tool sistem design.

4.3.2.1. Perancangan Use Case Diagram

Use case diagram di bawah ini yaitu menggambarkan mengenai

interaksi antara sistem, eksternal sistem dan user.

Adapun langkah-langkah dalam membuat use case diagram yaitu sebagai

berikut :

a. Identifikasi Aktor

Tabel 4.2 Identifikasi aktor

No. Aktor Deskripsi
1. Admin Administrator dari suatu instansi yang menggunakan sistem

implementasi algoritma K-Means dalam data mining untuk peminatan

siswa kelas X. Admin juga mengatur siapa saja yang berhak

menggunakan sistem ini. Dalam hal ini adalah pegawai akademik.

 82

2. User User adalah guru yang bertugas untuk meng Input data & nilai siswa,

sekaligus menentukan peminatan bagi siswa kelas X sesuai hasil

perhitungan nilai akademik dan minat siswa.

b. Identifikasi Use Case

Tabel 4.3 Identifikasi Use Case

No. Use case Name Deskripsi Aktor
1. Log In Use case menggambarkan kegiatan memasukkan Semua Aktor

username dan password untuk mengakses sistem.

2 Input User Use case yang digunakan untuk menambah user Admin (Pegawai

baru, berikut username, password dan level user. Akademik)

3 Ubah User Use case menggambarkan kegiatan mengubah Admin (Pegawai

username dan password pengguna sistem yang Akademik)

sedang login.

4 Lihat Siswa Use case yang digunakan untuk melihat data siswa Admin (Pegawai

(Admin) dan mencetak laporan data siswa dalam bentuk .pdf Akademik)
 83

5 Lihat Nilai Use case yang digunakan untuk melihat nilai siswa Admin (Pegawai

dan mencetak laporan nilai siswa dalam bentuk .pdf Akademik)

6 Input Kelas Usecase yang digunakan untuk menambah kelas Admin (Pegawai

baru Akademik)

7 Ubah Kelas Use case yang digunakan untuk mengubah data Admin (Pegawai

kelas Akademik)

8 Lihat Hasil Use case yang digunakan untuk melihat hasil Admin (Pegawai

Peminatan peminatan siswa dan mencetak laporan laporan Akademik)

(Admin) hasil peminatan siswa dalam bentuk .pdf

9 Input Data Use case yang digunakan untuk menambah data User

Siswa siswa baru

10 Lihat Siswa Use case yang digunakan untuk melihat data siswa, User

(User) cari data siswa, mengubah data siswa, menghapus

data siswa dan cetak data siswa.

11 Input Nilai Use case yang digunakan untuk menambah nilai User

Siswa siswa sesuai data siswa yang telah di Input

sebelumnya.

12 Lihat Nilai Use case yang digunakan untuk melihat data nilai User

(User) siswa, cari data nilai siswa, mengubah data nilai

siswa, menghapus data nilai siswa dan cetak data

 84

nilai siswa.

13 Peminatan Use case digunakan untuk melihat hasil peminatan User

(User) dan hasil konsentrasi peminatan. Dalam tab hasil

peminatan, user dapat melihat berapa banyak siswa

yang berada di kelompok peminatan IPA dan

berapa banyak di kelompok peminatan IPS. Dalam

tab hasil konsentrasi peminatan, user dapat

mencetak hasil peminatan serta mengetahui hasil

cluster dari nilai akademik siswa. Dan tab

pengujian, user dapat melihat perbandingan hasil

penghitungan k-means dan manual serta dapat

mencetak hasil pengujian dalam bentuk .pdf.

14 Log Out Use case yang menggambarkan kegiatan keluar Semua aktor

dari sistem.
 85

c. Use Case Diagram

System

Login

<<include>> input user

User edit user delete user

<<include>> lihat user <<include>>

Siswa <<include>> lihat data siswa <<include>> cetak laporan siswa

Nilai <<include>> lihat nilai siswa <<include>> cetak laporan nilai

Admin
<<include>> input kelas
Kelas
<<include>> lihat kelas

lihat hasil cetak laporan

Peminatan <<include>>
peminatan
<<include>>
hasil peminatan

Logout

Login
<<include>> input data siswa
edit data hapus data cetak data cari data

Siswa <<include>> lihat data siswa <<include>>

User <<include>> input nilai

edit data hapus data cetak data cari nilai

Nilai <<include>> lihat nilai <<include>>

<<include>> hasil peminatan

peminatan hasil konsentrasi cetak laporan

<<include>> <<include>>
peminatan peminatan

cetak laporan
<<include>> hasil pengujian <<include>>
peminatan

Logout

Gambar 4.3 Use Case Diagram

 86

d. Narasi Use Case Diagram

1. Narasi Use Case Diagram Login

Tabel 4.4 Deskripsi Use Case Login

Use case Name Login

Use case Id 1

Aktor Semua Aktor

Deskripsi Use case menggambarkan kegiatan memasukkan username dan password

untuk mengakses sistem

Precondition Semua aktor memasukkan username dan password untuk dapat masuk

kedalam sistem

Typical Course of Aktor Action Sistem Response

Events

1. Input Username dan Password 2. Cek Username dan password

3. Menampilkan halaman sesuai

authentifikasi

Alternate Courses 2: Jika Username dan Password benar maka langsung masuk kedalam sistem.

Jika Username dan password salah maka akan menampilkan pesan kesalahan.

Conclusion Semua Aktor Login ke dalam sistem

Post Condition Sistem berhasil diakses

 87

2. Narasi Use Case Diagram Input User

Tabel 4.5 Deskripsi Use Case Input User

Use case Name Input data user

Use case Id 2

Aktor Admin

Deskripsi Use case menggambarkan kegiatan menambah user baru

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response

1. Tekan tombol Input 2. Menampilkan form user baru

data user

3. Mengisi form user 4. Menyimpan data user yang baru

baru diInput

Alternate Courses -

Conclusion Data user telah berInput

Post Condition Data user baru berhasil disimpan

 88

3. Narasi Use Case Diagram Lihat User

Tabel 4.6 Deskripsi Use Case Input User

Use case Name Lihat Data User

Use case Id 3
Aktor Admin
Deskripsi Use case menggambarkan kegiatan melihat, ubah dan hapus user

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol lihat 2. Menampilkan tabel user yang
user sebelumnya sudah disimpan
3. Pilih salah satu user 4. Muncul form ubah user
yang hendak di ubah
datanya
5. Isi form ubah dengan 6. Menyimpan data user yang telah
data baru yang hendak diubah
di ubah
-
Data user telah berubah
Data user baru berhasil disimpan
 89

4. Use Case Diagram Lihat Siswa

Tabel 4.7 Deskripsi Use Case Lihat Siswa

Use case Name Lihat Data Siswa

Use case Id 4
Aktor Admin
Deskripsi Use case menggambarkan kegiatan melihat data siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol Siswa 2. Menampilkan tabel data siswa yang
dan Pilih Lihat Siswa sebelumnya telah disimpan
3. Klik Cetak 4. Muncul data siswa dalam bentuk
.pdf
-
Data siswa bisa dilihat
Data siswa bisa di cetak dalam bentuk .pdf
 90

5. Use Case Diagram Lihat Nilai Siswa

Tabel 4.8 Deskripsi Use Case Lihat Nilai Siswa

Use case Name Lihat Nilai Siswa

Use case Id 5
Aktor Admin
Deskripsi Use case menggambarkan kegiatan melihat nilai siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response
1. Tekan tombol Nilai 2. Menampilkan tabel nilai siswa yang
dan Pilih Lihat Nilai sebelumnya telah disimpan
Siswa
3. Klik Cetak 4. Muncul nilai siswa dalam bentuk
.pdf
Alternate Courses -
Conclusion Data nilai siswa bisa dilihat
Post Condition Data nilai siswa bisa di cetak dalam bentuk .pdf
 91

6. Use Case Diagram Input Kelas

Tabel 4.9 Deskripsi Use Case Input Kelas

Use case Name Lihat Input Kelas

Use case Id 6
Aktor Admin
Deskripsi Use case menggambarkan kegiatan menambahkan kelas baru

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol kelas 2. Menampilkan form Input kelas
lalu pilih Input Kelas
3. Isi field pada form 4. Simpan data kelas yang baru diInput
kelas
-
Data kelas baru berhasil berInput
Data kelas baru berhasil disimpan
 92

7. Use Case Diagram Lihat Kelas

Tabel 4.10 Deskripsi Use Case Lihat Kelas

Use case Name Lihat Data Kelas

Use case Id 7
Aktor Admin
Deskripsi Use case menggambarkan kegiatan melihat, ubah dan hapus kelas

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol Kelas 2. Menampilkan tabel kelas yang
lalu pilih Lihat Kelas sebelumnya sudah disimpan
3. Pilih salah satu 4. Muncul form ubah kelas
kelas yang hendak di
ubah datanya
5. Isi form ubah dengan 6. Menyimpan data kelas yang telah
data baru yang hendak diubah
di ubah
-
Data kelas telah berubah
Data kelas baru berhasil disimpan
 93

8. Use Case Diagram Peminatan

Tabel 4.11 Deskripsi Use Case Peminatan Siswa

Use case Name Lihat Peminatan Siswa

Use case Id 8
Aktor Admin
Deskripsi Use case menggambarkan kegiatan melihat hasil peminatan siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response
1. Tekan tombol 2. Menampilkan tabel hasil peminatan
Peminatan dan Pilih siswa
Lihat Hasil Peminatan
3. Klik Cetak 4. Muncul hasil peminatan siswa dalam
bentuk .pdf
Alternate Courses -
Conclusion Data hasil peminatan siswa bisa dilihat
Post Condition Data hasil peminatan siswa bisa di cetak dalam bentuk .pdf
 94

9. Use Case Diagram Input Data Siswa

Tabel 4.12 Deskripsi Use Case Input Data Siswa

Use case Name Input Data Siswa

Use case Id 9
Aktor User
Deskripsi Use case menggambarkan kegiatan menambahkan data siswa

baru

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol siswa 2. Menampilkan form Input siswa
lalu pilih Input Siswa
3. Isi field pada form 4. Simpan data siswa yang baru diInput
siswa
-
Data siswa baru berhasil berInput
Data siswa baru berhasil disimpan
 95

10. Use Case Diagram Lihat Data Siswa

Tabel 4.13 Deskripsi Use Case Lihat Data Siswa

Use case Name Lihat Data Siswa

Use case Id 10
Aktor User
Deskripsi Use case menggambarkan kegiatan melihat, ubah, hapus dan cari

data siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response
1. Tekan tombol Siswa lalu 2. Menampilkan tabel siswa yang
pilih Lihat Siswa sebelumnya sudah disimpan
3. Pilih salah satu siswa 4. Muncul form ubah siswa
yang hendak di ubah
datanya
5. Isi form ubah dengan data 6. Menyimpan data siswa yang
baru yang hendak di ubah telah diubah
7. Pilih salah satu data yang 8. akan ada notifikasi jika data
akan dihapus berhasil hapus dan kembali ke
menu Lihat Siswa
9. pilih Cari Siswa sesuai 10. Menampilkan data hasil
kelas yang akan dicari lalu pencarian
klik cari
Alternate Courses -
Conclusion User dapat melihat seluruh data siswa, mengubah data siswa
menghapus data siswa dan mencari data siswa
Post Condition Seluruh data siswa yang sudah diInput berhasil ditampilkan
 96

11. Use Case Diagram Input Nilai Siswa

Tabel 4.14 Deskripsi Use Case Input Nilai Siswa

Use case Name Input Data Siswa

Use case Id 11
Aktor User
Deskripsi Use case menggambarkan kegiatan menambahkan nilai siswa

baru

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events
Alternate Courses
Conclusion
Post Condition
Aktor Action Sistem Response
1. Tekan tombol Nilai 2. Menampilkan form Input nilai siswa
lalu pilih Input Nilai
Siswa
3. Isi field pada form 4. Simpan data nilai siswa yang baru
nilai siswa diInput
-
Pengguna sistem dapat menambahkan data nilai siswa
Penambahan data nilai siswa baru berhasil
 97

12. Use Case Diagram Lihat Nilai Siswa

Tabel 4.15 Deskripsi Use Case Lihat Nilai Siswa

Use case Name Lihat Nilai Siswa

Use case Id 12
Aktor User
Deskripsi Use case menggambarkan kegiatan melihat, ubah, hapus dan cari

nilai siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response
1. Tekan tombol Nilai lalu pilih 2. Menampilkan tabel Nilai siswa
Lihat Nilai Siswa yang sebelumnya sudah disimpan
3. Pilih salah satu nilai siswa 4. Muncul form ubah nilai siswa
yang hendak di ubah datanya
5. Isi form ubah dengan data 6. Menyimpan data nilai siswa
baru yang hendak di ubah yang telah diubah
7. Pilih salah satu data yang 8. akan ada notifikasi jika data
akan dihapus berhasil hapus dan kembali ke
menu Lihat Nilai Siswa
9. pilih Cari Nilai Siswa sesuai 10. Menampilkan data hasil
kelas yang akan dicari lalu klik pencarian
cari
Alternate Courses -
Conclusion User dapat melihat seluruh nilai siswa, mengubah nilai siswa
menghapus nilai siswa dan mencari nilai siswa
Post Condition Seluruh nilai siswa yang sudah diInput berhasil ditampilkan
 98

13. Use Case Diagram Peminatan Siswa (User)

Tabel 4.16 Deskripsi Use Case Peminatan Siswa (User)

Use case Name Lihat Peminatan Siswa
Use case Id 13
Aktor User
Deskripsi Use case menggambarkan kegiatan melihat hasil peminatan siswa

Precondition Pengguna telah berhasil melakukan login.

Typical Course of Events Aktor Action Sistem Response
1. Tekan tombol 2. Menampilkan tab hasil peminatan
Peminatan dan Pilih dan tab hasil konsentrasi peminatan
Hasil Peminatan
3. Pilih tab hasil 4. Muncul tabel berisi jumlah siswa
peminatan yang masuk ke dalam kelompok minat
IPA atau IPS
5. Pilih tab hasil 5. Muncul tabel berisi nis, nama, kelas
konsentrasi peminatan dan hasil perhitungan cluster (C1 &
C2) beserta minat siswa berdasarkan
hasil penghitungan algoritma K-Means
6. Pada tab hasil 7. Muncul data siswa perkelas,
konsentrasi peminatan, kemudian klik tombol Hitung K-
pilih kelas yang akan di Means, tunggu sampai kotak dialog
cari hasil konsentrasi message “K-Means Berhasil Dihitung”
peminatannya
8. Pada tab hasil 9. Muncul seluruh data siswa beserta
konsentrasi peminatan, hasil peminatan yang sudah di proses
klik tombol lihat menggunakan algoritma K-Means.
seluruh data
 99

10. Pada tab hasil 11. Hasil Konsentrasi Peminatan akan

konsentrasi peminatan, tercetak dalam bentuk .pdf sesuai
pilih kelas yang akan di dengan kelas yang ingin kita cetak
cetak datanya, datanya.
kemudian klik cetak.
Alternate Courses -
Conclusion Data hasil peminatan dan hasil konsentrasi peminatan siswa bisa
dilihat.
Post Condition Data hasil konsentrasi peminatan siswa bisa di cetak dalam
bentuk .pdf

14. Use case Diagram Log Out

Tabel 4.17 Deskripsi Use Case Log Out

Use case Name Log Out
Use case Id 6

Aktor Semua Aktor

Deskripsi Use Case menggambarkan kegiatan keluar dari sistem.

Precondition Aktor telah masuk ke dalam sistem.

Typical Course of Events Aktor Action Sistem Response

1. Memilih menu Log Out. 2. Keluar dari sistem

Alternate Courses -

Conclusion Aktor Keluar dari sistem.

 100

4.3.2.2. Activity Diagram

Activity Diagram menggambarkan aktivitas - aktivitas yang terjadi

dalam implementasi algoritma k-means dalam data mining untuk

peminatan bagi siswa kelas X SMA Negeri 29 Jakarta :

a. Activity diagram Login :

Gambar 4.4 Activity Diagram Login

Keterangan gambar :

Di dalam activity diagram use case login yang harus dilakukan oleh

semua aktor yaitu membuka aplikasi sistem. semua aktor terlebih dahulu

melakukan login. Masukkan Username dan Password. Jika salah

memasukkan Username dan Password, sistem akan menampilkan pesan

 101

kesalahan dan kembali ke menu login untuk memasukkan Username dan

Password yang benar. Jika benar memasukkan Username dan Password

maka sistem akan menampilkan menu utama sistem.

b. Activity Diagram Input User (Halaman Admin)

Gambar 4.5 Activity Diagram Tambah User

 102

Keterangan gambar :

Didalam activity diagram Input user (halaman admin), admin sudah

login terlebih dahulu. Admin memilih menu User, dalam menu User

terdapat submenu Input user dan lihat data user. Dalam submenu Input

user, admin dapat menambah user baru dan menyimpannya ke dalam

database dengan memberikan username, password beserta hak akses nya.

c. Activity Diagram Lihat User

Gambar 4.6 Activity Diagram Lihat User

 103

Keterangan gambar :

Didalam activity diagram Lihat user (halaman admin), admin sudah

login terlebih dahulu. Admin memilih menu User, dalam menu User

terdapat submenu Input user dan lihat data user. Dalam submenu Lihat

user, admin dapat mengubah data user yang sebelumnya telah di Input ke

dalam sistem. Admin memilih salah satu data yang akan di ubah kemudian

admin mengisi form ubah user setelah itu klik simpan. Secara otomatis data

yang sudah di ubah akan tersimpan dalam database. Selain mengubah data

user, admin juga bisa menghapus data user dengan memilih salah satu data

yang ingin dihapus.

 104

d. Activity Diagram Siswa (Halaman Admin)

Gambar 4.7 Activity Diagram Siswa

Keterangan Gambar :

Di dalam activity diagram Siswa (Halaman Admin), sistem pada

awalnya menampilkan halaman utama, lalu aktor memilih menu Siswa

dimana dalam menu Siswa, aktor (admin) memilih submenu Lihat Siswa

dan dapat melihat seluruh data siswa yang sebelumnya sudah di Input ke

dalam sistem dan berhasil disimpan. Dalam menu Lihat Siswa, admin

dapat mencetak laporan data siswa perkelas. Laporan data siswa yang akan

tercetak berbentuk .pdf

 105

e. Activity Diagram Nilai (Halaman Admin)

Gambar 4.8 Activity Diagram Nilai

Keterangan Gambar :

Di dalam activity diagram Nilai (Halaman Admin), sistem pada

awalnya menampilkan halaman utama, lalu aktor memilih menu Nilai

dimana dalam menu Nilai, aktor (admin) memilih submenu Lihat Nilai dan

dapat melihat seluruh nilai siswa yang sebelumnya sudah di Input ke dalam

sistem dan berhasil disimpan. Dalam menu Lihat Nilai, admin dapat

mencetak laporan nilai siswa perkelas. Laporan nilai siswa yang akan

tercetak berbentuk .pdf

 106

f. Activity Diagram Input Kelas (Halaman Admin)

Gambar 4.9 Activity Diagram Tambah Kelas

Keterangan Gambar :

Didalam activity diagram Kelas (halaman admin), admin sudah login

terlebih dahulu. Admin memilih menu Kelas, dalam menu Kelas terdapat

submenu Input Kelas dan lihat Kelas. Dalam submenu Input Kelas, admin

dapat menambah Kelas baru sekaligus menyimpan data kelas baru ke

dalam database.
 107

g. Activity Diagram Lihat Kelas

Gambar 4.10 Activity Diagram Nilai

Keterangan Gambar :

Didalam activity diagram Kelas (halaman admin), admin sudah login

terlebih dahulu. Admin memilih menu Kelas, dalam menu Kelas terdapat

submenu Input Kelas dan lihat Kelas. Dimana dalam submenu lihat Kelas

terdapat pilihan ubah Kelas dan hapus Kelas.

Dalam submenu lihat Kelas, admin dapat mengubah kode kelas, kelas, dan

tahun ajaran yang sebelumnya telah diInput. Caranya pilih salah satu kelas
 108

yang akan di ubah, kemudian klik ubah pada kolom actions setelah diklik

aktor harus mengisi form ubah Kelas dan klik simpan lalu sistem akan

memproses data yang dimasukan. Admin juga bisa menghapus data Kelas

yang sebelumnya sudah tersimpan.

h. Activity Diagram Peminatan (Halaman Admin)

Gambar 4.11 Activity Diagram Peminatan (Halaman Admin)

 109

Keterangan Gambar :

Di dalam activity diagram Peminatan (Halaman Admin), sistem pada

awalnya menampilkan halaman utama, lalu aktor memilih menu Peminatan

dimana dalam menu Peminatan, aktor (admin) memilih submenu Lihat

Hasil Peminatan, pada submenu tersebut admin memilih tab Hasil

Peminatan dan admin dapat melihat jumlah siswa yang masuk kelompok

peminatan IPA atau IPS serta mencetak nya. Dan pada tab Hasil

Konsentrasi Peminatan, admin dapat melihat seluruh hasil peminatan siswa

yang sebelumnya sudah di proses oleh sistem dan berhasil disimpan.

Dalam menu Lihat Hasil Konsentrasi Peminatan, admin dapat mencetak

laporan hasil peminatan siswa. Laporan hasil peminatan siswa yang akan

tercetak berbentuk .pdf

 110

i. Activity Diagram Input Siswa (Halaman User)

Gambar 4.12 Activity Diagram Input Siswa (Halaman User)

Keterangan Gambar :

Didalam activity diagram Siswa (halaman user), user sudah login

terlebih dahulu. User memilih menu Siswa, dalam menu Siswa terdapat

submenu Input Siswa dan lihat Siswa. Dalam submenu Input Siswa, user

dapat menambah data siswa baru sekaligus menyimpan data siswa ke

dalam database.
 111

j. Activity Diagram Lihat Siswa (User)

Gambar 4.13 Activity Diagram Lihat Siswa (Halaman User)

Keterangan Gambar :

Didalam activity diagram Siswa (halaman user), user sudah login

terlebih dahulu. User memilih menu Siswa, dalam menu Siswa terdapat

submenu Input Siswa dan lihat Siswa. Dimana dalam submenu lihat Siswa

terdapat pilihan ubah, hapus, cari dan cetak data siswa .

Dalam submenu lihat Siswa, user dapat mengubah data siswa yang

sebelumnya telah diInput. Caranya pilih salah satu data siswa yang akan di
 112

ubah, kemudian klik ubah pada kolom actions setelah diklik aktor harus

mengisi form ubah data kelas dan klik simpan lalu sistem akan memproses

data yang dimasukan. Admin bisa menghapus data siswa yang sebelumnya

sudah tersimpan. Untuk mencari data siswa, user cukup memilih kelas

mana yang akan di cari data nya, kemudian klik cari. Maka sistem akan

menampilkan data hasil pencarian. Sedangkan untuk mencetak data siswa,

user hanya memilih kelas mana yang akan di cetak data siswanya,

kemudian klik cetak. Data siswa yang akan tercetak berbentuk .pdf

k. Activity Diagram Input Nilai (Halaman User)

Gambar 4.14 Activity Diagram Input Nilai (Halaman User)

 113

Keterangan Gambar :

Didalam activity diagram Nilai (halaman user), user sudah login

terlebih dahulu. User memilih menu Nilai, dalam menu Nilai terdapat

submenu Input Nilai dan lihat Nilai. Dimana dalam submenu lihat Nilai

terdapat pilihan ubah, hapus, cari dan cetak data nilai siswa. Dalam

submenu Input nilai, user dapat menambah nambah nilai ke dalam data

siswa yang sebelumnya telah ada.

l. Activity Diagram Lihat Nilai (Halaman User)

Gambar 4.15 Activity Diagram Lihat Nilai (Halaman User)

 114

Keterangan Gambar :

Didalam activity diagram Nilai (halaman user), user sudah login

terlebih dahulu. User memilih menu Nilai, dalam menu Nilai terdapat

submenu Input Nilai dan lihat Nilai. Dimana dalam submenu lihat Nilai

terdapat pilihan ubah, hapus, cari dan cetak data nilai siswa.

Dalam submenu lihat Nilai user dapat mengubah data nilai siswa yang

sebelumnya telah diInput. Caranya pilih salah satu data nilai siswa yang

akan di ubah, kemudian klik ubah pada kolom actions setelah diklik aktor

harus mengisi form ubah data nilai siswa dan klik simpan lalu sistem akan

memproses data yang dimasukan. Admin bisa menghapus data nilai siswa

yang sebelumnya sudah tersimpan. Untuk mencari data nilai siswa, user

cukup memilih kelas mana yang akan di cari data nya, kemudian klik cari.

Maka sistem akan menampilkan data hasil pencarian. Sedangkan untuk

mencetak data nilai siswa, user hanya memilih kelas mana yang akan di

cetak data nilai siswanya, kemudian klik cetak. Data nilai siswa yang akan

tercetak berbentuk .pdf

 115

m. Activity Diagram Peminatan Siswa (User)

Gambar 4.16 Activity Diagram Peminatan (Halaman User)

Keterangan Gambar :

Di dalam activity diagram Peminatan (Halaman User), sistem pada

awalnya menampilkan halaman utama, lalu aktor memilih menu Peminatan

dimana dalam menu Peminatan, aktor (user) memilih submenu Hasil

Peminatan, pada submenu tersebut admin dapat memilih tab Hasil

Peminatan berupa tabel yang berisi jumlah siswa yang berada dalam

kelompok minat IPA atau IPS serta dapat mencetak nya dalam bentuk .pdf.

Sedangkan dalam tab Hasil Konsentrasi Peminatan, user dapat melihat

 116

seluruh hasil peminatan siswa yang sebelumnya sudah di proses

menggunakan algoritma K-Means oleh sistem. Dalam menu Hasil

Konsentrasi Peminatan, user dapat mencari data yang diinginkan sesuai

kelas yang akan di cari serta user dapat pula mencetak laporan hasil

peminatan siswa perkelas. Laporan hasil peminatan siswa yang akan

tercetak berbentuk .pdf

n. Activity Diagram Log Out

Gambar 4.17 Activity Diagram Logout

Keterangan gambar :

Di dalam activity diagram Log Out. Aktor memilih log out lalu sistem

akan keluar secara otomatis dan kembali ke halaman Login.

 117

4.3.2.3. Sequence Diagram

Sequence diagram ini menjelaskan secara detail urutan proses yang

dilakukan dalam sistem untuk mencapai tujuan dari use case, digambarkan

pada sequence diagram berikut :

a. Sequence Diagram Login

Gambar 4.18 Sequence Diagram Login

Keterangan Gambar :

Pada saat semua aktor melakukan login, sistem akan meminta

username dan password terlebih dahulu. Pada saat username dan password

dibaca oleh sistem, sistem memverifikasi username dan password yang

 118

diisi dengan yang sudah ada di dalam database. Jika sudah berhasil login

maka seluruh aktor akan masuk ke tampilan home (menu utama) sistem.

Jika Username dan password yang dimasukkan salah, maka sistem akan

menampilkan pesan kesalahan.

b. Sequence Diagram Input User (Halaman Admin)

Gambar 4.19 Sequence Diagram Tambah User (Halaman

Keterangan Gambar :

Dalam sequence diagram Input User digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke dalam

menu User dan memilih submenu Input User. Sistem akan menampilkan

form Input user, lalu admin mengisi field username, password dan level
 119

yang ada pada form Input user. Setelah semua field terisi, klik simpan.

Maka data user yang baru saja di Input akan langsung tersimpan di dalam

database.

c. Sequence Diagram Lihat User (Halaman Admin)

Gambar 4.20 Sequence Diagram Lihat User (Halaman Admin)

 120

Keterangan Gambar :

Dalam sequence diagram Lihat User digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, lalu masuk ke dalam menu

User dan memilih submenu Lihat User. Sistem akan menampilkan data

user yang sebelumnya telah tersimpan. Kemudian admin memilih salah

satu user yang data nya ingin diubah, setelah itu klik tombol ubah. Sistem

menampilkan form ubah user, admin merubah salah satu atau semua field

pada form ubah user, setelah merubah data yang diinginkan, klik simpan.

Data yang baru saja di ubah akan langsung tersimpan ke dalam database.

Jika ingin menghapus data salah satu user, admin cukup memilih salah satu

user yang ingin dihapus datanya, kemudian klik hapus maka sistem akan

langsung menghapus data tersebut dari database.

 121

d. Sequence Diagram Lihat Siswa (Halaman Admin)

Gambar 4.21 Sequence Diagram Lihat Siswa (Halaman

Keterangan Gambar :

Dalam sequence diagram Lihat Siswa digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, lalu masuk ke dalam menu

Siswa dan memilih submenu Lihat Siswa. Sistem akan menampilkan data

Siswa yang sebelumnya telah tersimpan. Kemudian admin memilih salah

satu kelas yang data nya ingin dicetak, setelah itu klik tombol cetak. Sistem

menampilkan data siswa dalam bentuk .pdf sesuai dengan kelas yang ingin

di cetak datanya.
 122

e. Sequence Diagram Lihat Nilai (Halaman Admin)

Gambar 4.22 Sequence Diagram Lihat Nilai (Halaman Admin)

Keterangan Gambar

Dalam sequence diagram Lihat Nilai digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, lalu masuk ke dalam menu

Nilai dan memilih submenu Lihat Nilai. Sistem akan menampilkan data

Nilai Siswa yang sebelumnya telah tersimpan. Kemudian admin memilih

salah satu kelas yang data nya ingin dicetak, setelah itu klik tombol cetak.

Sistem menampilkan datanilai siswa dalam bentuk .pdf sesuai dengan

kelas yang ingin di cetak datanya.

 123

f. Sequence Diagram Input Kelas (Halaman Admin)

Gambar 4.23 Sequence Diagram Input Kelas (Halaman Admin)

Keterangan Gambar :

Dalam sequence diagram Input Kelas digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke dalam

menu Kelas dan memilih submenu Input Kelas. Sistem akan menampilkan

form Input kelas, lalu admin mengisi field yang ada pada form Input Kelas.

Setelah semua field terisi, klik simpan. Maka data kelas yang baru saja di

Input akan langsung tersimpan di dalam database.

g. Sequence Diagram Lihat Kelas (Halaman Admin)

 124

Gambar 4.24 Sequence Diagram Lihat Kelas (Halaman Admin)

Keterangan Gambar :

Dalam sequence diagram Lihat Kelas digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, lalu masuk ke dalam menu

Kelas dan memilih submenu Lihat Kelas. Sistem akan menampilkan data

kelas yang sebelumnya telah tersimpan. Kemudian admin memilih salah

satu kelas yang data nya ingin diubah, setelah itu klik tombol ubah. Sistem

menampilkan form ubah kelas, admin merubah salah satu atau semua field

pada form ubah kelas, setelah merubah data yang diinginkan, klik simpan.

Data yang baru saja di ubah akan langsung tersimpan ke dalam database.
 125

Jika ingin menghapus data salah satu kelas, admin cukup memilih salah

satu kelas yang ingin dihapus datanya, kemudian klik hapus maka sistem

akan langsung menghapus data tersebut dari database.

h. Sequence Diagram Peminatan (Halaman Admin)

Gambar 4.25 Sequence Diagram Peminatan (Halaman Admin)

 126

Keterangan Gambar :

Dalam sequence diagram Peminatan Siswa digambarkan admin telah

login terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke

dalam menu Peminatan. Klik Hasil Peminatan lalu Sistem akan

menampilkan tab hasil peminatan dan hasil konsentrasi peminatan siswa

secara keseluruhan. Tab hasil peminatan merupakan tabel yang berisi

jumlah siswa yang masuk dalam kelompok peminatan IPA atau IPS dan tab

hasil konsentrasi peminatan siswa berisi tabel yang menampilkan hasil

peminatan dari masing-masing siswa. Setelah itu admin dapat memilih

tombol cetak yang ada pada tab Hasil Konsentrasi Peminatan, maka

seluruh data yang sudah tersimpan akan tercetak dalam bentuk .pdf

i. Sequence Diagram Input Siswa (Halaman User)

Gambar 4.26 Sequence Diagram Input Siswa (Halaman User)

 127

Keterangan Gambar :

Dalam sequence diagram Input Siswa digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke dalam

menu Siswa dan memilih submenu Input Siswa. Sistem akan menampilkan

form Input Siswa, lalu admin mengisi field yang ada pada form Input

Siswa. Setelah semua field terisi, klik simpan. Maka data kelas yang baru

saja di Input akan langsung tersimpan di dalam database.

j. Sequence Diagram Lihat Siswa (Halaman User)

Gambar 4.27 Sequence Diagram Lihat Siswa (Halaman User)

 128

Keterangan Gambar :

Dalam sequence diagram Lihat Siswa digambarkan admin telah login

terlebih dahulu. User masuk halaman utama, lalu masuk ke dalam menu

Siswa dan memilih submenu Lihat Siswa. Sistem akan menampilkan data

Siswa yang sebelumnya telah tersimpan. Kemudian user memilih salah

satu siswa yang data nya ingin diubah, setelah itu klik tombol ubah. Sistem

menampilkan form ubah siswa, user merubah salah satu atau semua field

pada form ubah siswa, setelah merubah data yang diinginkan, klik simpan.

Data yang baru saja di ubah akan langsung tersimpan ke dalam database.

Jika ingin menghapus data salah satu siswa, user cukup memilih salah satu

kelas yang ingin dihapus datanya, kemudian klik hapus maka sistem akan

langsung menghapus data tersebut dari database.

Jika ingin mencari data siswa, user dapat memilih salah satu kelas yang

akan di cari datanya, setelah itu klik tombol cari, kemudian sistem akan

menampilkan data siswa yang telah tersimpan sesuai dengan kelas yang

ingin dicari datanya. Jika kelas yang akan dicari tidak ada, maka sistem

akan menampilkan tabel data siswa yang kosong.

Pada submenu Lihat Siswa, user juga dapat mencetak data siswa perkelas

dengan cara memilih kelas yang akan di cetak data siswa nya, kemudian

klik cetak. Secara otomatis sistem akan menampilkan data siswa sesuai
 129

dengan kelas yang ingin di cetak datanya. Data siswa tercetak dalam

bentuk .pdf.

k. Sequence Diagram Input Nilai (Halaman User)

Gambar 4.28 Sequence Diagram Input Nilai (Halaman User)

Keterangan Gambar :

Dalam sequence diagram Input Nilai digambarkan admin telah login

terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke dalam

menu Nilai dan memilih submenu Input Nilai. Sistem akan menampilkan

form Input Nilai, lalu admin mengisi field yang ada pada form Input Nilai.
 130

Setelah semua field terisi, klik simpan. Maka data kelas yang baru saja di

Input akan langsung tersimpan di dalam database.

l. Sequence Diagram Lihat Nilai (Halaman User)

Gambar 4.29 Sequence Diagram Lihat Nilai (Halaman User)

 131

Keterangan Gambar :

Dalam sequence diagram Lihat Nilai digambarkan admin telah login

terlebih dahulu. User masuk halaman utama, lalu masuk ke dalam menu

Siswa dan memilih submenu Lihat Nilai. Sistem akan menampilkan data

Nilai Siswa yang sebelumnya telah tersimpan. Kemudian user memilih

salah satu nilai yang data nya ingin diubah, setelah itu klik tombol ubah.

Sistem menampilkan form ubah nilai, user merubah salah satu atau semua

field pada form ubah nilai, setelah merubah data yang diinginkan, klik

simpan. Data yang baru saja di ubah akan langsung tersimpan ke dalam

database. Jika ingin menghapus data salah satu siswa, user cukup memilih

salah satu nilai siswa yang ingin dihapus datanya, kemudian klik hapus

maka sistem akan langsung menghapus data tersebut dari database.

Jika ingin mencari data nilai siswa, user dapat memilih salah satu kelas

yang akan di cari datanya, setelah itu klik tombol cari, kemudian sistem

akan menampilkan data nilai siswa yang telah tersimpan sesuai dengan

kelas yang ingin dicari datanya. Jika kelas yang akan dicari tidak ada, maka

sistem akan menampilkan tabel data siswa yang kosong.

Pada submenu Lihat Nilai, user juga dapat mencetak data nilai siswa

perkelas dengan cara memilih kelas yang akan di cetak data nilai siswa

nya, kemudian klik cetak. Secara otomatis sistem akan menampilkan data
 132

nilai siswa sesuai dengan kelas yang ingin di cetak datanya. Data nilai

siswa tercetak dalam bentuk .pdf.

m. Sequence Diagram Peminatan (Halaman User)

Gambar 4.30 Sequence Diagram Peminatan (Halaman User)

 133

Keterangan Gambar :

Dalam sequence diagram Peminatan Siswa digambarkan user telah

login terlebih dahulu. Admin masuk halaman utama, kemudian masuk ke

dalam menu Peminatan. Klik Hasil Peminatan lalu Sistem akan

menampilkan tab hasil peminatan dan hasil konsentrasi peminatan siswa

baik perkelas atau secara keseluruhan. User dapat memilih tombol cari

untuk mencari data yang ingin dilihat hasil peminatannya setelah klik cari,

kemudian klik tombol Hitung K-Means setelah itu sistem akan

menampilkan hasil penghitungan K-Means beserta minat siswa masing-

masing setelah itu, untuk mencetak hasil peminatan, user dapat mengklik

cetak yang ada pada tab Hasil Konsentrasi Peminatan, maka seluruh data

yang sudah tersimpan akan tercetak dalam bentuk .pdf

Pada tab Pengujian, user dapat melihat hasil pengujian sistem terhadap

peminatan yang menggunakan algoritma K-Means dan peminatan secara

manual. Jika minat hasil penghitungan K-Means sama seperti minat hasil

penghitungan manual bernilai TRUE. Jika minat hasil penghitungan K-

Means atau manual tidak sama, maka bernilai FALSE. Selain itu, user juga

bisa mencetak hasil pengujian dalam bentuk .pdf

 134

n. Sequence Diagram Log Out

Gambar 4.31 Sequence Diagram Log Out

Keterangan gambar :

Semua aktor memilih menu log out kemudian sistem akan melakukan

proses verifikasi log out, kemudian sistem akan menampilkan

notifikasi/pesan berhasil log out dan kembali ke menu utama.

 135

4.3.2.4. Class Diagram

Class Diagram digunakan untuk menggambarkan kumpulan dari

class dan hubungannya. Diagram ini merupakan diagram yang paling

umum ditemukan dalam pemodelan sistem berorientasi objek. Class

memiliki tiga area pokok yaitu nama, atribut dan metode. Selain itu setiap

class yang ada dapat menjadi sebuah form saat pembuatan program.

Pada gambar 4.32 Class Diagram memiliki 16 Class dengan atribut dan

metode. Class diagram dapat dilihat pada gambar 4.32

 136

Gambar 4.32 Class Diagram

 137

4.3.2.5. Desain Database

Pada aplikasi ini, penulis merancang beberapa tabel dalam satu

dabatase pusat yang berguna sebagi media penyimpanan data informasi

aplikasi sehingga dapat membantu dalam proses peminatan dan proses

lainnya. Berikut adalah penjelasan lengkap mengenai tabel-tabel dan desain

database yang telah dibuat :

1. Daftar Tabel

Berikut ini adalah daftar tabel yang ada pada database

jurusanSMA.sql dalam aplikasi peminatan :

Nama Tabel Primary Key Data Store

Jurusan kd_jurusan jurusanSMA.sql

Kelas kd_kelas jurusanSMA.sql

Matapelajaran kd_matapelajaran jurusanSMA.sql

Nilai id_nilai jurusanSMA.sql

Pengujian id jurusanSMA.sql

Siswa nis jurusanSMA.sql

Thn_ajaran kd_thnajaran jurusanSMA.sql

User username jurusanSMA.sql

Tabel 4.18 Daftar Tabel Database

 138

2. Deskripsi Tabel

a. Tabel jurusan

Nama Field Tipe data Ukuran Keterangan

kd_jurusan varchar 5 Kode jurusan

jurusan varchar 20 Nama Jurusan

b. Tabel kelas

Nama Field Tipe data Ukuran Keterangan

kd_kelas varchar 10 Kode kelas

kelas varchar 10 Nama Kelas

c. Tabel matapelajaran

Nama Field Tipe data Ukuran Keterangan

kd_matapelajaran int 11 Kode mata pelajaran

matapelajaran varchar 20 Nama mata pelajaran

 139

d. Tabel nilai

Nama Field Tipe data Ukuran Keterangan

id_nilai int 5 Nomor nilai

kd_kelas varchar 10 Kode kelas

kd_thnajaran varchar 10 Kode tahun ajaran

nis varchar 10 Nomor Induk Siswa

kd_mp varchar 5 Kode matapelajaran

nilai double Nilai siswa

username varchar 15 Username user

e. Tabel siswa

Nama Field Tipe data Ukuran Keterangan

nis varchar 10 Nomor induk mahasiswa

nama varchar 50 Nama siswa

kd_kelas varchar 10 Kode kelas

C1 varchar 50 Hasil cluster 1atau C1

C2 varchar 50 Hasil cluster2 atau C2

kd_jurusan varchar 10 Kode jurusan

 140

f. Tabel tahun ajaran

Nama Field Tipe data Ukuran Keterangan

kd_thnajaran varchar 10 Kode tahunajaran

thn_ajaran varchar 10 Tahun ajaran

g. Tabel User

Nama Field Tipe data Ukuran Keterangan

username varchar 15 Username user

password varchar 10 Password user

hak_akses varchar 10 Hak akses user

h. Tabel Pengujian

Nama Field Tipe data Ukuran Keterangan

id varchar 5 id pengujian

nis varchar 20 nomor induk siswa

nama varchar 50 nama siswa

kd_kelas varchar 10 kode kelas

manual varchar 5 hasil peminatan manual

kd_jurusan varchar 5 hasil peminatan k-means

keterangan varchar 5 keterangan True/False

 141

4.3.2.6. Perancangan Desain Antar Muka (Interface)

Berikut ini rancangan user interface Implementasi Algoritma K-

Means dalam Data Mining untuk Peminatan Jurusan Bagi Siswa

Kelas X SMA Negeri 29 Jakarta :

a. Login

Gambar 4.33 Tampilan Form Login

b. Home Admin

Gambar 4.34 Tampilan Home Admin

 142

c. Input User

Gambar 4.35 Tampilan Form Input User

d. Lihat User

Gambar 4.36 Tampilan Lihat User

 143

e. Lihat Siswa (Halaman Admin)

Gambar 4.37 Tampilan Lihat Siswa (Halaman Admin)

f. Lihat Nilai (Halaman Admin)

Gambar 4.38 Tampilan Lihat Nilai (Halaman Admin)

 144

g. Input Kelas (Halaman Admin)

Gambar 4.39 Tampilan Form Input Kelas (Halaman Admin)

h. Lihat Kelas (Halaman Admin)

Gambar 4.40 Tampilan Lihat Kelas (Halaman Admin)

 145

i. Peminatan (Halaman Admin)

Gambar 4.41 Tampilan Peminatan (Halaman Admin)

j. Home User

Gambar 4.42 Tampilan Home User

 146

k. Input Siswa (Halaman User)

Gambar 4.43 Tampilan Form Input Siswa (Halaman

l. Lihat Siswa (Halaman User)

Gambar 4.44 Tampilan Lihat Siswa (Halaman User)

 147

m. Input Nilai (Halaman User)

Gambar 4.45 Tampilan Form Input Nilai (Halaman

n. Lihat Nilai (Halaman User)

Gambar 4.46 Tampilan Lihat Nilai (Halaman User)

 148

o. Peminatan (Halaman User)

Gambar 4.47 Tampilan Peminatan (Halaman User)

p. Peminatan Tab Pengujian (Halaman User)

Gambar 4.48 Tampilan Peminatan Tab Pengujian (Halaman User)

 149

4.3.3. Fase Konstruksi

4.3.3.1 Konstruksi Algoritma

Berikut adalah Pseudocode dari penerapan algoritma K-Means

yang telah dijelaskan pada sub bab 4.3.1.6 mengenai algoritma K-Means

yang akan diterapkan untuk melakukan penghitungan cluster pada nilai

akademik siswa yang dibangun dengan bahasa pemrograman java.

Input X = {X1, X2, ... , Xn} (input Data Set)

Output C = {C1, C2, ... Cn} (C Cluster pusat)
Pilih acak subhimpunan C dan X sebagai inisial Cluster pusat
while kriteria terminasi belum terpenuhi do
for (i = 1; i N; i = + 1) do
masukkan Xi pada pusat cluster terdekat
m[i] = argmin X {1, 2, ...k} ;
end
Hitung kembali pusat cluster;
for (k = i; k K; k = k + 1) do
Cluster Sk mengandung himpunan titik-titik Xi yang paling dekat dengan pusat Ck;
Sk = {Xi | m[i] = k};
Hitung pusat baru Ck berdasar nilai rata-rata titik yang termasuk dalam Sk;
Ck =

Sampai C konvergen (data tidak berpindah ke Cluster lain)

end
end

Gambar 4.49 Pseudocode

 150

4.3.3.2 Pengkodean

Pada tahap ini, penulis melakukan konstruksi/pembuatan aplikasi

berdasarkan tahapan-tahapan sebelumnya. Proses konstruksi dilakukan

dengan mengacu pada rancangan dan alur aplikasi yang telah di tentukan.

Selanjutnya hasil perancangan menggunakan model UML diterjemahkan

kedalam sebuah kode (coding).

Proses pengkodean dilakukan dengan menggunakan bantuan

beberapa perangkat lunak (software), yaitu JDK versi 7sebagai platform

Java, Netbeans IDE 7.0.1 sebagai editor dan Xampp sebagai server

database. Berikut penjelasan mengenai konstruksi aplikasi menggunakan

Netbeans IDE 7.0.1 syntax code program terkait peminatan bagi siswa

SMA. Untuk proses konstruksi dan source code program dapat dilihat

selengkapnya pada lampiran.

1. Contoh Syntax Code Hitung Kmeans

151
152
153
 154

Gambar 4.50 Syntax Code Hitung Hasil Peminatan

Gambar 4.50 menunjukkan untuk melakukan penghitungan terhadap nilai

akademik siswa. Fungsi hitung merupakan penerapan dari algoritma K-Means

yang digunakan untuk menghitung nilai akademik siswa dan untuk

mengetahui minat siswa berdasarkan nilai akademik siswa.

 155

Berikut ini langkah-langkah proses hitung hasil peminatan menggunakan

algoritma K-Means :

a. Membaca perintah yang di input melalui GUI

b. Controller class menangkap perintah tersebut, kemudian diteruskan ke

model class untuk mengambil data yang diperlukan dan tersimpan di

dalam database

c. Jika telah mengambil data yang sesuai, kemudian model class

mengembalikan data yang telah di ambil dari database ke controller

class untuk kemudian dihitung nilai akademik siswa menggunakan

algoritma K-Means, langkah-langkah untuk menghitung nilai

akademik siswa terdapat dalam controlerhasilpeminatan.java

d. Setelah controller class selesai menghitung nilai akademik masing-

masing siswa, kemudian hasil penghitungan nilai masuk ke dalam

database dan selanjutnya hasil tersebut di tampilkan melalui GUI

sebagai Output.
 156

2. Syntax Code Cari Siswa

3.

Gambar 4.51 Syntax Code Cari Siswa

 157

Gambar 4.51 menjelaskan fungsi pencarian dari data dan nilai akademik

yang dimiliki siswa sebelum proses hitung K-Means. Data dan nilai akademik

dibaca kemudian di hitung menggunakan proses hitung K-Means.

 158

4.3.4. Fase Pelaksanaan

Analisis kebutuhan perangkat pendukung menjadi hal yang sangat

penting. Aplikasi ini dapat berjalan baik apabila perangkat keras

pendukung juga dapat berjalan dengan baik.

4.3.4.1. Implementasi User Interface Aplikasi

Berikut ini rancangan user interface aplikasi Implementasi

Algoritma K-Means dalam Data Mining untuk Peminatan Jurusan Bagi

Siswa Kelas X SMA Negeri 29 Jakarta :

a. Login

Gambar 4.52 Tampilan Layar Utama Menu Login

 159

b. Home Admin (Halaman Admin)

Gambar 4.53 Tampilan Home Admin (Halaman Admin)

c. Home User (Halaman User)

Gambar 4.54 Tampilan Home User (Halaman User)

 160

4.3.4.2. Pengujian Aplikasi (Black-Box Testing)

Pengujian merupakan bagian yang terpenting dalam siklus

pembangunan perangkat lunak. Pengujian dilakukan untuk memeriksa

fungsi-fungsi dalam aplikasi peminatan bagi siswa kelas X agar dapat

berjalan dengan baik dan sesuai fungsinya. Pengujian aplikasi ini

menggunakan jenis uji black-box yaitu pengujian yang berfokus pada

persyaratan fungsional perangkat lunak. Berikut adalah tabel hasil

pengujian black-box :

Tabel 4.19 Hasil Pengujian Black-Box

Status
No Fungsi Skenario pengujian Hasil Yang Diharapkan
Pengujian
Jika username dan

password terdaftar

maka akan masuk ke

dalam menu utama

Pengguna baik admin sesuai dengan

1 Login Pengguna atau user melakukan username saat login, Terpenuhi

Login jika tidak maka

pengguna tidak dapat

masuk ke dalam

halaman utama.

2 Input User Admin menambah user Aplikasi akan Terpenuhi

 161

(Halaman Admin) baru dengan menampilkan pesan

memasukkan username, bahwa data berhasil

password dan level tersimpan ke dalam

pengguna pada form database

input user. Kemudian

klik tombol simpan

Aplikasi akan
Admin memilih
menampilkan tabel
submenu Lihat User
yang berisi username
pada menu User untuk
Lihat User dan password. Pada
3 melihat daftar pengguna Terpenuhi
(Halaman Admin) submenu ini, admin
serta merubah dan
dapat menghapus atau
menghapus data
merubah data user
pengguna
yang diinginkan

Aplikasi akan

Admin memilih menampilkan seluruh

submenu Lihat Siswa data siswa yang ada,

Lihat Siswa pada menu Siswa untuk ketika admin menekan

4 Terpenuhi
(Halaman Admin) melihat data siswa tombol cetak, maka

keseluruhan dan data siswa akan

mencetak data siswa. tercetak dalam bentuk

.pdf

5 Lihat Nilai Admin memilih Aplikasi akan Terpenuhi

 162

(Halaman Admin) submenu Lihat Nilai menampilkan seluruh

pada menu Nilai untuk nilai siswa yang ada,

melihat nilai siswa ketika admin menekan

keseluruhan dan tombol cetak, maka

mencetak nilai siswa. nilai siswa akan

tercetak dalam bentuk

.pdf

Admin memilih

submenu Input Kelas Aplikasi akan

pada menu Kelas, menampilkan pesan

Input Kelas
6 kemudian admin mengisi bahwa data berhasil Terpenuhi
(Halaman Admin)
field kode kelas dan disimpan ke dalam

kelas lalu tekan tombol database

simpan

Admin memilih
Aplikasi akan
Lihat Kelas submenu Lihat Kelas
7 menampilkan seluruh Terpenuhi
(Halaman Admin) pada menu Kelas untuk
nilai siswa yang ada.
melihat data kelas.

Admin memilih Aplikasi akan

submenu peminatan pada menampilkan jumlah

Peminatan
8 menu peminatan. Lalu siswa yang masuk Terrpenuhi
(Halaman Admin)
admin memilih tab Hasil kelompok peminatan

Peminatan untuk melihat IPA dan IPS lalu admin

 163

jumlah siswa yang dapat mencetak dalam

masuk kelompok bentuk .pdf Aplikasi

peminatan IPA atau IPS. juga menampilkan

Tab Hasil Konsentrasi hasil peminatan bagi

Peminatan berisi hasil masing-masing siswa

peminatan masing- dan hasil konsentrasi

masing siswa. peminatan dpt dicetak

dalam bentuk .pdf

User memilih submenu

Input Siswa pada menu Aplikasi akan

Siswa, kemudian admin menampilkan pesan

Input Siswa
9 mengisi field yang bahwa data berhasil Terpenuhi
(Halaman User)
terdapat dalam form tersimpan ke dalam

siswa lalu tekan tombol database

simpan

User memilih submenu Aplikasi akan

Lihat Siswa pada menu menampilkan tabel

Siswa untuk melihat data yang berisi data siswa.

Lihat Siswa siswa keseluruhan. User Ketika user memilih

10 Terpenuhi
(Halaman User) dapat mengubah data kelas yang akan di cari,

siswa, menghapus, dan menekan tombol

mencari dan mencetak cari, maka aplikasi

data siswa. akan menampilkan

 164

hasil pencarian. Ketika

user memilih salah satu

data yang akan di ubah

menekan tombol edit

maka aplikasi akan

menampilkan form edit

Siswa, setelah diisi dan

klik simpan, data akan

terupdate otomatis.

Ketika user memilih

salah satu data yang

akan di hapus dan

menekan tombol

hapus, maka aplikasi

akan menghapus data

secara otomatis.

Ketika user menekan

tombol cetak, lalu

aplikasi akan mencetak

data siswa dalam

bentuk .pdf

Input Nilai User memilih submenu Aplikasi akan

11 Terpenuhi
(Halaman User) Input Nilai pada menu menampilkan pesan
 165

Nilai, kemudian admin bahwa data berhasil

mengisi field yang tersimpan ke dalam

terdapat dalam form database

siswa lalu tekan tombol

simpan

Aplikasi akan

menampilkan tabel

yang berisi nilai siswa.

Ketika user memilih

kelas yang akan di cari,

User memilih submenu dan menekan tombol

Lihat Nilai pada menu cari, maka aplikasi

Nilai untuk melihat data akan menampilkan

Lihat Nilai nilai siswa keseluruhan. hasil pencarian. Ketika

12 Terpenuhi
(Halaman User) User dapat mengubah user memilih salah satu

data siswa, menghapus, data yang akan di ubah

mencari dan mencetak menekan tombol edit

data siswa. maka aplikasi akan

menampilkan form edit

nilai siswa, setelah diisi

dan klik simpan, data

akan terupdate

otomatis.
 166

Ketika user menekan

tombol cetak, lalu

aplikasi akan mencetak

nilai siswa dalam

bentuk .pdf

Aplikasi akan
User memilih submenu
menampilkan jumlah
peminatan pada menu
siswa yang masuk
peminatan. Lalu user
kelompok peminatan
memilih tab Hasil
IPA dan IPS lalu user
Peminatan untuk melihat
dapat mencetak dalam
jumlah siswa yang
bentuk .pdf Aplikasi
masuk kelompok
juga menampilkan
peminatan IPA atau IPS.
Peminatan hasil peminatan bagi
13 Tab Hasil Konsentrasi Terpenuhi
(Halaman User) masing-masing siswa
Peminatan berisi hasil
dan hasil konsentrasi
peminatan masing-
peminatan dpt dicetak
masing siswa.
dalam bentuk .pdf
Tab Pengujian berisi
Aplikasi akan
perbandingan peminatan
menampilkan
antara hasil
perbandingan hasil
penghitungan k-means
penghitungan k-means
dan manual.
dan manual. Jika
 167

minat hasil

penghitungan K-Means

sama seperti minat

hasil penghitungan

manual bernilai TRUE.

Jika minat hasil

penghitungan K-Means

atau manual tidak

sama, maka bernilai

FALSE

4.3.4.3. Uji Validasi Algoritma K-Means

Uji validasi dalam aplikasi ini bertujuan untuk mengetahui kinerja

aplikasi yang telah dibuat. Pada aplikasi ini dari 253 data penelitian yang

ada, dibagi menjadi 2 data yaitu 208 record data untuk pelatihan/training

dan 45 record data untuk testing. Data testing tersebut yang akan dijadikan

sebagai data validasi untuk mengetahui tingkat akurasi dan laju kesalahan

dari algoritma K-Means.

Data uji validasi yang digunakan dapat dilihat pada tabel 4.20 berikut ini :

No Nis Nama Kelas Manual K-Means Keterangan

ABRAR SUMANGERUKKA
1 16705 X1 IPA IPS FALSE
SUWANDAKUSUMAH
2 16739 YOGA ARDIANSYAH X1 IPS IPS TRUE
3 16717 DIMAS MURYA PERDANA X1 IPA IPS FALSE
4 16931 ANANDA RAISYA X7 IPA IPS FALSE
 168

SULTHANA LABIBA
5 16737 X1 IPA IPA TRUE
KHANSA
6 16948 MAGHFIRA X7 IPA IPS FALSE
7 16962 SAFIRA HANIFA X7 IPA IPS FALSE
8 16855 ADELA SETIAWAN X5 IPS IPS TRUE
9 16706 ADZKIA RAHMATILLAH X1 IPS IPA FALSE
10 16725 MAYLA RIZKI ARJUNA X1 IPA IPS FALSE
11 16822 ARSYAD FATHURRIZAL X4 IPS IPS TRUE
12 16813 VEDHA AMURAKHAIR X3 IPS IPS TRUE
13 16858 ARSY ERLASYIFA X5 IPS IPS TRUE
14 16778 ADRIAN MARVIN X3 IPS IPS TRUE
CHRISTINA AJENG
15 16786 X3 IPS IPS TRUE
BUDIARTI
16 16945 KEVIN ERIYANG KENCANA X7 IPS IPS TRUE
17 16904 FITRIANA NABELA X6 IPS IPA FALSE
18 16905 ICA KHAIRUN NISA X6 IPS IPA FALSE
19 16965 YUSRIA ULFIANA X7 IPS IPA FALSE
20 16818 ALFRINO ADYWIRYA X4 IPS IPS TRUE
21 16744 ALYSA X2 IPA IPA TRUE
WAHID GALANG
22 16814 X3 IPS IPS TRUE
DEWANTORO
23 16781 ANIISA ZULVINA X3 IPS IPS TRUE
24 16718 ELISABETH GULTOM X1 IPA IPA TRUE
25 16902 FATHY NOOR HAQ LUBIS X6 IPA IPA TRUE
26 16762 GHINVA KEMALAPUTRI X2 IPA IPA TRUE
27 16796 LYDIA PURNAMA SARI X3 IPS IPS TRUE
28 16845 PUTRI DEA SARI X4 IPA IPA TRUE
29 16754 DESY CITRA SARI X2 IPA IPA TRUE
30 16788 FIRMAN HERDIANSYAH X3 IPA IPS FALSE
MUHAMMAD HARALD
31 16839 X4 IPS IPS TRUE
ARKAAN
32 16943 HAFIZAH NURUL AIN X7 IPA IPS FALSE
33 16812 TITA NIDYA SARI X3 IPA IPA TRUE
34 16880 QISTHI HILMI KIASATI X5 IPA IPA TRUE
35 16734 RAHMAT FADHLI SYAUQI X1 IPA IPS FALSE
36 16802 NISA CHAIRUNNISA X3 IPA IPA TRUE
37 16793 ILHAM HABIBIE X3 IPA IPS FALSE
RIZZKE KURNIA
38 16774 X2 IPA IPA TRUE
MARCHELINDA
LEONARDO YORIANO
39 16765 X2 IPS IPS TRUE
BHIRAWA WICAKSANA
40 16766 MANUEL WILMAN X2 IPS IPS TRUE
41 16834 MARCELLINA SITI NABILA X4 IPS IPS TRUE
42 16836 MEY AYU LESTARI X4 IPS IPA FALSE
43 16955 NUR AINI RIDIANDARI X7 IPS IPS TRUE
44 16849 RUSDI SHOLIHIN X4 IPS IPS TRUE
45 16842 NIPUTU AYU DEWI YANTI X4 IPA IPA TRUE
46 16810 SHAFIRA KAUTSAR MAHDI X3 IPS IPS TRUE
47 16912 MAJDINA RACHMA DEWI X6 IPA IPA TRUE
 169

48 16887 SYAMAIDZAR X5 IPA IPA TRUE

49 16726 MELISA ANGRAINI X1 IPA IPA TRUE
50 16733 PUTRI MAIDI BACHTIYANI X1 IPS IPS TRUE
51 16881 RACHMI ANINDYAPUTRI X5 IPA IPA TRUE
52 16922 RIZKA AMALIA X6 IPA IPA TRUE
53 16981 PUSPITHA CAHAYA AYU X5 IPS IPS TRUE
54 16806 RISSA DIANA NOVIANTI X3 IPS IPS TRUE
55 16940 FATHUR AMMAR X7 IPS IPS TRUE
WIRAWAN AHMAD
56 16926 X6 IPA IPA TRUE
DESTAMA
57 16794 JOVITA RAMADHANTI X3 IPA IPA TRUE
58 16937 DEVI NANDIA OKTAVIANI X7 IPA IPS FALSE
59 16835 MAYKEL RICARDO X4 IPA IPA TRUE
60 16888 SYIFA BUDI PRATIWI X5 IPS IPS TRUE
61 16826 DWI PRATIWI SESARIANI X4 IPA IPA TRUE
62 16952 MUSTAQIM X7 IPS IPS TRUE
63 16919 NITA AVIYANTI X6 IPA IPA TRUE
64 16944 HANNY APRILIANI PUTRI X7 IPA IPS FALSE
LUTHFI JOVAN WANDY
65 16910 X6 IPA IPA TRUE
AKMANDO
MUHAMAD HAPIZ
66 16951 X7 IPA IPS FALSE
HERDIANSYAH
MUHAMMAD WAFIYUDDIN
67 16875 X5 IPA IPA TRUE
AL WAHAB
68 16949 MAULIDA RAHMA X7 IPA IPA TRUE
69 16840 NADA NABILA X4 IPS IPS TRUE
70 16876 NATASHA PUTRI ADITA X5 IPS IPS TRUE
GRACE ANASTASIA
71 16871 X5 IPS IPS TRUE
MAHARDIKA
72 16872 KINDY ISLAMIATTI X5 IPA IPA TRUE
SITI NURLAILA
73 16924 X2 IPA IPA TRUE
APRILIYANTI

Hasil pengujian tersebut kemudian dapat dihitung tingkat akurasi

dan laju kesalahannya menggunakan rumus matriks konfusi seperti

berikut:
 170

Tabel 4.21 Matriks Konfusi untuk Hasil Peminatan K-Means

Kelas hasil prediksi (j)

fij
Kelas = IPA Kelas = IPS
f11 f10
Kelas = IPA
27 13
Kelas asli
f01 f00
(i) Kelas = IPS
5 28

Berdasarkan isi matrik konfusi, dapat diketahui jumlah data dari

masing-masing kelas yang diklasifikasikan secara benar dan kelas yang

diklasifikasikan secara salah. Kemudian berdasarkan data matriks

konfusi tersebut maka dapat diketahui tingkat akurasi dan laju kesalahan

algoritma K-Means dalam peminatan bagi siswa kelas X pada data uji.

Berikut adalah perhitungan akurasi dan laju kesalahan hasil peminatan

tersebut:

(1)

(2)

Mengacu pada hasil perhitungan akurasi dan laju kesalahan di atas

maka dapat disimpulkan bahwa hasil peminatan menggunakan

 171

algoritma K-Means terhadap data uji validasi memiliki tingkat akurasi

sebesar 0.753 atau 75.3% dan laju kesalahan sebesar 0.2465 atau 24.7%

Laju kesalahan sebesar 24.7% atau 25% disebabkan karena

rentang nilai antara IPA dan IPS terlalu dekat sehingga menyebabkan

hasil penghitungan algoritma K-Means bernilai samar. Siswa bisa

masuk ke dalam peminatan IPA dan IPS karena rentang nilai nya terlalu

dekat.

80

70

60

50 Tingkat Akurasi
Laju Error
40

30

20

10

0
Matriks Konfusi

Gambar 4.54 Grafik Perbandingan Tingkat Akurasi dan Laju Kesalahan

 BAB V

PENUTUP

Setelah melakukan serangkaian penelitian, maka pada bab ini penulis

menguraikan kesimpulan dari penelitian yang telah dilakukan serta saran-saran yang

bermanfaat bagi pengembangan aplikasi selanjutnya.

5.1 Kesimpulan

1. Dari hasil penggalian informasi terhadap 253 data sampel yang diuji

dengan mengimplementasikan algoritma K- Means dalam teknologi data

mining, diketahui bahwa sebanyak 110 siswa masuk kedalam kelompok

peminatan IPA dan sebanyak 143 siswa masuk kedalam kelompok

peminatan IPS.

2. Algoritma K-Means dapat di implementasikan dalam teknologi data

mining untuk sistem peminatan jurusan bagi siswa kelas X SMA dengan

tingkat akurasi sebesar 0.753 atau 75.3% atau 75% terhadap 253 data

sampel. Laju kesalahan sebesar 0.247 atau 24.7% atau 25%.

3. Dengan tingkat akurasi sebesar 75% aplikasi peminatan jurusan cukup

efektif untuk membantu pihak sekolah dalam menentukan minat siswa

kelas X sesuai dengan nilai akademik yang dimiliki masing-masing

siswa.

172
 173

5.2 Saran

Aplikasi yang penulis buat tentu saja masih belum sempurna, masih

banyak hal yang dapat dilakukan untuk mengembangkan aplikasi ini agar

menjadi lebih baik lagi. Oleh karena itu oenulis juga menyampaikan beberapa

saran guna menambah nilai dan mafaat penulisan, yaitu :

1. Untuk mendapatkan tingkat akurasi yang lebih baik dalam penerapan

algoritma K-Means untuk peminatan jurusan di Sekolah Menengah

Atas, serta untuk memberikan kontribusi yang lebih besar di dunia riset,

disarankan agar hasil penelitian ini dikembangkan dengan cara

memodifikasi/updating algoritma K-Means yang digunakan saat ini, atau

dengan menggabungkan algoritma K-Means dengan algoritma lain.

2. Dalam penelitian ini hanya menggunakan variabel prestasi siswa dalam

bentuk nilai mata pelajaran semester 2, disarankan agar penelitian ini

dikembangkan lagi dengan menambahkan (menyertakan) nilai mata

pelajaran semester 1 dan variabel minat siswa sebagai variabel

komputasi dalam proses penghitungan menggunakan algoritma.

3. Jika nilai C1 sama dengan nilai C2 atau rentang nilai antara C1 dan C2

terlalu dekat, pihak sekolah bisa menggunakan angket minat siswa

sebagai bahan pertimbangan untuk menentukan hasil keputusan akhir

peminatan siswa.
 DAFTAR PUSTAKA

Bahar. 2011. Penentuan Jurusan Sekolah Menengah Atas dengan Algoritma Fuzzy C-

Means. Tesis. Semarang : Universitas Dian Nuswantoro

Baskoro, H. 2010. Implementasi Algoritma K-Means Menggunakan Data Penyewaan

Alat Berat Untuk Melakukan Estimasi Nilai Outcome. Skripsi. Jakarta : Fakultas

Ilmu Komputer, Universitas Pembangunan Nasional ”Veteran” Jakarta

Cahyono, Setiyo. 2006. Panduan Praktis Pemrograman Database MySQL dan Java.

Bandung : Informatika

Davies, and Paul Beynon. 2004. Database System Third Edition. New York : Palgrave

Macmillan

Departemen Pendidikan Nasional (2008), Petunjuk Teknis Laporan Hasil Belajar Peserta

Didik (LHBPD), Dirjen Mandikdasmen, Jakarta

Dunham, Margaret H. 2003. Data Mining Introductory and Advanced Topics. New

Jersey : Prentice Hall

Ediyanto., Mara, Muhlasah Novitasari., Satyahadewi, Neva. 2013. Pengklasifikasian

Karakteristik Dengan Metode K-Means Cluster Analysis. Jurnal. Pontianak :

Universitas Tanjungpura (UNTAN)

Giyanto, Heribertus. 2008. Penerapan algoritma Clustering K-Means, K-Medoid, Gath

Geva. Tesis Tidak Terpublikasi. Yogyakarta: Universitas Gajah Mada

Han, Jiawei., Kamber, Micheline., Pei, Jian. 2011. Data Mining Concept and Techniques

Third Edition. San Francisco: Morgan Kaufmann Publishers

174
 175

Hermawati, Fajar Astuti. 2013. Data Mining. Yogyakarta : Andi

Jananto, Arief. 2010. Memprediksi Kinerja Mahasiswa Menggunakan Teknik Data

Mining (Studi kasus data akademik mahasiswa UNISBANK). Tesis Tidak

Terpublikasi. Yogyakarta: Universitas Gajah Mada

Kantardzic, M. 2003. Data Mining : Concepts, Models, Methods, and Algorithms. New

York : IEEE & Wiley Inter-Science

Kendall, Kenneth E. and Kendall, Julie E. 2008. Systems Analysis and Design. Jakarta :

PT. Indeks

Kusrini., Taufiq Luthfi, Emha. 2009. Algoritma Data Mining. Yogyakarta: CV. Andi

Offset.

MacQueen, J. B. 1967. Some Methods for classification and Analysis of Multivariate

Observations, Proceedings of 5-th Berkeley Symposium on Mathematical Statistics

and Probability. Berkeley : University of California Press

Munawar. 2005. Pemodelan Visual dengan UML. Yogyakarta : Graha Ilmu

Nazir, Muh. 2005. Metodologi penelitian. Bogor : Ghalia Indonesia

Nazri, Ade Amalia. 2011. Perancangan Aplikasi Sistem Penentuan Peminatan Siswa

Berdasarkan Minat dan Kemampuan Akademik Siswa Berbasis Web. Skripsi.

Jakarta : Universitas Islam Negeri (UIN) Syarif Hidayatullah Jakarta

Nugroho, Adi. 2005. Analisa Perancangan Sistem dengan Metode Berorientasi Objek.

Bandung : Informatika
 176

Prasetio, Aditya. 2010. Pengembangan Aplikasi Content Management System Untuk

Mobile Learning Bagi Pengajar Berbasis Java. Skripsi. Jakarta : Universitas Islam

Negeri (UIN) Syarif Hidayatullah Jakarta

Prasetyo, Eko. 2012. Data Mining – Konsep dan Aplikasi Menggunakan MATLAB.

Yogyakarta: ANDI

Pressman, Roger S. 2002. Rekayasa Perangkat Lunak. Yogyakarta : Andi

Rismawan, Tedy dan Kusumadewi, Sri. 2008. Aplikasi K-Means untuk Pengelompokkan

Mahasiswa Berdasarkan Nilai Body Mass Index (BMI) & Ukuran Kerangka.

Jurnal. Yogyakarta : Universitas Islam Indonesia.

Santoso, B. (2007), Data Mining: Teknik Pemanfaatan Data untuk Keperluan Bisnis,

Yogyakarta: Graha Ilmu.

Setiawan, Wawan. dan Munir. 2006. Pengantar Teknologi Informasi: Sistem Informasi.

Bandung : Universitas Pendidikan Indonesia.

Sutedjo, Budi dan AN, Michael. 2004. Algoritma dan Teknik Pemrograman Konsep,

Implementasi dan Aplikasi. Yogyakarta: ANDI

Tan, P.N., Stainbach, M., dan Kumar, V. 2005, Introduction to Data Mining, Addison

Wesley Publisher, New York.

Utami, E dan Raharjo, S. 2004. Logika, Algoritma dan Implementasinya dalam Bahasa

Phyton di GNU/Linux. Yogyakarta : ANDI

Vercellis, Carlo. 2009. Business intelligence : Data Mining and Optimization for

Decision Making. Chichester: John Wiley & Sons.

 177

Whitten JL, Bentley LD, Dittman KC. 2004. Metode Desain dan Analisis Sistem edisi 6.

Yogyakarta: Andi. Terjemahan dari Systems Analysis and Design Method.

Witten, Ian H. and Frank, Eibe. 2005. Data Mining: Practical Machine Learning Tools

and Techniques, Second Edition. Morgan Kaufmann Publishers, San Fransisco,

California, U.S.A

Wijaya, Arim. 2010. Analisis Algoritma K-Means untuk Sistem Pendukung Keputusan

Penjurusan Siswa di MAN Binong Subang. Skripsi. Bandung : Universitas

Komputer Indonesia.

Aryan, Peb Rusyono. 2010. Algoritma K-means Clustering.

http://pebbie.wordpress.com/2008/11/13/algoritma-kmeansclustering/ Diakses pada

tanggal 24 September 2013 pukul 3.38 PM dari

Pramudiono, I. 2007. Pengantar Data Mining : Menambang Permata Pengetahuan di

Gunung Data. http://www.ilmukomputer.org/wpcontent/uploads/2006/08/iko-

datamining.zip Diakses pada tanggal 24 September 2013 pukul 2.38PM

Proboyekti, Umi. Software Process Model I,

http://lecturer.ukdw.ac.id/othie/softwareprocess.pdf. Diakses pada tanggal 27

Agustus 2013 pukul 3.03 PM

Somantri, Maman, ST, MT. 2004. Pemrograman Berorientasi Objek Menggunakan Java

“Object Oriented Programming using Java”. Semarang : Universitas Diponegoro

www.geocities.ws/mmsomantri/modul1oop Diakses tanggal 20 Agustus 2013 pada

pukul 3.12PM
 178

Lampiran 1
Surat Keterangan Dosen Pembimbing
179
 180

Lampiran 2
Surat Keterangan Pelaksanaan Riset
181
 182

Lampiran 3
Hasil Wawancara
 183

WAWANCARA

Penulis melakukan wawancara pada :

Hari/Tanggal : Kamis/13 Juni 2013
Tempat : Ruang Bimbingan Konseling (BK) SMA Negeri 29 Jakarta
Narasumber : Ibu Afrianti Z. Sani, S.Pd.
Pewawancara : Luigi Ajeng Pratiwi

Pertanyaan :
1. Kapan proses peminatan dilakukan?
Jawab : Peminatan dilakukan kepada siswa yang berada di kelas X dan
akan naik ke kelas XI.

2. Bagaimana proses menentukan peminatan yang selama ini dilakukan di SMA

Negeri 29 Jakarta?
Jawab : Proses peminatan dilakukan dengan cara mengumpulkan seluruh
data siswa, baik hasil nilai kemampuan akademik siswa maupun
minat yang diinginkan siswa. Siswa melakukan konsultasi
mengenai minat yang diinginkan kepada guru BK, lalu hasil
minat siswa di catat dan di simpan oleh guru BK yang kemudian
selanjutnya di serahkan kepada masing masing wali kelas
sebagai salah satu bahan pertimbangan untuk menentukan minat
siswa yang akan naik ke kelas XI. Setelah ditentukan hasil
keputusan peminatan, wali kelas kemudian menyerahkan hasil
keputusan beserta nilai kemampuan akademik ke bagian tata
usaha (TU) untuk di simpan dan di jadikan laporan pertahun.

3. Peminatan apa saja yang ada di SMA Negeri 29 Jakarta?

Jawab :
a) Peminatan Ilmu Pengetahuan Alam (IPA)
b) Peminatan Ilmu Pengetahuan Sosial (IPS)

4. Bagaimana proses penilaian terhadap siswa sehingga ditentukan hasil akhir

untuk peminatannya?
Jawab : Proses penilaian yang dilakukan oleh wali kelas saat ini untuk
menentukan hasil keputusan akhir peminatan yaitu dilihat dari
nilai minimum 78 untuk tiap mata pelajaran pokok untuk setiap
peminatan, seperti nilai matematika, biologi, fisika, kimia untuk
 184

peminatan IPA, dan nilai sosiologi, sejarah, ekonomi, geografi

untuk peminatan IPS. Setelah syarat tersebut terpenuhi,
kemudian wali kelas membandingkan hasil pengolahan nilai
akademik dengan minat siswa yang diperoleh dari hasil
konsultasi siswa dengan guru BK.

5. Apa yang diinginkan pihak sekolah jika disediakan aplikasi penunjang keputusan
untuk peminatan bagi siswa?
Jawab : Pihak sekolah berharap adanya sebuah aplikasi yang bisa
membantu pihak sekolah dalam menentukan peminatan bagi
siswa, hal ini berguna sebagai salah satu bahan pertimbangan
untuk menentukan minat yang sesuai dengan potensi akademik
maupun minat dari siswa.

6. Bagaimana ketentuan yang diinginkan pihak sekolah jika aplikasi peminatan

terbentuk? bagaimana pengambilan keputusan yang diinginkan sehingga
menghasilkan keputusan peminatan siswa?
Jawab : Nilai minimum 78 untuk mata pelajaran pokok peminatan IPA
seperti matematika, biologi, fisika, kimia. Dan nilai minimum 78
untuk mata pelajaran pokok peminatan IPS seperti sosiologi,
sejarah, ekonomi, geografi. Setelah ketentuan tersebut terpenuhi,
kemudian wali kelas menentukan hasil peminatan siswa dengan
membandingkan hasil pengolahan nilai akademik siswa dengan
minat siswa yang di dapat dari guru BK sehingga bisa di dapat
hasil akhir peminatan bagi siswa kelas X.
 185

WAWANCARA

Penulis melakukan wawancara pada :

Hari/Tanggal : Kamis/13 Juni 2013
Tempat : Ruang Guru SMA Negeri 29 Jakarta
Narasumber : Ibu Dra. Sri Widayati
Pewawancara : Luigi Ajeng Pratiwi

Pertanyaan :
1. Kapan proses peminatan dilakukan?
Jawab : Peminatan dilakukan kepada siswa yang berada di kelas X dan
akan naik ke kelas XI.

2. Apakah pihak sekolah kesulitan dalam menentukan peminatan bagi siswa?

Jawab : Setiap siswa memiliki 17 nilai dari mata pelajaran yang berbeda,
baik untuk mata pelajaran pokok peminatan IPA, IPS maupun
mata pelajaran yang tidak termasuk kedalam kelompok
peminatan IPA, IPS, seperti Agama, Bahasa Indonesia,
Kewarganegaraan, TIK, dll. Dan setiap kelas memiliki jumlah
siswa yang tidak sedikit, minimum 35 orang siswa untuk 1 kelas.
Hal ini lah yang menyebabkan pihak sekolah khususnya wali
kelas kesulitan dalam proses penghitungan nilai akademik siswa
hingga proses untuk menentukan peminatan siswa.

3. Bagaimana proses menentukan peminatan yang selama ini dilakukan di SMA

Negeri 29 Jakarta?
Jawab : Wali kelas menghitung nilai akademik siswa khususnya pada
mata pelajaran pokok untuk peminatan IPA dan IPS. Jika telah
 186

diketahui hasilnya, kemudian wali kelas melihat hasil angket

minat siswa yang ada pada guru BK untuk selanjutnya di
bandingkan dan menjadi salah satu bahan pertimbangan untuk
keputusan akhir peminatan bagi siswa. Namun jika nilai siswa
tidak memenuhi syarat untuk masuk peminatan IPA atau IPS dan
siswa tersebut memiliki nilai tidak tuntas pada 2 mata pelajaran
atau lebih, maka siswa dinyatakan tidak naik kelas.

4. Peminatan apa saja yang ada di SMA Negeri 29 Jakarta?

Jawab :
c) Peminatan Ilmu Pengetahuan Alam (IPA) dengan mata
pelajaran pokok Matematika, Kimia, Fisika dan Biologi
d) Peminatan Ilmu Pengetahuan Sosial (IPS) dengan mata
pelajaran pokok Geografi, Sejarah, Sosiologi dan Ekonomi

5. Bagaimana proses penilaian terhadap siswa sehingga ditentukan hasil akhir

untuk peminatannya?
Jawab : Proses penilaian yang dilakukan oleh wali kelas saat ini untuk
menentukan hasil keputusan akhir peminatan yaitu dilihat dari
nilai semester 2 dengan nilai minimum 78 untuk tiap mata
pelajaran pokok untuk setiap peminatan, seperti nilai
matematika, biologi, fisika, kimia untuk peminatan IPA, dan
nilai sosiologi, sejarah, ekonomi, geografi untuk peminatan IPS.
Setelah syarat tersebut terpenuhi, kemudian wali kelas
membandingkan hasil pengolahan nilai akademik dengan minat
siswa yang diperoleh dari hasil konsultasi siswa dengan guru
BK. Jika syarat tersebut tidak terpenuhi dan siswa memiliki nilai
 187

tidak tuntas pada 2 mata pelajaran atau lebih, maka siswa tidak
bisa naik ke kelas XI.

6. Apa yang diinginkan pihak sekolah jika disediakan aplikasi penunjang

keputusan untuk peminatan bagi siswa?
Jawab : Pihak sekolah berharap adanya sebuah aplikasi yang bisa
membantu pihak sekolah khusus nya wali kelas dalam
menentukan peminatan bagi siswa, hal ini berguna sebagai salah
satu bahan pertimbangan bagi wali kelas untuk menentukan
minat yang sesuai dengan potensi akademik maupun minat dari
siswa masing masing.

7. Bagaimana ketentuan yang diingikan pihak sekolah jika aplikasi peminatan

terbentuk? bagaimana pengambilan keputusan yang diinginkan sehingga
menghasilkan keputusan peminatan siswa?
Jawab : Nilai minimum 78 untuk mata pelajaran pokok peminatan IPA
seperti matematika, biologi, fisika, kimia. Dan nilai minimum 78
untuk mata pelajaran pokok peminatan IPS seperti sosiologi,
sejarah, ekonomi, geografi. Setelah ketentuan tersebut terpenuhi,
kemudian wali kelas menentukan hasil peminatan siswa dengan
membandingkan hasil pengolahan nilai akademik siswa dengan
minat siswa sehingga bisa di dapat hasil akhir peminatan bagi
siswa kelas X. Hasil akhir peminatan siswa merupakan
keputusan yang sah dari wali kelas, karena wali kelas lah yang
mengetahui perkembangan akademik siswa bimbingannya.
 188

Lampiran 4
Source Code
 189

Controlleradmin.java

package controler;

import peminatansma.halaman_admin;

import peminatansma.hasilpeminatan_admin;

import peminatansma.inputkelas;

import peminatansma.inputuser;

import peminatansma.lihatkelas;

import peminatansma.lihatnilai_admin;

import peminatansma.lihatsiswa_admin;

import peminatansma.lihatuser;

import peminatansma.login;

public class controleradmin {

public void logout (){

new login().setVisible(true);

public void inputUser(){

new inputuser().setVisible(true);

public void lihatUser(){

new lihatuser().setVisible(true);

}
 190

public void lihatSiswa(){

new lihatsiswa_admin().setVisible(true);

public void lihatNilai(){

new lihatnilai_admin().setVisible(true);

public void InputKelas(){

new inputkelas().setVisible(true);

public void lihatKelas(){

new lihatkelas().setVisible(true);

public void lihatHasilPermintaan(){

new hasilpeminatan_admin().setVisible(true);

Controllereditnilai.java

package controler;

import javax.swing.JOptionPane;
 191

public class controlereditnilai {

public void edit(String nilaibaru){

String nis = controlerlihatnilai_user.getNis();

String kd_mp = controlerlihatnilai_user.getKd_mp();

boolean status = new model.modeleditnilai().edit(nis, kd_mp, nilaibaru);

if (status == true){

JOptionPane.showMessageDialog(null, "nilai berhasil diedit..!!");

}else{

JOptionPane.showMessageDialog(null, "gagal edit nilai");

Controllerpeminatan.java

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package controler;

import java.util.ArrayList;

import java.util.Collections;

import javax.swing.JOptionPane;

import model.modeladmin;
 192

/**

* @author user

*/

public class controlerhasilpeminatan {

int indexc1, indexc2;

ArrayList<String> matematika = new ArrayList<String>();

ArrayList<String> fisika = new ArrayList<String>();

ArrayList<String> kimia = new ArrayList<String>();

ArrayList<String> biologi = new ArrayList<String>();

ArrayList<String> ekonomi = new ArrayList<String>();

ArrayList<String> sosiologi = new ArrayList<String>();

ArrayList<String> sejarah = new ArrayList<String>();

ArrayList<String> geografi = new ArrayList<String>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<Double> C1 = new ArrayList<Double>();

ArrayList<Double> C2 = new ArrayList<Double>();

ArrayList<Double> d1 = new ArrayList<Double>();

ArrayList<Double> d2 = new ArrayList<Double>();

ArrayList<Double> g1 = new ArrayList<Double>();

ArrayList<Double> g2 = new ArrayList<Double>();

ArrayList<Double> g1baru = new ArrayList<Double>();

ArrayList<Double> g2baru = new ArrayList<Double>();

int iterasi = 1;
 193

public ArrayList<ArrayList<String>> getalldata() {

ArrayList<ArrayList<String>> datasiswa = new

model.modelhasilpeminatan().getalldata();

return datasiswa;

public ArrayList<String> initkelas() {

ArrayList<String> datakelas = new model.modelhasilpeminatan().initkelas();

return datakelas;

public ArrayList<String> inittahun() {

ArrayList<String> datatahun = new model.modelhasilpeminatan().inittahun();

return datatahun;

public ArrayList<ArrayList<String>> cari(String kelas, String tahun) {

ArrayList<ArrayList<String>> datasiswa = new model.modelhasilpeminatan().cari(kelas,

tahun);

return datasiswa;

public void hitung(String kelas, String tahun) {

ArrayList<ArrayList<String>> datasiswa = new

model.modelhasilpeminatan().hitung(kelas, tahun);

nis = datasiswa.get(0);
 194

matematika = datasiswa.get(1);

fisika = datasiswa.get(2);

kimia = datasiswa.get(3);

biologi = datasiswa.get(4);

ekonomi = datasiswa.get(5);

sosiologi = datasiswa.get(6);

sejarah = datasiswa.get(7);

geografi = datasiswa.get(8);

indexc1 = index(matematika, fisika, kimia, biologi, 1);

indexc2 = index(ekonomi, sosiologi, sejarah, geografi, 2);

System.out.println("" + indexc1 + " " + indexc2);

C1.add(Double.parseDouble(matematika.get(indexc1)));

C1.add(Double.parseDouble(fisika.get(indexc1)));

C1.add(Double.parseDouble(kimia.get(indexc1)));

C1.add(Double.parseDouble(biologi.get(indexc1)));

C1.add(Double.parseDouble(ekonomi.get(indexc1)));

C1.add(Double.parseDouble(sosiologi.get(indexc1)));

C1.add(Double.parseDouble(sejarah.get(indexc1)));

C1.add(Double.parseDouble(geografi.get(indexc1)));

C2.add(Double.parseDouble(matematika.get(indexc2)));

C2.add(Double.parseDouble(fisika.get(indexc2)));

C2.add(Double.parseDouble(kimia.get(indexc2)));

C2.add(Double.parseDouble(biologi.get(indexc2)));

C2.add(Double.parseDouble(ekonomi.get(indexc2)));
 195

C2.add(Double.parseDouble(sosiologi.get(indexc2)));

C2.add(Double.parseDouble(sejarah.get(indexc2)));

C2.add(Double.parseDouble(geografi.get(indexc2)));

for (int j = 0; j < matematika.size(); j++) {

double data1 = Math.pow((C1.get(0) - Double.parseDouble(matematika.get(j))), 2)

+ Math.pow((C1.get(1) - Double.parseDouble(fisika.get(j))), 2)

+ Math.pow((C1.get(2) - Double.parseDouble(kimia.get(j))), 2)

+ Math.pow((C1.get(3) - Double.parseDouble(biologi.get(j))), 2)

+ Math.pow((C1.get(4) - Double.parseDouble(ekonomi.get(j))), 2)

+ Math.pow((C1.get(5) - Double.parseDouble(sosiologi.get(j))), 2)

+ Math.pow((C1.get(6) - Double.parseDouble(sejarah.get(j))), 2)

+ Math.pow((C1.get(7) - Double.parseDouble(geografi.get(j))), 2);

d1.add(Math.sqrt(data1));

double data2 = Math.pow((C2.get(0) - Double.parseDouble(matematika.get(j))), 2)

+ Math.pow((C2.get(1) - Double.parseDouble(fisika.get(j))), 2)

+ Math.pow((C2.get(2) - Double.parseDouble(kimia.get(j))), 2)

+ Math.pow((C2.get(3) - Double.parseDouble(biologi.get(j))), 2)

+ Math.pow((C2.get(4) - Double.parseDouble(ekonomi.get(j))), 2)

+ Math.pow((C2.get(5) - Double.parseDouble(sosiologi.get(j))), 2)

+ Math.pow((C2.get(6) - Double.parseDouble(sejarah.get(j))), 2)

+ Math.pow((C2.get(7) - Double.parseDouble(geografi.get(j))), 2);

d2.add(Math.sqrt(data2));

}
 196

for (int k = 0; k < d1.size(); k++) {

if (d1.get(k) > d2.get(k)) {

g1.add(0.0);

g2.add(1.0);

} else if (d1.get(k) == d2.get(k)) {

g1.add(.0);

g2.add(0.0);

} else {

g1.add(1.0);

g2.add(0.0);

nextIteration();

System.out.println("iterasi = " + iterasi + "\n" + g1 + "\n" + g2 + "\n" + g1baru + "\n" +

g2baru);

iterasi++;

while ((g1 != g1baru && g2 != g2baru) && iterasi < 50) {

g1.clear();

g2.clear();

g1 = g1baru;

g2 = g2baru;
 197

nextIteration();

System.out.println("iterasi = " + iterasi + "\n" + g1 + "\n" + g2 + "\n" + g1baru + "\n" +

g2baru);

iterasi = iterasi + 1;

System.out.println(nis.size());

boolean status = new model.modelhasilpeminatan().inputhasilpenjurusan(nis, d1, d2);

if (status == true) {

JOptionPane.showMessageDialog(null, "K-Means berhasil dihitung");

} else {

JOptionPane.showMessageDialog(null, "K-Means gagal dihitung");

public void nextIteration() {

double jumlah1 = 0.0, nmatematika1 = 0.0, nfisika1 = 0.0, nkimia1 = 0.0, nbiologi1 = 0.0,
nekonomi1 = 0.0, nsosiologi1 = 0.0, nsejarah1 = 0.0, ngeografi1 = 0.0;

double jumlah2 = 0.0, nmatematika2 = 0.0, nfisika2 = 0.0, nkimia2 = 0.0, nbiologi2 = 0.0,
nekonomi2 = 0.0, nsosiologi2 = 0.0, nsejarah2 = 0.0, ngeografi2 = 0.0;

// System.out.println(g1+"\n"+g2);

for (int g = 0; g < g1.size(); g++) {

if (g1.get(g) == 1.0) {
 198

jumlah1 = jumlah1 + g1.get(g);

nmatematika1 = nmatematika1 + Double.parseDouble(matematika.get(g));

nfisika1 = nfisika1 + Double.parseDouble(fisika.get(g));

nkimia1 = nkimia1 + Double.parseDouble(kimia.get(g));

nbiologi1 = nbiologi1 + Double.parseDouble(biologi.get(g));

nekonomi1 = nekonomi1 + Double.parseDouble(ekonomi.get(g));

nsosiologi1 = nsosiologi1 + Double.parseDouble(sosiologi.get(g));

nsejarah1 = nsejarah1 + Double.parseDouble(sejarah.get(g));

ngeografi1 = ngeografi1 + Double.parseDouble(geografi.get(g));

} else if (g2.get(g) == 1.0) {

jumlah2 = jumlah2 + g2.get(g);

nmatematika2 = nmatematika2 + Double.parseDouble(matematika.get(g));;

nfisika2 = nfisika2 + Double.parseDouble(fisika.get(g));

nkimia2 = nkimia2 + Double.parseDouble(kimia.get(g));

nbiologi2 = nbiologi2 + Double.parseDouble(biologi.get(g));

nekonomi2 = nekonomi2 + Double.parseDouble(ekonomi.get(g));

nsosiologi2 = nsosiologi2 + Double.parseDouble(sosiologi.get(g));

nsejarah2 = nsejarah2 + Double.parseDouble(sejarah.get(g));

ngeografi2 = ngeografi2 + Double.parseDouble(geografi.get(g));

C1.clear();

C2.clear();

Collections.addAll(C1, nmatematika1 / jumlah1,

nfisika1 / jumlah1,

nkimia1 / jumlah1,
 199

nbiologi1 / jumlah1,

nekonomi1 / jumlah1,

nsosiologi1 / jumlah1,

nsejarah1 / jumlah1,

ngeografi1 / jumlah1);

Collections.addAll(C2, nmatematika2 / jumlah2,

nfisika2 / jumlah2,

nkimia2 / jumlah2,

nbiologi2 / jumlah2,

nekonomi2 / jumlah2,

nsosiologi2 / jumlah2,

nsejarah2 / jumlah2,

ngeografi2 / jumlah2);

// System.out.println(C1+"\n"+C2);

d1.clear();

d2.clear();

for (int j = 0; j < matematika.size(); j++) {

double data1 = Math.pow((C1.get(0) - Double.parseDouble(matematika.get(j))), 2)

+ Math.pow((C1.get(1) - Double.parseDouble(fisika.get(j))), 2)

+ Math.pow((C1.get(2) - Double.parseDouble(kimia.get(j))), 2)

+ Math.pow((C1.get(3) - Double.parseDouble(biologi.get(j))), 2)

+ Math.pow((C1.get(4) - Double.parseDouble(ekonomi.get(j))), 2)

+ Math.pow((C1.get(5) - Double.parseDouble(sosiologi.get(j))), 2)

+ Math.pow((C1.get(6) - Double.parseDouble(sejarah.get(j))), 2)

+ Math.pow((C1.get(7) - Double.parseDouble(geografi.get(j))), 2);

d1.add(Math.sqrt(data1));
 200

double data2 = Math.pow((C2.get(0) - Double.parseDouble(matematika.get(j))), 2)

+ Math.pow((C2.get(1) - Double.parseDouble(fisika.get(j))), 2)

+ Math.pow((C2.get(2) - Double.parseDouble(kimia.get(j))), 2)

+ Math.pow((C2.get(3) - Double.parseDouble(biologi.get(j))), 2)

+ Math.pow((C2.get(4) - Double.parseDouble(ekonomi.get(j))), 2)

+ Math.pow((C2.get(5) - Double.parseDouble(sosiologi.get(j))), 2)

+ Math.pow((C2.get(6) - Double.parseDouble(sejarah.get(j))), 2)

+ Math.pow((C2.get(7) - Double.parseDouble(geografi.get(j))), 2);

d2.add(Math.sqrt(data2));

g1baru.clear();

g2baru.clear();

for (int k = 0; k < d1.size(); k++) {

if (d1.get(k) > d2.get(k)) {

g1baru.add(0.0);

g2baru.add(1.0);

} else if (d1.get(k) == d2.get(k)) {

g1baru.add(0.0);

g2baru.add(0.0);

} else {

g1baru.add(1.0);

g2baru.add(0.0);

}
 201

public ArrayList<ArrayList<String>> refresh() {

ArrayList<ArrayList<String>> data = new model.modelhasilpeminatan().refresh();

return data;

public int index(ArrayList<String> a, ArrayList<String> b, ArrayList<String> c,

ArrayList<String> d, int id) {

int penandaIndex = 0;

double penanda = 78*4;

if (id == 1) {

for (int i = 0; i < a.size(); i++) {

if ((Double.parseDouble(a.get(i))

+ Double.parseDouble(b.get(i))

+ Double.parseDouble(c.get(i))

+ Double.parseDouble(d.get(i))) > penanda) {

penanda = Double.parseDouble(a.get(i))

+ Double.parseDouble(b.get(i))

+ Double.parseDouble(c.get(i))

+ Double.parseDouble(d.get(i));

penandaIndex = i;

}
 202

if (id == 2) {

for (int i = 0; i < a.size(); i++) {

if (i != indexc1) {

if ((Double.parseDouble(a.get(i))

+ Double.parseDouble(b.get(i))

+ Double.parseDouble(c.get(i))

+ Double.parseDouble(d.get(i))) < penanda) {

penanda = Double.parseDouble(a.get(i))

+ Double.parseDouble(b.get(i))

+ Double.parseDouble(c.get(i))

+ Double.parseDouble(d.get(i));

penandaIndex = i;

return penandaIndex;

public String [] getTrueFalse(){

String [] data = new model.modelhasilpeminatan().getTrueFalse();

return data;

}
 203

public ArrayList<ArrayList<String>> pengujian (){

ArrayList<ArrayList<String>> data = new model.modelhasilpeminatan().pengujian();

System.out.println(data.get(4));

return data;

public void clearLog (String kelas, String thn_ajaran){

boolean status = new model.modelhasilpeminatan().clearLog(kelas, thn_ajaran);

if(status == true){

JOptionPane.showMessageDialog(null, "sukses Clear Log");

}else{

JOptionPane.showMessageDialog(null, "gagal Clear Log");

Controllerinputnilai.java

package controler;
 204

import java.util.ArrayList;

import model.modelinputnilai;

public class controlerinputnilai {

public ArrayList<String> getNis(){

ArrayList<String> nis = new model.modelinputnilai().getNis();

return nis;

public void simpan(String nis, ArrayList<Double> nilai){

model.modelinputnilai min = new modelinputnilai();

String user = controlerlogin.getUsernameUser();

for(int i = 0 ; i<nilai.size() ; i++){

min.simpan(nis, i+1, nilai.get(i), user);

Controllerinputsiswa.java

package controler;

import java.util.ArrayList;

import javax.swing.JOptionPane;

public class controlerinputsiswa {

public ArrayList<String> getKelas(){

 205

ArrayList<String> kelas = new model.modelinputsiswa().getKelas();

return kelas;

public ArrayList<String> getTahunAjaran(){

ArrayList<String> tahun = new model.modelinputsiswa().getTahunAjaran();

return tahun;

public void inputSiswa(String nis, String nama, String kelamin, String kelas, String
tahunajaran){

boolean status = new model.modelinputsiswa().inputSiswa(nis, nama, kelamin, kelas,

tahunajaran);

if(status == true){

JOptionPane.showMessageDialog(null, "data berhasis di input");

}else{

JOptionPane.showMessageDialog(null, "Gagal input siswa, mungkin NIS sudah

pernah di input sebelumnya.");

public void editSiswa(String nis, String nama, String kelamin, String kelas, String
tahunajaran){

boolean status = new model.modelinputsiswa().editSiswa(nis, nama, kelamin, kelas,

tahunajaran);

if(status == true){

JOptionPane.showMessageDialog(null, "data berhasis diupdate");

 206

}else{

JOptionPane.showMessageDialog(null, "Gagal update siswa");

Controllerinputuser.java

package controler;

import javax.swing.JOptionPane;

public class controlerinputuser {

public void submit (String Username, String Password, String Level){

boolean proses = new model.modelinputuser().submit(Username, Password, Level);

if(proses == true){

JOptionPane.showMessageDialog(null, "Input User Sukses");

}else{

JOptionPane.showMessageDialog(null, "Input Gagal, Nama User Telah Digunakan

Sebelumnya");

}
 207

public void edit (String Username, String Password, String Level){

boolean proses = new model.modelinputuser().edit(Username, Password, Level);

if(proses == true){

JOptionPane.showMessageDialog(null, "Update User Sukses");

Controllerlihatuser.java

package controler;

import java.util.ArrayList;

import javax.swing.JOptionPane;

import peminatansma.inputuser;

public class controlerlihatuser {

public static String Username, Password;

public static boolean edit;

public ArrayList<ArrayList<String>> datauser(){

ArrayList<ArrayList<String>> data = new model.modellihatuser().datauser();

return data;

}
 208

public void edit (String Username, String Password){

this.Username = Username; this.Password = Password;

edit = true;

inputuser iu = new inputuser();

iu.setVisible(true);

public void hapus(String Username){

boolean status = new model.modellihatuser().hapus(Username);

if(status == true){

JOptionPane.showMessageDialog(null, "User telah dihapus");

}else{

JOptionPane.showMessageDialog(null, "Gagal dihapus");

public void setEdit(){

edit = false;

Controllerlogin.java

package controler;

import javax.swing.JOptionPane;
 209

import model.modellogin;

import peminatansma.halaman_admin;

import peminatansma.halaman_user;

import peminatansma.login;

public class controlerlogin {

public static String UsernameUser;

public static String getUsernameUser() {

return UsernameUser;

public static void setUsernameUser(String UsernameUser) {

controlerlogin.UsernameUser = UsernameUser;

public void login(String Username, String Password) {

String hak = new modellogin().login(Username, Password);

if (hak.equals("admin")) {

new halaman_admin().setVisible(true);

} else if (hak.equals("user")) {

new halaman_user().setVisible(true);

setUsernameUser(Username);

} else {

JOptionPane.showMessageDialog(null, "Username atau password Anda salah..");

new login().setVisible(true);

}
 210

Controlleruser.java

package controler;

import peminatansma.hasilpeminatan;

import peminatansma.inputnilai;

import peminatansma.inputsiswa;

import peminatansma.lihatnilai_user;

import peminatansma.lihatsiswa_user;

import peminatansma.login;

public class controleruser {

public void logout(){

new login().setVisible(true);

public void tambahSiswa(){

new inputsiswa().setVisible(true);

public void lihatSiswa(){

 211

new lihatsiswa_user().setVisible(true);

public void inputNilai(){

new inputnilai().setVisible(true);

public void lihatNilai(){

new lihatnilai_user().setVisible(true);

public void hasilPeminatan(){

new hasilpeminatan().setVisible(true);

Db_Connect.java

package model;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;
 212

public class Db_Connect {

Connection con;

Statement stat;

public Db_Connect() throws ClassNotFoundException, SQLException {

Class.forName("com.mysql.jdbc.Driver");

con = DriverManager.getConnection("jdbc:mysql://localhost/jurusansma", "root", "");

stat = con.createStatement();

public Connection getCon() {

return con;

public Statement getStat() {

return stat;

public void close() throws SQLException{

con.close();

stat.close();

}
 213

Modeladmin.java

package model;

public class modeladmin {

Modelnilai.java

package model;

import java.sql.SQLException;

import java.util.logging.Level;

import java.util.logging.Logger;

public class modeleditnilai {

public boolean edit(String nis, String kd_mp, String nilaibaru) {

try {

Db_Connect dc = new Db_Connect();

dc.stat.executeUpdate("update nilai set nilai= '"+nilaibaru+"' where nis = '"+nis+"' and

kd_mp = '"+kd_mp+"'");

return true;
 214

} catch (ClassNotFoundException ex) {

Logger.getLogger(modeleditnilai.class.getName()).log(Level.SEVERE, null, ex);

return false;

} catch (SQLException ex) {

Logger.getLogger(modeleditnilai.class.getName()).log(Level.SEVERE, null, ex);

return false;

Modelhasilpeminatan.java

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.logging.Level;
 215

import java.util.logging.Logger;

/**

* @author user

*/

public class modelhasilpeminatan {

public ArrayList<ArrayList<String>> getalldata() {

ArrayList<ArrayList<String>> datasiswa = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> nama = new ArrayList<String>();

ArrayList<String> kd_kelas = new ArrayList<String>();

ArrayList<String> kelas = new ArrayList<String>();

ArrayList<String> c1 = new ArrayList<String>();

ArrayList<String> c2 = new ArrayList<String>();

ArrayList<String> kd_jurusan = new ArrayList<String>();

ArrayList<String> jurusan = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select * from siswa");

while (rs.next()) {

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

kd_kelas.add(rs.getString("kd_kelas"));

c1.add(rs.getString("c1"));
 216

c2.add(rs.getString("c2"));

kd_jurusan.add(rs.getString("kd_jurusan"));

for (int i = 0; i < kd_kelas.size(); i++) {

rs = dc.getStat().executeQuery("select kelas from kelas where kd_kelas = '" +

kd_kelas.get(i) + "'");

while (rs.next()) {

kelas.add(rs.getString("kelas"));

if (!kd_jurusan.get(i).equals("")) {

rs = dc.getStat().executeQuery("select jurusan from jurusan where kd_jurusan =

'" + kd_jurusan.get(i) + "'");

while (rs.next()) {

jurusan.add(rs.getString("jurusan"));

}else{

jurusan.add("");

dc.close();

Collections.addAll(datasiswa, nis, nama, kelas, c1, c2, jurusan);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);
 217

return datasiswa;

public ArrayList<String> initkelas() {

ArrayList<String> datakelas = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select kelas from kelas");

while (rs.next()) {

datakelas.add(rs.getString("kelas"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return datakelas;

public ArrayList<String> inittahun() {

 218

ArrayList<String> datatahun = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select thn_ajaran from thn_ajaran");

while (rs.next()) {

datatahun.add(rs.getString("thn_ajaran"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return datatahun;

public ArrayList<ArrayList<String>> cari(String cKelas, String cTahun){

ArrayList<ArrayList<String>> datasiswa = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> nama = new ArrayList<String>();

ArrayList<String> kd_kelas = new ArrayList<String>();

ArrayList<String> kelas = new ArrayList<String>();

ArrayList<String> c1 = new ArrayList<String>();

ArrayList<String> c2 = new ArrayList<String>();

 219

ArrayList<String> kd_jurusan = new ArrayList<String>();

ArrayList<String> jurusan = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

String kd_kelass="", kd_thnajarann="";

ResultSet rs = dc.getStat().executeQuery("select kd_kelas from kelas where kelas =

'"+cKelas+"'");

while (rs.next()) {

kd_kelass = rs.getString("kd_kelas");

rs = dc.getStat().executeQuery("select kd_thnajaran from thn_ajaran where

thn_ajaran = '"+cTahun+"'");

while (rs.next()) {

kd_thnajarann = rs.getString("kd_thnajaran");

rs = dc.getStat().executeQuery("select * from siswa where kd_kelas = '"+kd_kelass+"'

and kd_thnajaran = '"+kd_thnajarann+"'");

while (rs.next()) {

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

kd_kelas.add(rs.getString("kd_kelas"));

c1.add(rs.getString("c1"));

c2.add(rs.getString("c2"));

kd_jurusan.add(rs.getString("kd_jurusan"));

for (int i = 0; i < kd_kelas.size(); i++) {

 220

rs = dc.getStat().executeQuery("select kelas from kelas where kd_kelas = '" +

kd_kelas.get(i) + "'");

while (rs.next()) {

kelas.add(rs.getString("kelas"));

if (!kd_jurusan.get(i).equals("")) {

rs = dc.getStat().executeQuery("select jurusan from jurusan where kd_jurusan =

'" + kd_jurusan.get(i) + "'");

while (rs.next()) {

jurusan.add(rs.getString("jurusan"));

}else{

jurusan.add("");

dc.close();

Collections.addAll(datasiswa, nis, nama, kelas, c1, c2, jurusan);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return datasiswa;

}
 221

public ArrayList<ArrayList<String>> hitung (String kelas, String tahun){

ArrayList<ArrayList<String>> datasiswa = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> matematika = new ArrayList<String>();

ArrayList<String> fisika = new ArrayList<String>();

ArrayList<String> kimia = new ArrayList<String>();

ArrayList<String> biologi = new ArrayList<String>();

ArrayList<String> ekonomi = new ArrayList<String>();

ArrayList<String> sosiologi = new ArrayList<String>();

ArrayList<String> sejarah = new ArrayList<String>();

ArrayList<String> geografi = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

String kd_kelass="", kd_thnajarann="";

ResultSet rs = dc.getStat().executeQuery("select kd_kelas from kelas where kelas =

'"+kelas+"'");

while (rs.next()) {

kd_kelass = rs.getString("kd_kelas");

rs = dc.getStat().executeQuery("select kd_thnajaran from thn_ajaran where

thn_ajaran = '"+tahun+"'");

while (rs.next()) {

kd_thnajarann = rs.getString("kd_thnajaran");

}
 222

rs = dc.getStat().executeQuery("select distinct nis from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"'");

while (rs.next()) {

nis.add(rs.getString("nis"));

System.out.println(nis);

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 1");

while (rs.next()) {

matematika.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 2");

while (rs.next()) {

fisika.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 3");

while (rs.next()) {

kimia.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 4");

while (rs.next()) {

biologi.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 5");
 223

while (rs.next()) {

ekonomi.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 6");

while (rs.next()) {

sosiologi.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 7");

while (rs.next()) {

sejarah.add(rs.getString("nilai"));

rs = dc.getStat().executeQuery("select nilai from nilai where kd_kelas =

'"+kd_kelass+"' and kd_thnajaran = '"+kd_thnajarann+"' and kd_mp = 8");

while (rs.next()) {

geografi.add(rs.getString("nilai"));

dc.close();

Collections.addAll(datasiswa, nis, matematika, fisika, kimia, biologi, ekonomi,

sosiologi, sejarah, geografi);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

}
 224

return datasiswa;

public boolean clearLog(String kelas, String tahun){

try {

Db_Connect dc = new Db_Connect();

String kd_kelass="", kd_thnajarann="";

ResultSet rs = dc.getStat().executeQuery("select kd_kelas from kelas where kelas

= '"+kelas+"'");

while (rs.next()) {

kd_kelass = rs.getString("kd_kelas");

rs = dc.getStat().executeQuery("select kd_thnajaran from thn_ajaran where

thn_ajaran = '"+tahun+"'");

while (rs.next()) {

kd_thnajarann = rs.getString("kd_thnajaran");

dc.getStat().executeUpdate("UPDATE siswa SET c1 = '', c2 = '', kd_jurusan = ''

WHERE kd_kelas = '"+kd_kelass+"' AND kd_thnajaran = '"+kd_thnajarann+"' ");

dc.getStat().executeUpdate("update pengujian set kd_jurusan = '', keterangan = ''

where kd_kelas = '"+kd_kelass+"'");

return true;

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return false;
 225

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return false;

public boolean inputhasilpenjurusan(ArrayList<String> nis, ArrayList<Double>c1,

ArrayList<Double>c2){

try {

Db_Connect dc = new Db_Connect();

System.out.println(nis.size());

// ArrayList<String>manual = new ArrayList<String>();

// ArrayList<String>kd = new ArrayList<String>();

for(int i = 0 ; i < nis.size() ; i++){

if(c1.get(i)>c2.get(i)){

dc.getStat().executeUpdate("update siswa set c1 = '"+c1.get(i) +"', c2 =

'"+c2.get(i) +"', kd_jurusan = '2' where nis = '"+nis.get(i)+"'");

dc.getStat().executeUpdate("update pengujian set kd_jurusan = '2' where nis =

'"+nis.get(i)+"'");

}else{

dc.getStat().executeUpdate("update siswa set c1 = '"+c1.get(i) +"', c2 =

'"+c2.get(i) +"', kd_jurusan = '1' where nis = '"+nis.get(i)+"'");

dc.getStat().executeUpdate("update pengujian set kd_jurusan = '1' where nis =

'"+nis.get(i)+"'");

InsertTrueFalse(nis.get(i));
 226

return true;

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return false;

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return false;

public void InsertTrueFalse(String nis){

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select manual, kd_jurusan from pengujian

where nis = '" + nis + "'");

if (rs.next()) {

String manual = "";

String kode = "";

System.out.println(rs.getString("manual"));

if (rs.getString("manual").equals("IPA")) {

manual = "1";

} else if (rs.getString("manual").equals("IPS")) {

manual = "2";
 227

kode = rs.getString("kd_jurusan");

if (kode.equals(manual)) {

dc.getStat().executeUpdate("update pengujian set keterangan = 'true' where

nis = '" + nis + "'");

} else {

dc.getStat().executeUpdate("update pengujian set keterangan = 'false' where

nis = '" + nis + "'");

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

public ArrayList<ArrayList<String>>refresh(){

ArrayList<ArrayList<String>>data = new ArrayList<ArrayList<String>>();

ArrayList<String> kd_jurusan = new ArrayList<String>();

ArrayList<String> jurusan = new ArrayList<String>();

ArrayList<String> jumlah = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select * from jurusan");

 228

while(rs.next()){

kd_jurusan.add(rs.getString("kd_jurusan"));

jurusan.add(rs.getString("jurusan"));

rs = dc.getStat().executeQuery("select count(kd_jurusan) as jumlah from siswa where

kd_jurusan = '1'");

while(rs.next()){

jumlah.add(rs.getString("jumlah"));

rs = dc.getStat().executeQuery("select count(kd_jurusan) as jumlah from siswa where

kd_jurusan = '2'");

while(rs.next()){

jumlah.add(rs.getString("jumlah"));

Collections.addAll(data, kd_jurusan, jurusan, jumlah);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return data;

public String [] getTrueFalse(){

String [] data = new String[2];

 229

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select count(keterangan) from pengujian

where keterangan = 'true'");

while(rs.next()){

data[0] = rs.getString("count(keterangan)");

rs = dc.getStat().executeQuery("select count(keterangan) from pengujian where

keterangan = 'false'");

while(rs.next()){

data[1] = rs.getString("count(keterangan)");

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

return data;

public ArrayList<ArrayList<String>> pengujian (){

ArrayList<ArrayList<String>> data = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> nama = new ArrayList<String>();

ArrayList<String> kd_kelas = new ArrayList<String>();

 230

ArrayList<String> kelasss = new ArrayList<String>();

ArrayList<String> kd_jurusan = new ArrayList<String>();

ArrayList<String> manual = new ArrayList<String>();

ArrayList<String> jurusan = new ArrayList<String>();

ArrayList<String> keterangan = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select * from pengujian");

while(rs.next()){

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

kd_kelas.add(rs.getString("kd_kelas"));

manual.add(rs.getString("manual"));

kd_jurusan.add(rs.getString("kd_jurusan"));

keterangan.add(rs.getString("keterangan"));

for(int i = 0 ; i<kd_kelas.size() ; i++){

rs = dc.getStat().executeQuery("select kelas from kelas where kd_kelas =

'"+kd_kelas.get(i)+"'");

while(rs.next()){

kelasss.add(rs.getString("kelas"));

if(kd_jurusan.get(i).equals("")){

jurusan.add("");
 231

}else{

rs = dc.getStat().executeQuery("select jurusan from jurusan where kd_jurusan =

'"+kd_jurusan.get(i)+"'");

while(rs.next()){

jurusan.add(rs.getString("jurusan"));

}}

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modelhasilpeminatan.class.getName()).log(Level.SEVERE, null,
ex);

Collections.addAll(data, nis, nama, kelasss, manual, jurusan, keterangan);

return data;

Modelinputsiswa.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;
 232

import java.util.logging.Level;

import java.util.logging.Logger;

public class modelinputsiswa {

public ArrayList<String> getKelas(){

ArrayList<String> kelas = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select kelas from kelas");

while(rs.next()){

kelas.add(rs.getString("kelas"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return kelas;

public ArrayList<String> getTahunAjaran(){

ArrayList<String> tahun = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select thn_ajaran from thn_ajaran");

 233

while(rs.next()){

tahun.add(rs.getString("thn_ajaran"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return tahun;

public boolean inputSiswa(String nis, String nama, String kelamin, String kelas, String
tahunajaran){

String kd_kelas = "", kd_thnajaran = "";

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select kd_kelas from kelas where kelas =

'"+kelas+"'");

while(rs.next()){

kd_kelas = rs.getString("kd_kelas");

System.out.println(kd_kelas);

rs = dc.stat.executeQuery("select kd_thnajaran from thn_ajaran where thn_ajaran =

'"+tahunajaran+"'");

while(rs.next()){

kd_thnajaran = rs.getString("kd_thnajaran");
 234

if(kd_kelas.equals("")||kd_thnajaran.equals("")){

dc.close();

return false;

}else{

dc.stat.executeUpdate("insert into siswa values

('"+nis+"','"+nama+"','"+kelamin+"','"+kd_kelas+"','"+kd_thnajaran+"', '', '', '')");

dc.close();

return true;

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return false;

} catch (SQLException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return false;

public boolean editSiswa(String nis, String nama, String kelamin, String kelas, String
tahunajaran){

String kd_kelas = "", kd_thnajaran = "";

try {

Db_Connect dc = new Db_Connect();

 235

ResultSet rs = dc.stat.executeQuery("select kd_kelas from kelas where kelas =

'"+kelas+"'");

while(rs.next()){

kd_kelas = rs.getString("kd_kelas");

System.out.println(kd_kelas);

rs = dc.stat.executeQuery("select kd_thnajaran from thn_ajaran where thn_ajaran =

'"+tahunajaran+"'");

while(rs.next()){

kd_thnajaran = rs.getString("kd_thnajaran");

if(kd_kelas.equals("")||kd_thnajaran.equals("")){

dc.close();

return false;

}else{

dc.stat.executeUpdate("update siswa set nama = '"+nama+"',jenis_kelamin =

'"+kelamin+"',kd_kelas = '"+kd_kelas+"', kd_thnajaran = '"+kd_thnajaran+"' where nis =
'"+nis+"'");

dc.close();

return true;

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return false;
 236

} catch (SQLException ex) {

Logger.getLogger(modelinputsiswa.class.getName()).log(Level.SEVERE, null, ex);

return false;

Modelinputuser.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.logging.Level;

import java.util.logging.Logger;

public class modelinputuser {

public boolean submit(String Username, String Password, String level) {

String validating = "";

try {

Db_Connect dc = new Db_Connect();

ResultSet re = dc.stat.executeQuery("select username from user where username =

'" + Username + "'");

while (re.next()) {

validating = re.getString("username");
 237

if (validating.equals("")) {

dc.stat.executeUpdate("insert into user values ('" + Username + "','" + Password +

"','" + level + "')");

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputuser.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modelinputuser.class.getName()).log(Level.SEVERE, null, ex);

if (validating.equals("")) {

return true;

} else {

return false;

public boolean edit(String Username, String Password, String level) {

try {

Db_Connect dc = new Db_Connect();

dc.stat.executeUpdate("update user set password = '"+Password+"', hak_akses =

'"+level+"' where username ='"+Username+"'" );

dc.close();
 238

} catch (ClassNotFoundException ex) {

Logger.getLogger(modelinputuser.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modelinputuser.class.getName()).log(Level.SEVERE, null, ex);

return true;

Modellihatnilai_user.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

* @author user

*/
 239

public class modellihatnilai_user {

public ArrayList<String> getNisData (){

ArrayList<String> nis = new ArrayList<String>();

Db_Connect dc;

try {

dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select nis from siswa");

while(rs.next()){

nis.add(rs.getString("nis"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

return nis;

public ArrayList<ArrayList<String>>nilaisiswa(){

ArrayList<ArrayList<String>>data = new ArrayList<ArrayList<String>>();

ArrayList<String>nis = new ArrayList<String>();

ArrayList<String>nama = new ArrayList<String>();

ArrayList<String>matapelajaran = new ArrayList<String>();

ArrayList<String>nilai = new ArrayList<String>();

try {
 240

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("SELECT nilai.nis, siswa.nama,

matapelajaran.matapelajaran, nilai.nilai FROM nilai LEFT JOIN matapelajaran ON `kd_mp` =
matapelajaran.kd_matapelajaran LEFT JOIN siswa ON nilai.nis = siswa.nis");

while(rs.next()){

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

matapelajaran.add(rs.getString("matapelajaran"));

nilai.add(rs.getString("nilai"));

Collections.addAll(data, nis, nama, matapelajaran, nilai);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

return data;

public ArrayList<String> cari(String nis){

ArrayList<String> data = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("SELECT nilai.nis, siswa.nama,

matapelajaran.matapelajaran, nilai.nilai FROM nilai LEFT JOIN matapelajaran ON `kd_mp` =
matapelajaran.kd_matapelajaran LEFT JOIN siswa ON nilai.nis = siswa.nis where nilai.nis =
'"+nis+"'");

while(rs.next()){
 241

data.add(rs.getString("nis"));

data.add(rs.getString("nama"));

data.add(rs.getString("matapelajaran"));

data.add(rs.getString("nilai"));

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

return data;

public String kd_mp(String mp){

String kd_mp="";

try {

Db_Connect dc = new Db_Connect();

ResultSet rs= dc.getStat().executeQuery("select kd_matapelajaran from

matapelajaran where matapelajaran = '"+mp+"'");

while(rs.next()){

kd_mp = rs.getString("kd_matapelajaran");

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

 242

Logger.getLogger(modellihatnilai_user.class.getName()).log(Level.SEVERE, null, ex);

return kd_mp;

Modellihatsiswa_user.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.logging.Level;

import java.util.logging.Logger;

public class modellihatsiswa_user {

public ArrayList<String> getKelasData (){

ArrayList<String> kelas = new ArrayList<String>();

Db_Connect dc;

try {

dc = new Db_Connect();
 243

ResultSet rs = dc.stat.executeQuery("select kelas from kelas");

while(rs.next()){

kelas.add(rs.getString("kelas"));

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

return kelas;

public ArrayList<ArrayList<String>> datasiswa(){

ArrayList<ArrayList<String>> data = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> nama = new ArrayList<String>();

ArrayList<String> jenis_kelamin = new ArrayList<String>();

ArrayList<String> kelas = new ArrayList<String>();

ArrayList<String> thn_ajaran = new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("SELECT nis, nama, jenis_kelamin, kelas.kelas,

thn_ajaran.thn_ajaran FROM siswa LEFT JOIN kelas ON siswa.kd_kelas = kelas.kd_kelas
LEFT JOIN thn_ajaran ON siswa.kd_thnajaran = thn_ajaran.kd_thnajaran");
 244

while(rs.next()){

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

jenis_kelamin.add(rs.getString("jenis_kelamin"));

kelas.add(rs.getString("kelas"));

thn_ajaran.add(rs.getString("thn_ajaran"));

dc.close();

Collections.addAll(data, nis, nama, jenis_kelamin, kelas, thn_ajaran);

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

return data;

public ArrayList<ArrayList<String>> cari (String kelas){

ArrayList <ArrayList<String>> data = new ArrayList<ArrayList<String>>();

ArrayList<String> nis = new ArrayList<String>();

ArrayList<String> nama = new ArrayList<String>();

ArrayList<String> jenis_kelamin = new ArrayList<String>();

ArrayList<String> kelass = new ArrayList<String>();

ArrayList<String> thn_ajaran = new ArrayList<String>();

 245

String kd_kelas = "";

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select kd_kelas from kelas where kelas =

'"+kelas+"'");

while(rs.next()){

kd_kelas = rs.getString("kd_kelas");

rs = dc.stat.executeQuery("SELECT nis, nama, jenis_kelamin, kelas.kelas,

thn_ajaran.thn_ajaran FROM siswa LEFT JOIN kelas ON siswa.kd_kelas = kelas.kd_kelas
LEFT JOIN thn_ajaran ON siswa.kd_thnajaran = thn_ajaran.kd_thnajaran where
siswa.kd_kelas = '"+kd_kelas+"'");

while(rs.next()){

nis.add(rs.getString("nis"));

nama.add(rs.getString("nama"));

jenis_kelamin.add(rs.getString("jenis_kelamin"));

kelass.add(rs.getString("kelas"));

thn_ajaran.add(rs.getString("thn_ajaran"));

Collections.addAll(data, nis, nama, jenis_kelamin, kelass, thn_ajaran);

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

}
 246

return data;

public void hapusSiswa(String nis){

try {

Db_Connect dc = new Db_Connect();

dc.stat.executeUpdate("delete from siswa where nis = '"+nis+"'");

dc.stat.executeUpdate("delete from nilai where nis = '"+nis+"'");

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatsiswa_user.class.getName()).log(Level.SEVERE, null,
ex);

Modellihatuser.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;
 247

import java.util.ArrayList;

import java.util.logging.Level;

import java.util.logging.Logger;

public class modellihatuser {

public ArrayList<ArrayList<String>> datauser(){

ArrayList<ArrayList<String>> data = new ArrayList<ArrayList<String>>();

ArrayList<String>username = new ArrayList<String>();

ArrayList<String>password= new ArrayList<String>();

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.stat.executeQuery("select username, password from user");

while(rs.next()){

username.add(rs.getString("username"));

password.add(rs.getString("password"));

data.add(username);data.add(password);

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatuser.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modellihatuser.class.getName()).log(Level.SEVERE, null, ex);

return data;

}
 248

public boolean hapus(String Username){

try {

Db_Connect dc = new Db_Connect();

dc.stat.executeUpdate("delete from user where username = '"+Username+"'");

dc.close();

return true;

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellihatuser.class.getName()).log(Level.SEVERE, null, ex);

return false;

} catch (SQLException ex) {

Logger.getLogger(modellihatuser.class.getName()).log(Level.SEVERE, null, ex);

return false;

Modellogin.java

package model;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.logging.Level;

import java.util.logging.Logger;
 249

public class modellogin {

public String login (String Username, String Password){

String hak="";

try {

Db_Connect dc = new Db_Connect();

ResultSet rs = dc.getStat().executeQuery("select hak_akses from user where

username = '"+Username+"' and password = '"+Password+"'");

while(rs.next()){

hak = rs.getString("hak_akses");

dc.close();

} catch (ClassNotFoundException ex) {

Logger.getLogger(modellogin.class.getName()).log(Level.SEVERE, null, ex);

} catch (SQLException ex) {

Logger.getLogger(modellogin.class.getName()).log(Level.SEVERE, null, ex);

return hak;

Editnilai.java

package peminatansma;
 250

import java.awt.event.ActionEvent;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JTextField;

/**

* @author user

*/

public class editnilai extends javax.swing.JFrame {

/** Creates new form editnilai */

public editnilai() {

initComponents();

mp.setText(controler.controlerlihatnilai_user.getMp());

nilai.setText(controler.controlerlihatnilai_user.getNilai());

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")
 251

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

mp = new javax.swing.JLabel();

nilai = new javax.swing.JTextField();

edit = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

mp.setText("jLabel1");

nilai.setText("jTextField1");

edit.setText("edit");

edit.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

editActionPerformed(evt);

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()
 252

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)

.addComponent(edit)

.addGroup(layout.createSequentialGroup()

.addComponent(mp, javax.swing.GroupLayout.PREFERRED_SIZE, 98,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(nilai, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)))

.addContainerGap(30, Short.MAX_VALUE))

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)

.addComponent(mp)

.addComponent(nilai, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(edit)

.addContainerGap(48, Short.MAX_VALUE))

);

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

setBounds((screenSize.width-231)/2, (screenSize.height-146)/2, 231, 146);

}// </editor-fold>
 253

private void editActionPerformed(java.awt.event.ActionEvent evt) {

new controler.controlereditnilai().edit(nilai.getText());

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and
feel.

* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

*/

try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {

if ("Nimbus".equals(info.getName())) {

javax.swing.UIManager.setLookAndFeel(info.getClassName());

break;

} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(editnilai.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
 254

} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(editnilai.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);

} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(editnilai.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);

} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(editnilai.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);

//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new editnilai().setVisible(true);

});

// Variables declaration - do not modify

private javax.swing.JButton edit;

private javax.swing.JLabel mp;

private javax.swing.JTextField nilai;

// End of variables declaration

 255

Halaman_admin.java

package peminatansma;

import controler.controleradmin;

import java.awt.event.ActionEvent;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JPanel;

/**

* @author Luigi

*/

public class halaman_admin extends javax.swing.JFrame {

/** Creates new form halaman_admin */

public halaman_admin() {

initComponents();

}
 256

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jPanel1 = new javax.swing.JPanel();

jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel();

jMenuBar1 = new javax.swing.JMenuBar();

jMenu1 = new javax.swing.JMenu();

jMenuItem1 = new javax.swing.JMenuItem();

jMenu6 = new javax.swing.JMenu();

jMenuItem4 = new javax.swing.JMenuItem();

jMenuItem5 = new javax.swing.JMenuItem();

jMenu2 = new javax.swing.JMenu();

jMenuItem3 = new javax.swing.JMenuItem();

jMenu3 = new javax.swing.JMenu();

jMenuItem6 = new javax.swing.JMenuItem();

jMenu4 = new javax.swing.JMenu();

jMenuItem8 = new javax.swing.JMenuItem();

jMenuItem9 = new javax.swing.JMenuItem();

 257

jMenu5 = new javax.swing.JMenu();

jMenuItem2 = new javax.swing.JMenuItem();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jPanel1.setBackground(new java.awt.Color(255, 255, 255));

jLabel1.setFont(new java.awt.Font("Pristina", 1, 36));

jLabel1.setText("Administrator");

jLabel2.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/image1s.jpeg"))); // NOI18N

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addGap(98, 98, 98)

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADIN
G)

.addComponent(jLabel2)

.addComponent(jLabel1))

.addContainerGap(98, Short.MAX_VALUE))

);

jPanel1Layout.setVerticalGroup(
 258

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)

.addComponent(jLabel2)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jLabel1)

.addGap(43, 43, 43))

);

jMenu1.setText("File");

jMenuItem1.setText("Logout");

jMenuItem1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem1ActionPerformed(evt);

});

jMenu1.add(jMenuItem1);

jMenuBar1.add(jMenu1);

jMenu6.setText("User");

jMenuItem4.setText("Input User");
 259

jMenuItem4.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem4ActionPerformed(evt);

});

jMenu6.add(jMenuItem4);

jMenuItem5.setText("Lihat User");

jMenuItem5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem5ActionPerformed(evt);

});

jMenu6.add(jMenuItem5);

jMenuBar1.add(jMenu6);

jMenu2.setText("Siswa");

jMenuItem3.setText("Lihat Data Siswa");

jMenuItem3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem3ActionPerformed(evt);

});

jMenu2.add(jMenuItem3);
 260

jMenuBar1.add(jMenu2);

jMenu3.setText("Nilai");

jMenuItem6.setText("Lihat Nilai");

jMenuItem6.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem6ActionPerformed(evt);

});

jMenu3.add(jMenuItem6);

jMenuBar1.add(jMenu3);

jMenu4.setText("Kelas");

jMenuItem8.setText("Input Kelas");

jMenuItem8.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem8ActionPerformed(evt);

});

jMenu4.add(jMenuItem8);

jMenuItem9.setText("Lihat Kelas");
 261

jMenuItem9.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem9ActionPerformed(evt);

});

jMenu4.add(jMenuItem9);

jMenuBar1.add(jMenu4);

jMenu5.setText("Peminatan");

jMenuItem2.setText("Lihat Hasil Peminatan");

jMenuItem2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem2ActionPerformed(evt);

});

jMenu5.add(jMenuItem2);

jMenuBar1.add(jMenu5);

setJMenuBar(jMenuBar1);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(
 262

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, 282,

Short.MAX_VALUE)

);

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

setBounds((screenSize.width-416)/2, (screenSize.height-341)/2, 416, 341);

}// </editor-fold>

private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().logout();

this.dispose();

private void jMenuItem4ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().inputUser();

private void jMenuItem5ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().lihatUser();

}
 263

private void jMenuItem6ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().lihatNilai();// TODO add your handling code here:

private void jMenuItem8ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().InputKelas();// TODO add your handling code here:

private void jMenuItem9ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().lihatKelas();// TODO add your handling code here:

private void jMenuItem2ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().lihatHasilPermintaan();// TODO add your handling code here:

private void jMenuItem3ActionPerformed(java.awt.event.ActionEvent evt) {

new controleradmin().lihatSiswa();// TODO add your handling code here:

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
 264

public void run() {

new halaman_admin().setVisible(true);

});

// Variables declaration - do not modify

private javax.swing.JLabel jLabel1;

private javax.swing.JLabel jLabel2;

private javax.swing.JMenu jMenu1;

private javax.swing.JMenu jMenu2;

private javax.swing.JMenu jMenu3;

private javax.swing.JMenu jMenu4;

private javax.swing.JMenu jMenu5;

private javax.swing.JMenu jMenu6;

private javax.swing.JMenuBar jMenuBar1;

private javax.swing.JMenuItem jMenuItem1;

private javax.swing.JMenuItem jMenuItem2;

private javax.swing.JMenuItem jMenuItem3;

private javax.swing.JMenuItem jMenuItem4;

private javax.swing.JMenuItem jMenuItem5;

private javax.swing.JMenuItem jMenuItem6;

private javax.swing.JMenuItem jMenuItem8;

private javax.swing.JMenuItem jMenuItem9;

private javax.swing.JPanel jPanel1;

 265

// End of variables declaration

Halaman_user.java

package peminatansma;

import controler.controleruser;

import java.awt.event.ActionEvent;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JPanel;

/**

* @author Luigi

*/

public class halaman_user extends javax.swing.JFrame {

/** Creates new form halaman_user */

public halaman_user() {

initComponents();
 266

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-

BEGIN:initComponents

private void initComponents() {

jPanel1 = new javax.swing.JPanel();

jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel();

jMenuBar1 = new javax.swing.JMenuBar();

jMenu1 = new javax.swing.JMenu();

jMenuItem1 = new javax.swing.JMenuItem();

jMenu2 = new javax.swing.JMenu();

jMenuItem2 = new javax.swing.JMenuItem();

jMenuItem3 = new javax.swing.JMenuItem();

jMenu3 = new javax.swing.JMenu();

jMenuItem5 = new javax.swing.JMenuItem();

jMenuItem6 = new javax.swing.JMenuItem();

jMenu4 = new javax.swing.JMenu();

jMenuItem8 = new javax.swing.JMenuItem();

 267

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

setBackground(new java.awt.Color(255, 255, 255));

jPanel1.setBackground(new java.awt.Color(255, 255, 255));

jLabel1.setFont(new java.awt.Font("Pristina", 1, 36));

jLabel1.setText("Halaman User");

jLabel2.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/imageass.jpeg"))); // NOI18N

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addGap(68, 68, 68)

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILIN
G)

.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 217,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(jLabel2))

.addContainerGap(77, Short.MAX_VALUE))

);

jPanel1Layout.setVerticalGroup(
 268

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap()

.addComponent(jLabel2)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jLabel1)

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))

);

jMenu1.setText("File");

jMenuItem1.setText("Logout");

jMenuItem1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem1ActionPerformed(evt);

});

jMenu1.add(jMenuItem1);

jMenuBar1.add(jMenu1);

jMenu2.setText("Siswa");

jMenuItem2.setText("Tambah Data Siswa");

jMenuItem2.addActionListener(new java.awt.event.ActionListener() {
 269

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem2ActionPerformed(evt);

});

jMenu2.add(jMenuItem2);

jMenuItem3.setText("Lihat Data Siswa");

jMenuItem3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem3ActionPerformed(evt);

});

jMenu2.add(jMenuItem3);

jMenuBar1.add(jMenu2);

jMenu3.setText("Nilai");

jMenuItem5.setText("Input Nilai");

jMenuItem5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem5ActionPerformed(evt);

});

jMenu3.add(jMenuItem5);
 270

jMenuItem6.setText("Lihat Nilai");

jMenuItem6.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem6ActionPerformed(evt);

});

jMenu3.add(jMenuItem6);

jMenuBar1.add(jMenu3);

jMenu4.setText("Peminatan");

jMenuItem8.setText("Hasil Peminatan");

jMenuItem8.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem8ActionPerformed(evt);

});

jMenu4.add(jMenuItem8);

jMenuBar1.add(jMenu4);

setJMenuBar(jMenuBar1);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);
 271

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.Alignment.TRAILING,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)

);

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

setBounds((screenSize.width-378)/2, (screenSize.height-337)/2, 378, 337);

}// </editor-fold>//GEN-END:initComponents

private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem1ActionPerformed

new controleruser().logout();

this.dispose();// TODO add your handling code here:

}//GEN-LAST:event_jMenuItem1ActionPerformed

private void jMenuItem2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem2ActionPerformed

new controleruser().tambahSiswa();

}//GEN-LAST:event_jMenuItem2ActionPerformed
 272

private void jMenuItem3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem3ActionPerformed

new controleruser().lihatSiswa();// TODO add your handling code here:

}//GEN-LAST:event_jMenuItem3ActionPerformed

private void jMenuItem5ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem5ActionPerformed

new controleruser().inputNilai();// TODO add your handling code here:

}//GEN-LAST:event_jMenuItem5ActionPerformed

private void jMenuItem6ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem6ActionPerformed

new controleruser().lihatNilai();// TODO add your handling code here:

}//GEN-LAST:event_jMenuItem6ActionPerformed

private void jMenuItem8ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-

FIRST:event_jMenuItem8ActionPerformed

new controleruser().hasilPeminatan();// TODO add your handling code here:

}//GEN-LAST:event_jMenuItem8ActionPerformed

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new halaman_user().setVisible(true);
 273

});

// Variables declaration - do not modify//GEN-BEGIN:variables

private javax.swing.JLabel jLabel1;

private javax.swing.JLabel jLabel2;

private javax.swing.JMenu jMenu1;

private javax.swing.JMenu jMenu2;

private javax.swing.JMenu jMenu3;

private javax.swing.JMenu jMenu4;

private javax.swing.JMenuBar jMenuBar1;

private javax.swing.JMenuItem jMenuItem1;

private javax.swing.JMenuItem jMenuItem2;

private javax.swing.JMenuItem jMenuItem3;

private javax.swing.JMenuItem jMenuItem5;

private javax.swing.JMenuItem jMenuItem6;

private javax.swing.JMenuItem jMenuItem8;

private javax.swing.JPanel jPanel1;

// End of variables declaration//GEN-END:variables

Hasilpeminatan.java

/*
 274

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

/*

* hasilpeminatan.java

* Created on Jul 11, 2013, 12:07:58 PM

*/

package peminatansma;

import java.io.InputStream;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTabbedPane;

import javax.swing.JTable;

import java.util.ArrayList;

import java.util.HashMap;

import javax.swing.table.DefaultTableModel;

import net.sf.jasperreports.engine.JasperCompileManager;

import net.sf.jasperreports.engine.JasperFillManager;
 275

import net.sf.jasperreports.engine.JasperPrint;

import net.sf.jasperreports.engine.JasperReport;

import net.sf.jasperreports.engine.design.JasperDesign;

import net.sf.jasperreports.engine.xml.JRXmlLoader;

import net.sf.jasperreports.view.JasperViewer;

import java.awt.event.ActionEvent;

/**

* @author Luigi

*/

public class hasilpeminatan extends javax.swing.JFrame {

/** Creates new form hasilpeminatan */

public hasilpeminatan() {

initComponents();

refresh();

showAllDataSiswa();

initkelas();

inittahun();

hitung.setEnabled(false);

/** This method is called from within the constructor to

* initialize the form.

 276

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jTabbedPane2 = new javax.swing.JTabbedPane();

jTabbedPane1 = new javax.swing.JTabbedPane();

jPanel1 = new javax.swing.JPanel();

jScrollPane1 = new javax.swing.JScrollPane();

peminatan = new javax.swing.JTable();

jButton3 = new javax.swing.JButton();

jPanel4 = new javax.swing.JPanel();

jScrollPane3 = new javax.swing.JScrollPane();

tablehasil = new javax.swing.JTable();

kelas = new javax.swing.JComboBox();

tahun = new javax.swing.JComboBox();

hitung = new javax.swing.JButton();

lihatsemuadata = new javax.swing.JButton();

jButton2 = new javax.swing.JButton();

jButton5 = new javax.swing.JButton();

jPanel2 = new javax.swing.JPanel();

jScrollPane2 = new javax.swing.JScrollPane();

tpengujian = new javax.swing.JTable();

lihatsemuadata1 = new javax.swing.JButton();

 277

jButton4 = new javax.swing.JButton();

jtrue = new javax.swing.JLabel();

jfalse = new javax.swing.JLabel();

jButton1 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

peminatan.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

{null, null, null},

{null, null, null},

{null, null, null},

{null, null, null}

},

new String [] {

"Kode Jurusan", "Minat", "Jumlah"

));

jScrollPane1.setViewportView(peminatan);

jButton3.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/refreshh.png"))); // NOI18N

jButton3.setText("refresh");

jButton3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton3ActionPerformed(evt);
 278

});

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap()

.addComponent(jButton3)

.addContainerGap(573, Short.MAX_VALUE))

.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 678,

Short.MAX_VALUE)

);

jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap()

.addComponent(jButton3)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 105,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addContainerGap(75, Short.MAX_VALUE))

);

jTabbedPane1.addTab("Hasil Peminatan", jPanel1);

 279

tablehasil.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null}

},

new String [] {

"id", "NIS", "Nama", "Kelas", "C1", "C2", "Jurusan"

));

jScrollPane3.setViewportView(tablehasil);

kelas.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item

2", "Item 3", "Item 4" }));

tahun.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item

2", "Item 3", "Item 4" }));

hitung.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/equals.png"))); // NOI18N

hitung.setText("Hitung K-Means");

hitung.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

hitungActionPerformed(evt);

}
 280

});

lihatsemuadata.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Loading.png"))); // NOI18N

lihatsemuadata.setText("lihat semua data");

lihatsemuadata.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

lihatsemuadataActionPerformed(evt);

});

jButton2.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Print.png"))); // NOI18N

jButton2.setText("Cetak");

jButton2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton2ActionPerformed(evt);

});

jButton5.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Search.png"))); // NOI18N

jButton5.setText("cari");

jButton5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton5ActionPerformed(evt);

}
 281

});

javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4);

jPanel4.setLayout(jPanel4Layout);

jPanel4Layout.setHorizontalGroup(

jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel4Layout.createSequentialGroup()

.addContainerGap()

.addComponent(kelas, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(tahun, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 70,
Short.MAX_VALUE)

.addComponent(jButton5)

.addGap(2, 2, 2)

.addComponent(hitung)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(lihatsemuadata)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jButton2)

.addContainerGap())

.addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 678,

Short.MAX_VALUE)

);

jPanel4Layout.setVerticalGroup(
 282

jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel4Layout.createSequentialGroup()

.addContainerGap()

.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELI
NE)

.addComponent(kelas, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(tahun, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(hitung)

.addComponent(lihatsemuadata)

.addComponent(jButton2)

.addComponent(jButton5))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 30,
Short.MAX_VALUE)

.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 161,

javax.swing.GroupLayout.PREFERRED_SIZE))

);

jTabbedPane1.addTab("Hasil Konsentrasi Peminatan", jPanel4);

tpengujian.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null}

 283

},

new String [] {

"Nis", "Nama", "Kelas", "Minat", "K-Means", "Manual", "Keterangan"

));

jScrollPane2.setViewportView(tpengujian);

lihatsemuadata1.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Loading.png"))); // NOI18N

lihatsemuadata1.setText("lihat semua data");

lihatsemuadata1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

lihatsemuadata1ActionPerformed(evt);

});

jButton4.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Print.png"))); // NOI18N

jButton4.setText("Cetak");

jButton4.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton4ActionPerformed(evt);

});

jtrue.setText("True :");
 284

jfalse.setText("False :");

javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);

jPanel2.setLayout(jPanel2Layout);

jPanel2Layout.setHorizontalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel2Layout.createSequentialGroup()

.addContainerGap()

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADIN
G)

.addGroup(jPanel2Layout.createSequentialGroup()

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADIN
G)

.addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE,
658, Short.MAX_VALUE)

.addGroup(jPanel2Layout.createSequentialGroup()

.addComponent(lihatsemuadata1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jButton4)))

.addContainerGap())

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel2Layout.createSequentialGroup()

.addComponent(jtrue)

.addGap(113, 113, 113)

.addComponent(jfalse)
 285

.addGap(121, 121, 121))))

);

jPanel2Layout.setVerticalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel2Layout.createSequentialGroup()

.addContainerGap()

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELI
NE)

.addComponent(lihatsemuadata1)

.addComponent(jButton4))

.addGap(18, 18, 18)

.addComponent(jScrollPane2, javax.swing.GroupLayout.PREFERRED_SIZE, 150,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 9,
Short.MAX_VALUE)

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELI
NE)

.addComponent(jtrue)

.addComponent(jfalse)))

);

jTabbedPane1.addTab("Pengujian", jPanel2);

jButton1.setText("Clear");

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

 286

jButton1ActionPerformed(evt);

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jTabbedPane1, javax.swing.GroupLayout.DEFAULT_SIZE,
683, Short.MAX_VALUE)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addComponent(jButton1)

.addGap(28, 28, 28))))

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(23, 23, 23)

.addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
263, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(jButton1)
 287

.addContainerGap(19, Short.MAX_VALUE))

);

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

setBounds((screenSize.width-709)/2, (screenSize.height-384)/2, 709, 384);

}// </editor-fold>

private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {

cari();

private void hitungActionPerformed(java.awt.event.ActionEvent evt) {

new controler.controlerhasilpeminatan().hitung((String)kelas.getSelectedItem(),
(String)tahun.getSelectedItem());

hitung.setEnabled(false);

cari();

private void lihatsemuadataActionPerformed(java.awt.event.ActionEvent evt) {

showAllDataSiswa();

hitung.setEnabled(false);

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

refresh();

}
 288

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

try {

HashMap param = new HashMap();

System.out.println("load jrxml");

InputStream is = getClass().getResourceAsStream("/report/HasilPminatan.jrxml");

JasperDesign jasperDesign = JRXmlLoader.load(is);

//compile file

System.out.println("print jrxml");

JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, param, new

model.Db_Connect().getCon());

JasperViewer jasperViewer = new JasperViewer(jasperPrint, false);

System.out.println("show jrxml");

jasperViewer.viewReport(jasperPrint, false);

} catch (Exception e) {

System.out.println(e);

private void lihatsemuadata1ActionPerformed(java.awt.event.ActionEvent evt) {

pengujian();

String [] truefalse = new controler.controlerhasilpeminatan().getTrueFalse();

jtrue.setText("True : "+truefalse[0]);
 289

jfalse.setText("False : "+truefalse[1]);

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {

try {

HashMap param = new HashMap();

System.out.println("load jrxml");

InputStream is = getClass().getResourceAsStream("/report/pengujian.jrxml");

JasperDesign jasperDesign = JRXmlLoader.load(is);

//compile file

System.out.println("print jrxml");

JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, param, new

model.Db_Connect().getCon());

JasperViewer jasperViewer = new JasperViewer(jasperPrint, false);

System.out.println("show jrxml");

jasperViewer.viewReport(jasperPrint, false);

} catch (Exception e) {

System.out.println(e);

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

 290

new controler.controlerhasilpeminatan().clearLog((String)kelas.getSelectedItem(),
(String)tahun.getSelectedItem());

cari();

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new hasilpeminatan().setVisible(true);

});

public void showAllDataSiswa (){

ArrayList<ArrayList<String>> datasiswa = new

controler.controlerhasilpeminatan().getalldata();

// System.out.println(datasiswa);

ArrayList<String>nis = datasiswa.get(0);

ArrayList<String>nama= datasiswa.get(1);

ArrayList<String>kelass= datasiswa.get(2);

ArrayList<String>c1= datasiswa.get(3);

ArrayList<String>c2= datasiswa.get(4);

ArrayList<String>jurusan= datasiswa.get(5);
 291

String[] judul = {"nis", "nama", "kelas", "c1", "c2", "jurusan"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

tablehasil.setModel(dtm);

for (int i = 0; i < nis.size() ; i++){

String [] datauser = {nis.get(i), nama.get(i), kelass.get(i), c1.get(i), c2.get(i),

jurusan.get(i)};

dtm.addRow(datauser);

public void initkelas(){

ArrayList<String> datakelas = new controler.controlerhasilpeminatan().initkelas();

kelas.removeAllItems();

for (int i = 0; i < datakelas.size() ; i++){

kelas.addItem(datakelas.get(i));

public void inittahun(){

ArrayList<String> datatahun = new controler.controlerhasilpeminatan().inittahun();

tahun.removeAllItems();

for (int i = 0; i < datatahun.size() ; i++){

tahun.addItem(datatahun.get(i));

}
 292

public void cari (){

ArrayList<ArrayList<String>> datasiswa = new

controler.controlerhasilpeminatan().cari((String)kelas.getSelectedItem(),(String)tahun.getSele
ctedItem());

// System.out.println(datasiswa);

ArrayList<String>nis = datasiswa.get(0);

ArrayList<String>nama= datasiswa.get(1);

ArrayList<String>kelass= datasiswa.get(2);

ArrayList<String>c1= datasiswa.get(3);

ArrayList<String>c2= datasiswa.get(4);

ArrayList<String>jurusan= datasiswa.get(5);

String[] judul = {"nis", "nama", "kelas", "c1", "c2", "jurusan"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

tablehasil.setModel(dtm);

for (int i = 0; i < nis.size() ; i++){

String [] datauser = {nis.get(i), nama.get(i), kelass.get(i), c1.get(i), c2.get(i),

jurusan.get(i)};

dtm.addRow(datauser);

hitung.setEnabled(true);

public void refresh(){

ArrayList<ArrayList<String>>data = new controler.controlerhasilpeminatan().refresh();

ArrayList<String> kd_jurusan = data.get(0);

ArrayList<String> jurusan = data.get(1);

 293

ArrayList<String> jumlah = data.get(2);

String[] judul = {"kode jurusan", "peminatan", "jumlah"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

peminatan.setModel(dtm);

for (int i = 0; i < kd_jurusan.size() ; i++){

String [] datauser = {kd_jurusan.get(i), jurusan.get(i), jumlah.get(i)};

dtm.addRow(datauser);

public void pengujian(){

ArrayList<ArrayList<String>>data = new controler.controlerhasilpeminatan().pengujian();

ArrayList<String> nis = data.get(0);

ArrayList<String> nama = data.get(1);

ArrayList<String> kelasss = data.get(2);

ArrayList<String> manual = data.get(3);

ArrayList<String> jurusan = data.get(4);

ArrayList<String> keterangan = data.get(5);

System.out.println(nis);

String[] judul = {"nis", "nama", "kelas", "manual", "jurusan", "keterangan"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

tpengujian.setModel(dtm);

for (int i = 0; i < nis.size() ; i++){

String [] datauji = {nis.get(i), nama.get(i), kelasss.get(i), manual.get(i), jurusan.get(i),

keterangan.get(i)};
 294

dtm.addRow(datauji);

// Variables declaration - do not modify

private javax.swing.JButton hitung;

private javax.swing.JButton jButton1;

private javax.swing.JButton jButton2;

private javax.swing.JButton jButton3;

private javax.swing.JButton jButton4;

private javax.swing.JButton jButton5;

private javax.swing.JPanel jPanel1;

private javax.swing.JPanel jPanel2;

private javax.swing.JPanel jPanel4;

private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JScrollPane jScrollPane2;

private javax.swing.JScrollPane jScrollPane3;

private javax.swing.JTabbedPane jTabbedPane1;

private javax.swing.JTabbedPane jTabbedPane2;

private javax.swing.JLabel jfalse;

private javax.swing.JLabel jtrue;

private javax.swing.JComboBox kelas;

private javax.swing.JButton lihatsemuadata;

private javax.swing.JButton lihatsemuadata1;

private javax.swing.JTable peminatan;

private javax.swing.JTable tablehasil;

private javax.swing.JComboBox tahun;

 295

private javax.swing.JTable tpengujian;

// End of variables declaration

Hasilpeminatan_admin.java

package peminatansma;

import java.io.InputStream;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTabbedPane;

import javax.swing.JTable;

import java.util.ArrayList;

import java.util.HashMap;

import javax.swing.table.DefaultTableModel;

import net.sf.jasperreports.engine.JasperCompileManager;

import net.sf.jasperreports.engine.JasperFillManager;

import net.sf.jasperreports.engine.JasperPrint;

import net.sf.jasperreports.engine.JasperReport;

import net.sf.jasperreports.engine.design.JasperDesign;

import net.sf.jasperreports.engine.xml.JRXmlLoader;

import net.sf.jasperreports.view.JasperViewer;

import java.awt.event.ActionEvent;
 296

/**

* @author Luigi

*/

public class hasilpeminatan_admin extends javax.swing.JFrame {

/** Creates new form hasilpeminatan */

public hasilpeminatan_admin() {

initComponents();

showAllDataSiswa();

refresh();

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jTabbedPane2 = new javax.swing.JTabbedPane();

jTabbedPane1 = new javax.swing.JTabbedPane();

jPanel1 = new javax.swing.JPanel();

 297

jScrollPane1 = new javax.swing.JScrollPane();

peminatan = new javax.swing.JTable();

jPanel4 = new javax.swing.JPanel();

jScrollPane3 = new javax.swing.JScrollPane();

tablehasil = new javax.swing.JTable();

jButton1 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

peminatan.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

{null, null, null},

{null, null, null},

{null, null, null},

{null, null, null}

},

new String [] {

"Kode Jurusan", "Minat", "Jumlah"

));

jScrollPane1.setViewportView(peminatan);

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
 298

.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 547,

Short.MAX_VALUE)

);

jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jScrollPane1, javax.swing.GroupLayout.Alignment.TRAILING,
javax.swing.GroupLayout.DEFAULT_SIZE, 160, Short.MAX_VALUE)

);

jTabbedPane1.addTab("Hasil Peminatan", jPanel1);

tablehasil.setModel(new javax.swing.table.DefaultTableModel(

new Object [][] {

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null},

{null, null, null, null, null, null, null}

},

new String [] {

"id", "NIS", "Nama", "Kelas", "C1", "C2", "Jurusan"

));

jScrollPane3.setViewportView(tablehasil);

javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4);

jPanel4.setLayout(jPanel4Layout);
 299

jPanel4Layout.setHorizontalGroup(

jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 547,

Short.MAX_VALUE)

);

jPanel4Layout.setVerticalGroup(

jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel4Layout.createSequentialGroup()

.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 161,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))

);

jTabbedPane1.addTab("Hasil Konsentrasi Peminatan", jPanel4);

jButton1.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/gambar/Print.png"))); // NOI18N

jButton1.setText("Cetak");

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton1ActionPerformed(evt);

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);
 300

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()

.addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
552, javax.swing.GroupLayout.PREFERRED_SIZE)

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addContainerGap(473, Short.MAX_VALUE)

.addComponent(jButton1)

.addContainerGap())

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(28, 28, 28)

.addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
188, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jButton1)

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))

);

java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();

setBounds((screenSize.width-588)/2, (screenSize.height-309)/2, 588, 309);

 301

}// </editor-fold>

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

try {

HashMap param = new HashMap();

System.out.println("load jrxml");

InputStream is = getClass().getResourceAsStream("/report/HasilPminatan.jrxml");

JasperDesign jasperDesign = JRXmlLoader.load(is);

//compile file

System.out.println("print jrxml");

JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, param, new

model.Db_Connect().getCon());

JasperViewer jasperViewer = new JasperViewer(jasperPrint, false);

System.out.println("show jrxml");

jasperViewer.viewReport(jasperPrint, false);

} catch (Exception e) {

System.out.println(e);

/**

* @param args the command line arguments

*/
 302

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new hasilpeminatan_admin().setVisible(true);

});

public void showAllDataSiswa (){

ArrayList<ArrayList<String>> datasiswa = new

controler.controlerhasilpeminatan().getalldata();

// System.out.println(datasiswa);

ArrayList<String>nis = datasiswa.get(0);

ArrayList<String>nama= datasiswa.get(1);

ArrayList<String>kelass= datasiswa.get(2);

ArrayList<String>c1= datasiswa.get(3);

ArrayList<String>c2= datasiswa.get(4);

ArrayList<String>jurusan= datasiswa.get(5);

String[] judul = {"nis", "nama", "kelas", "c1", "c2", "jurusan"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

tablehasil.setModel(dtm);

for (int i = 0; i < nis.size() ; i++){

String [] datauser = {nis.get(i), nama.get(i), kelass.get(i), c1.get(i), c2.get(i),

jurusan.get(i)};

dtm.addRow(datauser);

}
 303

public void refresh(){

ArrayList<ArrayList<String>>data = new controler.controlerhasilpeminatan().refresh();

ArrayList<String> kd_jurusan = data.get(0);

ArrayList<String> jurusan = data.get(1);

ArrayList<String> jumlah = data.get(2);

String[] judul = {"kode jurusan", "peminatan", "jumlah"};

DefaultTableModel dtm = new DefaultTableModel(null, judul);

peminatan.setModel(dtm);

for (int i = 0; i < kd_jurusan.size() ; i++){

String [] datauser = {kd_jurusan.get(i), jurusan.get(i), jumlah.get(i)};

dtm.addRow(datauser);

// Variables declaration - do not modify

private javax.swing.JButton jButton1;

private javax.swing.JPanel jPanel1;

private javax.swing.JPanel jPanel4;

private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JScrollPane jScrollPane3;

private javax.swing.JTabbedPane jTabbedPane1;

private javax.swing.JTabbedPane jTabbedPane2;

private javax.swing.JTable peminatan;

private javax.swing.JTable tablehasil;

// End of variables declaration