implementasi algoritma k-means dalam data mining …
TRANSCRIPT
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
ii
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
iii
iv
v
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
vi
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
vii
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.
viii
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
ix
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
x
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
xi
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
xii
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
xiii
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
xiv
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
xv
BAB V. PENUTUP ................................................................................... 172
4.1. Kesimpulan ................................................................................... 172
4.2. Saran ..................................................................................................... 173
DAFTAR PUSTAKA ................................................................................. 174
LAMPIRAN
xvi
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
xvii
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
xviii
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
xix
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
xx
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
xxi
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
xxii
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
1
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
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.
11
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
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
fij Kelas hasil prediksi (j)
Kelas = 1 Kelas = 0
Kelas asli (i)
Kelas = 1 f11 f10
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
Pengetahuan Alam
Program Studi Ilmu
Pengetahuan Sosial
Matematika
Fisika
Kimia
Biologi
Ekonomi
Sosiologi
Sejarah
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.
Actor 1
Use Case 1
Use Case 2
Use Case 3
Actor 2
Actor 3
System
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).
+Operation 1()
+Operation 2()
+Operation n()
-Attribute 1
-Attribute 2
-Attribute 3
-Attribute n
Class1
+Operation 1()
+Operation n()
-Attribute 1
-Attribute 2
-Attribute n
Class2
+Operation 1()
+Operation n()
-Attribute 1
-Attribute 2
-Attribute n
Class3
*
1 1
*
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
ActionState1
ActionState2
If True
Control Flow
Start
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).
Actor
Object 1
Message 1
Reply Message 1
Message Call 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.
49
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
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
1
Peminatan Siswa
Berdasarkan Minat
dan Kemampuan
Ade Amalia Nazri 2011
Membahas tentang
rekomendasi
peminatan bagi siswa
Tidak menggunakan
algoritma dalam
proses perhitungan
51
Akademik Siswa
Berbasis Web
kelas X SMA melalui
proses komputerisasi
nilai akademik siswa.
2
Penentuan Jurusan
Sekolah Menengah
Atas dengan
algoritma Fuzzy C-
Means
Bahar 2011
Menggunakan
algoritma Fuzzy
C-Means untuk
menentukan
jurusan bagi
siswa kelas X.
Memiliki tingkat
keakurasian
sekitar 78,39%
dengan data
sampel 81 siswa
Penelitian tidak
dilakukan sampai
tahap pembuatan
aplikasi, penulis
hanya menggunakan
software matlab
untuk menguji coba
tingkat akurasi
algoritma Fuzzy C-
Means
3
Aplikasi K-Means
untuk
pengelompokkan
mahasiswa
berdasarkan nilai
Body Mass Index
(BMI) & ukuran
kerangka
Tedy Rismawan, Sri
Kusumadewi
2008
Penelitian ini
membahas
tentang
implementasi
algoritma K-
Means dalam
menentukan
Body Mass
Index (BMI) dan
Penelitian tidak
dilakukan sampai
tahap pembuatan
aplikasi.
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
P
e
n
e
l
i
59
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
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
J
a
k
a
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
SUMANGERUKKA
SUWANDAKUSUMAH
79 75 75 85 76 78 76 80
2 16706 ADZKIA
RAHMATILLAH
84 76 79 77 76 77 75 81
3 16707 AHMAD RISQI
SABILAL RASYAD
77 84 78 85 92 89 77 82
4 16708 AMBAR
PURWANTININGSIH
78 86 84 77 78 77 75 75
5 16709 ANDIKA SYAHALAM 82 82 81 91 90 82 79 91
6 16515 ANGGIE SURYO
PRAKOSO
75 75 70 82 75 75 79 75
7 16710 ANISAH DIYANTI 77 75 75 89 80 80 75 75
8 16711 ARIANSYAH
PRABOWO
77 76 70 77 77 80 75 80
9 16712 AUDI NADYA 79 76 75 84 77 81 76 77
77
10 16717 DIMAS MURYA
PERDANA
80 75 75 75 75 78 77 79
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
username dan password untuk mengakses sistem.
Semua Aktor
2 Input User Use case yang digunakan untuk menambah user
baru, berikut username, password dan level user.
Admin (Pegawai
Akademik)
3 Ubah User Use case menggambarkan kegiatan mengubah
username dan password pengguna sistem yang
sedang login.
Admin (Pegawai
Akademik)
4 Lihat Siswa
(Admin)
Use case yang digunakan untuk melihat data siswa
dan mencetak laporan data siswa dalam bentuk .pdf
Admin (Pegawai
Akademik)
83
5 Lihat Nilai Use case yang digunakan untuk melihat nilai siswa
dan mencetak laporan nilai siswa dalam bentuk .pdf
Admin (Pegawai
Akademik)
6 Input Kelas Usecase yang digunakan untuk menambah kelas
baru
Admin (Pegawai
Akademik)
7 Ubah Kelas Use case yang digunakan untuk mengubah data
kelas
Admin (Pegawai
Akademik)
8 Lihat Hasil
Peminatan
(Admin)
Use case yang digunakan untuk melihat hasil
peminatan siswa dan mencetak laporan laporan
hasil peminatan siswa dalam bentuk .pdf
Admin (Pegawai
Akademik)
9 Input Data
Siswa
Use case yang digunakan untuk menambah data
siswa baru
User
10 Lihat Siswa
(User)
Use case yang digunakan untuk melihat data siswa,
cari data siswa, mengubah data siswa, menghapus
data siswa dan cetak data siswa.
User
11 Input Nilai
Siswa
Use case yang digunakan untuk menambah nilai
siswa sesuai data siswa yang telah di Input
sebelumnya.
User
12 Lihat Nilai
(User)
Use case yang digunakan untuk melihat data nilai
siswa, cari data nilai siswa, mengubah data nilai
siswa, menghapus data nilai siswa dan cetak data
User
84
nilai siswa.
13 Peminatan
(User)
Use case digunakan untuk melihat hasil peminatan
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.
User
14 Log Out Use case yang menggambarkan kegiatan keluar
dari sistem.
Semua aktor
85
System
Login
Admin
User
User
Siswa
Login
Logout
input user
<<include>> lihat user
<<include>>
delete user
lihat data siswa cetak laporan siswa
Nilai
Peminatan
lihat nilai siswa
lihat hasil
peminatancetak laporan
hasil peminatan
cetak laporan nilai
Siswa
input data siswa
lihat data siswa
<<include>>
<<include>> <<include>>
edit data hapus data cari datacetak data
Nilai
input nilai
lihat nilai
<<include>>
<<include>> <<include>>
edit data hapus data cari nilaicetak data
Kelas
<<include>> input kelas
peminatan
hasil peminatan
hasil konsentrasi
peminatan
<<include>>
<<include>>
<<include>>
<<include>>
<<include>>
<<include>>
<<include>>
<<include>>
<<include>>cetak laporan
peminatan
<<include>> lihat kelas
edit user
<<include>>
Logout
hasil pengujian<<include>> <<include>>cetak laporan
peminatan
c. Use Case Diagram
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
Events
Aktor Action Sistem Response
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
data user
2. Menampilkan form user baru
3. Mengisi form user
baru
4. Menyimpan data user yang 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 Aktor Action Sistem Response
1. Tekan tombol lihat
user
2. Menampilkan tabel user yang
sebelumnya sudah disimpan
3. Pilih salah satu user
yang hendak di ubah
datanya
4. Muncul form ubah user
5. Isi form ubah dengan
data baru yang hendak
di ubah
6. Menyimpan data user yang telah
diubah
Alternate Courses -
Conclusion Data user telah berubah
Post Condition 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 Aktor Action Sistem Response
1. Tekan tombol Siswa
dan Pilih Lihat Siswa
2. Menampilkan tabel data siswa yang
sebelumnya telah disimpan
3. Klik Cetak 4. Muncul data siswa dalam bentuk
Alternate Courses -
Conclusion Data siswa bisa dilihat
Post Condition 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
dan Pilih Lihat Nilai
Siswa
2. Menampilkan tabel nilai siswa yang
sebelumnya telah disimpan
3. Klik Cetak 4. Muncul nilai siswa dalam bentuk
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 Aktor Action Sistem Response
1. Tekan tombol kelas
lalu pilih Input Kelas
2. Menampilkan form Input kelas
3. Isi field pada form
kelas
4. Simpan data kelas yang baru diInput
Alternate Courses -
Conclusion Data kelas baru berhasil berInput
Post Condition 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 Aktor Action Sistem Response
1. Tekan tombol Kelas
lalu pilih Lihat Kelas
2. Menampilkan tabel kelas yang
sebelumnya sudah disimpan
3. Pilih salah satu
kelas yang hendak di
ubah datanya
4. Muncul form ubah kelas
5. Isi form ubah dengan
data baru yang hendak
di ubah
6. Menyimpan data kelas yang telah
diubah
Alternate Courses -
Conclusion Data kelas telah berubah
Post Condition 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
Peminatan dan Pilih
Lihat Hasil Peminatan
2. Menampilkan tabel hasil peminatan
siswa
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 Aktor Action Sistem Response
1. Tekan tombol siswa
lalu pilih Input Siswa
2. Menampilkan form Input siswa
3. Isi field pada form
siswa
4. Simpan data siswa yang baru diInput
Alternate Courses -
Conclusion Data siswa baru berhasil berInput
Post Condition 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
pilih Lihat Siswa
2. Menampilkan tabel siswa yang
sebelumnya sudah disimpan
3. Pilih salah satu siswa
yang hendak di ubah
datanya
4. Muncul form ubah siswa
5. Isi form ubah dengan data
baru yang hendak di ubah
6. Menyimpan data siswa yang
telah diubah
7. Pilih salah satu data yang
akan dihapus
8. akan ada notifikasi jika data
berhasil hapus dan kembali ke
menu Lihat Siswa
9. pilih Cari Siswa sesuai
kelas yang akan dicari lalu
klik cari
10. Menampilkan data hasil
pencarian
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 Aktor Action Sistem Response
1. Tekan tombol Nilai
lalu pilih Input Nilai
Siswa
2. Menampilkan form Input nilai siswa
3. Isi field pada form
nilai siswa
4. Simpan data nilai siswa yang baru
diInput
Alternate Courses -
Conclusion Pengguna sistem dapat menambahkan data nilai siswa
Post Condition 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
Lihat Nilai Siswa
2. Menampilkan tabel Nilai siswa
yang sebelumnya sudah disimpan
3. Pilih salah satu nilai siswa
yang hendak di ubah datanya
4. Muncul form ubah nilai siswa
5. Isi form ubah dengan data
baru yang hendak di ubah
6. Menyimpan data nilai siswa
yang telah diubah
7. Pilih salah satu data yang
akan dihapus
8. akan ada notifikasi jika data
berhasil hapus dan kembali ke
menu Lihat Nilai Siswa
9. pilih Cari Nilai Siswa sesuai
kelas yang akan dicari lalu klik
cari
10. Menampilkan data hasil
pencarian
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
Peminatan dan Pilih
Hasil Peminatan
2. Menampilkan tab hasil peminatan
dan tab hasil konsentrasi peminatan
3. Pilih tab hasil
peminatan
4. Muncul tabel berisi jumlah siswa
yang masuk ke dalam kelompok minat
IPA atau IPS
5. Pilih tab hasil
konsentrasi peminatan
5. Muncul tabel berisi nis, nama, kelas
dan hasil perhitungan cluster (C1 &
C2) beserta minat siswa berdasarkan
hasil penghitungan algoritma K-Means
6. Pada tab hasil
konsentrasi peminatan,
pilih kelas yang akan di
cari hasil konsentrasi
peminatannya
7. Muncul data siswa perkelas,
kemudian klik tombol Hitung K-
Means, tunggu sampai kotak dialog
message “K-Means Berhasil Dihitung”
8. Pada tab hasil
konsentrasi peminatan,
klik tombol lihat
seluruh data
9. Muncul seluruh data siswa beserta
hasil peminatan yang sudah di proses
menggunakan algoritma K-Means.
99
10. Pada tab hasil
konsentrasi peminatan,
pilih kelas yang akan di
cetak datanya,
kemudian klik cetak.
11. Hasil Konsentrasi Peminatan akan
tercetak dalam bentuk .pdf sesuai
dengan kelas yang ingin kita cetak
datanya.
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 :
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
Gambar 4.4 Activity Diagram Login
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)
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
Gambar 4.7 Activity Diagram Siswa
105
e. Activity Diagram Nilai (Halaman Admin)
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
Gambar 4.8 Activity Diagram Nilai
106
f. Activity Diagram Input Kelas (Halaman Admin)
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.
Gambar 4.9 Activity Diagram Tambah Kelas
107
g. Activity Diagram Lihat 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. 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
Gambar 4.10 Activity Diagram Nilai
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)
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.
Gambar 4.12 Activity Diagram Input Siswa (Halaman User)
111
j. Activity Diagram Lihat Siswa (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
Gambar 4.13 Activity Diagram Lihat Siswa (Halaman User)
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)
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
Gambar 4.16 Activity Diagram Peminatan (Halaman User)
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
Keterangan gambar :
Di dalam activity diagram Log Out. Aktor memilih log out lalu sistem
akan keluar secara otomatis dan kembali ke halaman Login.
Gambar 4.17 Activity Diagram Logout
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
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
Gambar 4.18 Sequence Diagram Login
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)
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
Gambar 4.19 Sequence Diagram Tambah User (Halaman
A
d
m
i
n
)
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)
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.
Gambar 4.21 Sequence Diagram Lihat Siswa (Halaman
A
d
m
i
n
)
122
e. 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.
Gambar 4.22 Sequence Diagram Lihat Nilai (Halaman Admin)
123
f. 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)
Gambar 4.23 Sequence Diagram Input Kelas (Halaman Admin)
124
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.
Gambar 4.24 Sequence Diagram Lihat Kelas (Halaman Admin)
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)
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.
Gambar 4.28 Sequence Diagram Input Nilai (Halaman User)
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
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.
Gambar 4.31 Sequence Diagram Log Out
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
b. Tabel kelas
c. Tabel matapelajaran
Nama Field Tipe data Ukuran Keterangan
kd_jurusan varchar 5 Kode jurusan
jurusan varchar 20 Nama Jurusan
Nama Field Tipe data Ukuran Keterangan
kd_kelas varchar 10 Kode kelas
kelas varchar 10 Nama Kelas
Nama Field Tipe data Ukuran Keterangan
kd_matapelajaran int 11 Kode mata pelajaran
matapelajaran varchar 20 Nama mata pelajaran
139
d. Tabel nilai
e. Tabel siswa
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
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
g. Tabel User
h. Tabel Pengujian
Nama Field Tipe data Ukuran Keterangan
kd_thnajaran varchar 10 Kode tahunajaran
thn_ajaran varchar 10 Tahun ajaran
Nama Field Tipe data Ukuran Keterangan
username varchar 15 Username user
password varchar 10 Password user
hak_akses varchar 10 Hak akses user
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
b. Home Admin
Gambar 4.33 Tampilan Form Login
Gambar 4.34 Tampilan Home Admin
142
c. Input User
d. Lihat User
Gambar 4.35 Tampilan Form Input User
Gambar 4.36 Tampilan Lihat User
143
e. Lihat Siswa (Halaman Admin)
f. Lihat Nilai (Halaman Admin)
Gambar 4.37 Tampilan Lihat Siswa (Halaman Admin)
Gambar 4.38 Tampilan Lihat Nilai (Halaman Admin)
144
g. Input Kelas (Halaman Admin)
h. Lihat Kelas (Halaman Admin)
Gambar 4.39 Tampilan Form Input Kelas (Halaman Admin)
Gambar 4.40 Tampilan Lihat Kelas (Halaman Admin)
145
i. Peminatan (Halaman Admin)
j. Home User
Gambar 4.41 Tampilan Peminatan (Halaman Admin)
Gambar 4.42 Tampilan Home User
146
k. Input Siswa (Halaman User)
l. Lihat Siswa (Halaman User)
Gambar 4.43 Tampilan Form Input Siswa (Halaman
U
s
e
r
)
Gambar 4.44 Tampilan Lihat Siswa (Halaman User)
147
m. Input Nilai (Halaman User)
n. Lihat Nilai (Halaman User)
Gambar 4.45 Tampilan Form Input Nilai (Halaman
U
s
e
r
)
Gambar 4.46 Tampilan Lihat Nilai (Halaman User)
148
o. Peminatan (Halaman User)
p. Peminatan Tab Pengujian (Halaman User)
Gambar 4.47 Tampilan Peminatan (Halaman User)
Gambar 4.48 Tampilan Peminatan Tab Pengujian (Halaman User)
149
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
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.
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 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.
Gambar 4.50 Syntax Code Hitung Hasil Peminatan
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)
c. Home User (Halaman User)
Gambar 4.53 Tampilan Home Admin (Halaman Admin)
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
No Fungsi Skenario pengujian Hasil Yang Diharapkan Status
Pengujian
1 Login Pengguna
Pengguna baik admin
atau user melakukan
Login
Jika username dan
password terdaftar
maka akan masuk ke
dalam menu utama
sesuai dengan
username saat login,
jika tidak maka
pengguna tidak dapat
masuk ke dalam
halaman utama.
Terpenuhi
2 Input User Admin menambah user Aplikasi akan Terpenuhi
161
(Halaman Admin) baru dengan
memasukkan username,
password dan level
pengguna pada form
input user. Kemudian
klik tombol simpan
menampilkan pesan
bahwa data berhasil
tersimpan ke dalam
database
3
Lihat User
(Halaman Admin)
Admin memilih
submenu Lihat User
pada menu User untuk
melihat daftar pengguna
serta merubah dan
menghapus data
pengguna
Aplikasi akan
menampilkan tabel
yang berisi username
dan password. Pada
submenu ini, admin
dapat menghapus atau
merubah data user
yang diinginkan
Terpenuhi
4
Lihat Siswa
(Halaman Admin)
Admin memilih
submenu Lihat Siswa
pada menu Siswa untuk
melihat data siswa
keseluruhan dan
mencetak data siswa.
Aplikasi akan
menampilkan seluruh
data siswa yang ada,
ketika admin menekan
tombol cetak, maka
data siswa akan
tercetak dalam bentuk
Terpenuhi
5 Lihat Nilai Admin memilih Aplikasi akan Terpenuhi
162
(Halaman Admin) submenu Lihat Nilai
pada menu Nilai untuk
melihat nilai siswa
keseluruhan dan
mencetak nilai siswa.
menampilkan seluruh
nilai siswa yang ada,
ketika admin menekan
tombol cetak, maka
nilai siswa akan
tercetak dalam bentuk
6
Input Kelas
(Halaman Admin)
Admin memilih
submenu Input Kelas
pada menu Kelas,
kemudian admin mengisi
field kode kelas dan
kelas lalu tekan tombol
simpan
Aplikasi akan
menampilkan pesan
bahwa data berhasil
disimpan ke dalam
database
Terpenuhi
7
Lihat Kelas
(Halaman Admin)
Admin memilih
submenu Lihat Kelas
pada menu Kelas untuk
melihat data kelas.
Aplikasi akan
menampilkan seluruh
nilai siswa yang ada.
Terpenuhi
8
Peminatan
(Halaman Admin)
Admin memilih
submenu peminatan pada
menu peminatan. Lalu
admin memilih tab Hasil
Peminatan untuk melihat
Aplikasi akan
menampilkan jumlah
siswa yang masuk
kelompok peminatan
IPA dan IPS lalu admin
Terrpenuhi
163
jumlah siswa yang
masuk kelompok
peminatan IPA atau IPS.
Tab Hasil Konsentrasi
Peminatan berisi hasil
peminatan masing-
masing siswa.
dapat mencetak dalam
bentuk .pdf Aplikasi
juga menampilkan
hasil peminatan bagi
masing-masing siswa
dan hasil konsentrasi
peminatan dpt dicetak
dalam bentuk .pdf
9
Input Siswa
(Halaman User)
User memilih submenu
Input Siswa pada menu
Siswa, kemudian admin
mengisi field yang
terdapat dalam form
siswa lalu tekan tombol
simpan
Aplikasi akan
menampilkan pesan
bahwa data berhasil
tersimpan ke dalam
database
Terpenuhi
10
Lihat Siswa
(Halaman User)
User memilih submenu
Lihat Siswa pada menu
Siswa untuk melihat data
siswa keseluruhan. User
dapat mengubah data
siswa, menghapus,
mencari dan mencetak
data siswa.
Aplikasi akan
menampilkan tabel
yang berisi data siswa.
Ketika user memilih
kelas yang akan di cari,
dan menekan tombol
cari, maka aplikasi
akan menampilkan
Terpenuhi
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
11
Input Nilai
(Halaman User)
User memilih submenu
Input Nilai pada menu
Aplikasi akan
menampilkan pesan
Terpenuhi
165
Nilai, kemudian admin
mengisi field yang
terdapat dalam form
siswa lalu tekan tombol
simpan
bahwa data berhasil
tersimpan ke dalam
database
12
Lihat Nilai
(Halaman User)
User memilih submenu
Lihat Nilai pada menu
Nilai untuk melihat data
nilai siswa keseluruhan.
User dapat mengubah
data siswa, menghapus,
mencari dan mencetak
data siswa.
Aplikasi akan
menampilkan tabel
yang berisi nilai siswa.
Ketika user memilih
kelas yang akan di cari,
dan menekan tombol
cari, maka aplikasi
akan menampilkan
hasil pencarian. Ketika
user memilih salah satu
data yang akan di ubah
menekan tombol edit
maka aplikasi akan
menampilkan form edit
nilai siswa, setelah diisi
dan klik simpan, data
akan terupdate
otomatis.
Terpenuhi
166
Ketika user menekan
tombol cetak, lalu
aplikasi akan mencetak
nilai siswa dalam
bentuk .pdf
13
Peminatan
(Halaman User)
User memilih submenu
peminatan pada menu
peminatan. Lalu user
memilih tab Hasil
Peminatan untuk melihat
jumlah siswa yang
masuk kelompok
peminatan IPA atau IPS.
Tab Hasil Konsentrasi
Peminatan berisi hasil
peminatan masing-
masing siswa.
Tab Pengujian berisi
perbandingan peminatan
antara hasil
penghitungan k-means
dan manual.
Aplikasi akan
menampilkan jumlah
siswa yang masuk
kelompok peminatan
IPA dan IPS lalu user
dapat mencetak dalam
bentuk .pdf Aplikasi
juga menampilkan
hasil peminatan bagi
masing-masing siswa
dan hasil konsentrasi
peminatan dpt dicetak
dalam bentuk .pdf
Aplikasi akan
menampilkan
perbandingan hasil
penghitungan k-means
dan manual. Jika
Terpenuhi
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
1 16705 ABRAR SUMANGERUKKA
SUWANDAKUSUMAH X1 IPA IPS FALSE
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
5 16737 SULTHANA LABIBA
KHANSA X1 IPA IPA TRUE
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
15 16786 CHRISTINA AJENG
BUDIARTI X3 IPS IPS TRUE
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
22 16814 WAHID GALANG
DEWANTORO X3 IPS IPS TRUE
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
31 16839 MUHAMMAD HARALD
ARKAAN X4 IPS IPS TRUE
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
38 16774 RIZZKE KURNIA
MARCHELINDA X2 IPA IPA TRUE
39 16765 LEONARDO YORIANO
BHIRAWA WICAKSANA X2 IPS IPS TRUE
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
56 16926 WIRAWAN AHMAD
DESTAMA X6 IPA IPA TRUE
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
65 16910 LUTHFI JOVAN WANDY
AKMANDO X6 IPA IPA TRUE
66 16951 MUHAMAD HAPIZ
HERDIANSYAH X7 IPA IPS FALSE
67 16875 MUHAMMAD WAFIYUDDIN
AL WAHAB X5 IPA IPA TRUE
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
71 16871 GRACE ANASTASIA
MAHARDIKA X5 IPS IPS TRUE
72 16872 KINDY ISLAMIATTI X5 IPA IPA TRUE
73 16924 SITI NURLAILA
APRILIYANTI X2 IPA IPA TRUE
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
fij Kelas hasil prediksi (j)
Kelas = IPA Kelas = IPS
Kelas asli
(i)
Kelas = IPA f11
27
f10
13
Kelas = IPS f01
5
f00
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.
Gambar 4.54 Grafik Perbandingan Tingkat Akurasi dan Laju Kesalahan
0
10
20
30
40
50
60
70
80
Matriks Konfusi
Tingkat Akurasi
Laju Error
172
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.
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.
174
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
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
}