Laporan ini membahas tentang praktikum program array menggunakan bahasa pemrograman Java. Terdapat penjelasan tentang konsep array, pengorganisasian data, dan cara menggunakan NetBeans IDE untuk membuat program array."

1. LAPORAN PRAKTIKUM
KONSTRUKSI KOMPILER
Nama : Hibaten Wafiroh
NIM : 201012101
Tanggal : 11 Desember 2013
Kode MK : KOM 403
Laboratorium Teknik Informatika
SEKOLAH TINGGI TEKNOLOGI BONTANG
2013

2. KATA PENGANTAR
Alhamdulillah dan puji syukur kehadirat Allah SWT saya ucapkan atas selesainya Laporan
Praktikum Konstruksi Kompiler ini. Tanpa ridho dan kasih sayang serta petunjuk dari-Nya mustahil laporan
ini dapat dirampungkan.
Laporan ini disusun sebagai hasil dari tugas yang diberikan oleh dosen pengampu mata kuliah
Konstruksi Kompiler guna memperdalam pengetahuan mahasiswa tentang program Array pada Java.
Dalam penyusunan laporan ini tidak terlepas dari peran serta berbagai pihak yang turut memberikan
saran dan masukan-masukan sehingga laporan ini dapat saya selesaikan. Untuk itu saya ucapkan terimakasih
yang sebesar-besarnya.
Sesuai kata pepatah “Tak ada gading yang tak retak”, tentunya laporan ini tak lepas dari pepatah
tersebut. Dengan segenap kerendahan hati saran dan kritik yang konstruktif dari pembaca sangat diharapkan
demi perbaikan dan peningkatan kualitas laporan diwaktu yang akan datang.
Bontang, 25 Desember 2013
Hibaten Wafiroh
i

3. DAFTAR ISI
Kata Pengantar .............................................................................................. i
Daftar Isi........................................................................................................... ii
Daftar Gambar.................................................................................................. iii
BAB I PENDAHULUAN
1.1 Latar Belakang............................................................................................ 1
1.2 Tujuan .............................................................................................. 1
BAB II DASAR TEORI
2.1 Sekilas Tentang Array ................................................................................ 2
2.1.1 Deklarasi array ................................................................................. 2
2.1.2 Membuat array (create/define array)................................................ 2
2.1.3 Mengakses array............................................................................... 3
2.1.4 Mendeklarasikan dan membuat array............................................... 3
2.1.5 Inisialisasi array................................................................................ 3
2.1.6 Array multi dimensi.......................................................................... 4
2.1.7 Deklarasi array multi dimensi .......................................................... 5
2.2 Pengorganisasian Data................................................................................ 5
2.2.1 Sequential Searching ........................................................................ 6
2.2.2 Index Sequential Searching.............................................................. 6
2.2.3 Binary Search ................................................................................... 6
2.3 Sekilas Tentang Java .................................................................................. 7
2.3.1 Kelebihan Java................................................................................. 7
2.3.2 Kekurangan Java ............................................................................. 8
2.4 Sekilas Tentang NetBeans IDE 7.3 ............................................................ 9
2.4.1 Instalasi JDK ................................................................................... 9
2.4.2 Instalasi NetBeans IDE 7.3 ............................................................. 11
BAB III METODOLOGI
3.1 Praktikum 1 Program Array ...................................................................... 16
3.2 Praktikum 2 Penentuan Nilai Tertinggi..................................................... 17
3.3 Praktikum 3 Penentuan Nilai Terendah..................................................... 19
BAB IV HASIL DAN ANALISIS
4.1 Hasil Program ............................................................................................ 21
4.1.1 Hasil Program Array........................................................................ 21
4.1.2 Hasil Penentuan Nilai Tertinggi...................................................... 21
4.1.3 Hasil Penentuan Nilai Terendah...................................................... 21
4.2 Analisis Program ....................................................................................... 22
ii

4. 4.2.1 Analisis Program Array................................................................... 22
4.2.2 Analisis Penentuan Nilai Tertinggi ................................................. 22
4.2.3 Analisis Penentuan Nilai Terendah ................................................. 22
BAB V PENUTUP
5.1 Kesimpulan................................................................................................. 23
5.2 Saran........................................................................................................... 23
DAFTAR PUSTAKA ..................................................................................... 24
iii

5. DAFTAR GAMBAR
Gambar 1 (a) Proses instalasi JDK ................................................................. 9
Gambar 1 (b) Proses instalasi JDK ................................................................. 10
Gambar 1 (c) Proses instalasi JDK ................................................................. 10
Gambar 1 (d) Proses instalasi JDK ................................................................. 11
Gambar 1 (e) Proses instalasi JDK ................................................................. 11
Gambar 2 (a) Proses instalasi NetBeans IDE 7.3 ........................................... 12
Gambar 2 (b) Proses instalasi NetBeans IDE 7.3 ........................................... 12
Gambar 2 (c) Proses instalasi NetBeans IDE 7.3 ........................................... 12
Gambar 2 (d) Proses instalasi NetBeans IDE 7.3 ........................................... 13
Gambar 2 (e) Proses instalasi NetBeans IDE 7.3 ........................................... 13
Gambar 2 (f) Proses instalasi NetBeans IDE 7.3 ............................................ 13
Gambar 2 (g) Proses instalasi NetBeans IDE 7.3 ........................................... 14
Gambar 2 (h) Proses instalasi NetBeans IDE 7.3 ........................................... 14
Gambar 3 Loading memulia NetBeans IDE 7.3............................................... 15
Gambar 4 NetBeans IDE 7.3 telah siap digunakan .......................................... 15
Gambar 5 Hasil runing program Array............................................................. 21
Gambar 6 Hasil runing program Pencarian Nilai Tertinggi ............................. 21
Gambar 7 Hasil runing program Pencarian Nilai Terendah............................. 22
iv

6. BAB I
PENDAHULUAN
1.1 Latar Belakang
Latar belakang dibuatnya laporan praktikum ini adalah sebagai salah satu syarat penulis untuk
dapat lulus pada mata kuliah Konstruksi Kompiler. Sebagai mahasiswa STITEK Bontang, pembuatan
laporan pratikum ini juga dijadikan sebagai bukti bahwa penulis telah menyelesaikan pratikum mata
kuliah Konstruksi Kompiler. Praktikum telah dilaksanakan di Lab Teknik Informatika, dipandu oleh
dosen pengampu mata kuliah Konstruksi Kompiler bapak Lapu Tombilayuk,ST.
Dalam pembuatannya, penulis berharap agar laporan ini dapat memberikan manfaat kepada
orang lain maupun penulis khususnya agar dapat mengerti tentang program array dengan
menggunakan bahasa pemrograman Java.
1.2 Tujuan
Tujuan mahasiswa dalam melakukan pratikum Konstruksi Kompiler adalah :
1. Mahasiswa dapat membangun sebuah program sederhana menggunakan teknik array.
2. Mahasiswa diharapkan mampu menggunakan Bahasa (Script /Text Editor) JAVA
pada pembuatan program Array dan mencari nilai maximum dan minimum.
3. Mampu mengidentifikasi kesalahan yang terjadi pada pembuatan program dan mampu
merepairing kesalahan pada program tersebut.
PEMBAHASAN

7. BAB II
DASAR TEORI
2.1 Sekilas Tentang Array
Array adalah suatu kumpulan data bertipe sama yang menggunakan nama variabel yang sama
pada tiap elemen dibedakan melalui indeksnya, by default indeksnya dimulai dari 0 s/d (n-1) dengan n
adalah jumlah elemen array Pada deklarasi variabel biasa, kita hanya dapat memberikan 1 data pada 1
variabel. Tapi dengan konsep array, kita dapat memberikan lebih dari 1 data pada 1 variabel.
2.1.1 Deklarasi array
Cara mendeklarasikan suatu array (satu dimensi) adalah sebagai berikut :
tipe_array nama_array[];
tipe_array[] nama_array;
Contoh :
int nilai[];
char[] huruf;
Dalam mendeklarasikan array, blank space tidak berpengaruh terhadap peletakan tanda []. Sebagai
contohnya, deklarasi array di bawah ini juga dibenarkan :
tipe_array nama_array [];
tipe_array [] nama_array;
tipe_array []nama_array;
2.1.2 Membuat array (create/define array)
Pada saat pendeklarasian suatu array, sebagai contoh
int nilai[];

8. yang terjadi adalah kita hanya memberitahu kepada kompiler Java bahwa kita
mendeklarasikan/mengenalkan sebuah variabel bernama nilai yang berbentuk array dan bertipe int.
Disana kita belum memesan tempat di memori untuk menampung elemen-elemen array. Agar kita
dapat memesan tempat di memori untuk menampung elemen-elemen array, kita perlu membuat array.
Adapun caranya adalah dengan memakai new karena di dalam Java suatu array adalah dianggap suatu
OBYEK. Format penulisannya adalah sebagai berikut :
nama_array = new tipe_array[total_elemen_array];
Contoh :
int nilai[];
nilai = new int[5];
Pada saat baris kedua dieksekusi, kompiler Java akan menyediakan space di memori
sebanyak 5 elemen dengan tipe masing-masing adalah int. Identifikasi elemen array sering disebut
dengan indeks array, yang berawal dari 0 sampai total_elemen_array-1.
2.1.3 Mengakses array
Pada saat kita sudah selesai membuat array, kita dapat mengisinya dengan nilai yang tentunya
harus sesuai dengan tipe array-nya. Untuk mengisi array, kita perlu memberitahukan kepada kompiler
Java elemen manakah dari array yang akan kita isi. Format penulisannya sebagai berikut :
nama_array[elemen_array] = nilai;
2.1.4 Mendeklarasikan dan membuat array
Pada pembahasan sebelumnya kita sudah memahami bagaimana cara mendeklarasikan suatu
array dan kemudian membuatnya. Keduanya kita lakukan pada baris statement yang berbeda. Selain
cara tersebut, kita juga dapat melakukan deklarasi dan pembuatan array hanya pada satu baris
statement. Adapun format penulisannya adalah sebagai berikut :
tipe_array nama_array[] = new tipe_array[total_elemen_array];
Contoh :
int nilai[] = new int[5];

9. Kalau program Array1 sebelumnya kita mendeklarasikan dan membuat pada baris statement
yang berbeda, kita dapat menuliskannya hanya dengan satu baris statement seperti yang terlihat
dibawah ini :
2.1.5 Inisialisasi array
Inisialisasi array adalah pemberian nilai awal bagi setiap elemen array yang kita buat. Pada
saat kita membuat suatu array dengan sejumlah elemen tertentu, maka kompiler Java akan
memberikan nilai default kepada setiap elemen array selama kita tidak memberikan nilai awal pada
saat pembuatan array.
public class Array1 {
public static void main(String args[]) {
int nilai[];
nilai = new int[2];
nilai[0] = 50;
nilai[1] = 100;
System.out.println("Nilai indeks ke-0 = " + nilai[0]);
System.out.println("Nilai indeks ke-1 = " + nilai[1]);
}
}
Nilai indeks ke-0 = 50
Nilai indeks ke-1 = 100
public class Array2 {
public static void main(String args[]) {
int nilai[] = new int[2];
nilai[0] = 50;
nilai[1] = 100;

10. System.out.println("Nilai indeks ke-0 = " + nilai[0]);
System.out.println("Nilai indeks ke-1 = " + nilai[1]);
}
}
Untuk mudahnya, mari kita lihat program dibawah ini :
int nilai[];
nilai = new int[5];
Pada saat kita membuat array di baris kedua, kita tidak memberikan nilai awal (inisialisasi)
pada elemen array. Pada saat baris kedua selesai dieksekusi, maka kompiler Java akan memberikan
nilai default kepada setiap elemen array. Tentunya nilai default akan bergantung pada tipe array.
2.1.6 Array multi dimensi
Pada pembahasan sebelumnya kita hanya membahas tantang array berdimensi satu (tunggal). Pada
pembahasan kali ini akan dijelaskan bagaimana mendeklarasikan, membuat dan menginisialisasi suatu
array yang mempunyai dimensi lebih dari satu (multi dimensi).
2.1.7 Deklarasi array multi dimensi
Cara mendeklarasikan suatu array multi dimensi tidak jauh berbeda dengan cara
mendeklarasikan array berdimensi tunggal, yaitu cukup dengan menambahkan tanda []. Untuk lebih
jelasnya, berikut berbagai macam contoh dimensi pada array.
int nilai[];// berdimensi 1
char huruf[][];// berdimensi 2
double total[][][];// berdimensi 3
public class InitArray {

11. public static void main(String args[]) {
int nilai[] = new nilai[5];
System.out.println(“Nilai indeks ke-2 = “ + nilai[2]);
}
}
Nilai indeks ke-2 = 0
public class Array2 {
public static void main(String args[]) {
int nilai[] = {50, 100};
System.out.println("Nilai indeks ke-0 = " + nilai[0]);
System.out.println("Nilai indeks ke-1 = " + nilai[1]);
}
}
String[][] nama;// berdimensi 2
float[] panjang[];// berdimensi 2
short[][] tinggi[]; // berdimensi 3
2.2 Pengorganisasian Data
Bila jumlah data besar atau banyak, dibutuhkan suatu metode untuk mendapatkan data
yang dibutuhkan. Beberapa metode pengorganisasian data telah membuat proses pencarian
data menjadi lebih efisien.
2.2.1 Sequential Searching
Metode ini merupakan metode pencarian yang paling sederhana. Algoritma ini dapat
diterapkan pada daftar dalam bentuk array atau linked list. Algoritma ini menganalisa tiap
key dari masing-masing node data. Jika data yang dicari ditemukan maka indeks atau pointer

12. dari node tersebut akan dikembalikan. Jika data tidak ditemukan, maka nilai -1 yang
dikembalikan. Jumlah pembandingan yang dilakukan ditentukan oleh posisi dari data yang
dicari. Jika data berada pada posisi pertama maka hanya diperlukan satu kali pembandingan
sementara jika data berada pada urutan paling akhir dibutuhkan N kali pembandingan. Maka
rata-rata jumlah pembandingan adalah (N + 1)/2
2.2.2 Index Sequential Searching
Ada teknik lain untuk meningkatkan efisiensi dengan melakukan pencarian pada data
terurut. Jika data tidak terurut diperlukan sejumlah ruang untuk menyimpan indeks dari data.
Indeks ini berisi key dari masing-masing data. Indeks ini, disebut iindex, dipecah menjadi
beberapa kelompok dan nilai key dari masing-masing kelompok dicatat dalam indeks kedua,
misalnya kindeks. Pencarian data dilakukan pada indeks kedua dengan kindeks[i] ≤ key <
kindeks[i+1]. Sehingga pencarian tinggal dilakukan pada iindeks[kindeks[i]] hingga
iindeks[kindeks[i+1]] tersebut.
2.2.3 Binary Search
Metode yang paling efisien pada table sekuensial adalah binary search. Pada
dasarnya data yang dicari dibandingkan dengan elemen yang berada di tengah. Bila cocok
maka data tersebut dikembalikan, bila tidak pencarian dilanjutkan pada setengah bagian kiri
atau setengah bagian kanan. Masing-masing bagian dilakukan proses yang sama hingga data
yang diinginkan ditemukan.
Algoritma pencarian biner merupakan pebaikan dari konsep sebelumnya (pencarian linier)
karena lebih efisien. Dengan algoritma ini, kita tidak perlu memeriksa semua elemen
sehingga menghemat waktu pencarian. Algoritma ini dibagun berdasarkan ide sebagai
berikut:
- Urutkan terlebih dahulu elemen-elemen array berdasarkan nilainya urutan boleh naik
(bilangan terkecil dahulu, kemudian terakhir bilangan terbesar) atau turun.
- Selanjutnya, ambillah nilai elemen yang terletak pada posisi tengah urutan array
tersebut. Kita sebut nilai elemen ini sebagai nilai tengah. Nilai tengah ini membagi
array menjadi dua segmen; segmen pertama berisi elemen terkecil sampai nilai
tengah, sedangkan segmen kedua berisi elemen nilai tengah sampai nilai terbesar.
- Bandingkan nilai elemn yang dicari (kunci) dengan nilai tengah ini. Proses
pembandingan ini memiliki tiga nilai kemungkinan:
a. Bila nilai kunci sama dengan nilai tengah, maka pencarian selesai.

13. b. Bila nilai kunci lebih kecil dari nilai tengah, maka algoritma akan mengabaikan
setengah bagian dar array (mulai dari nilai tengah sampai nilai elemen terbesar).
Selanjutnya, proses pencarian difokuskan untuk segmen yang lain, yaitu elemen
terkecil sampai kepada nilai tengah. Kemudan, algoritma akan membagi lagi
segmen tersebut menjadi dua, dilanjutkan proses pembandingan, dan seterusnya.
c. Bilai nilai kunci lebih besar dari nilai tengah, maka algoritma akan mengabaikan
segmen yang berisi nilai terkecil sampai nilai tengah. Selanjutnya kaidah
pencarian mengikuti pola pembagian segmen menjadi dua dan
membandingkannya dengan nilai tengah, sama seperti butir sebelumnya.
Demikian seterusnya sampai elemen yang dicari ditemukan atau elemen array
sudah selesai diperiksa.
2.3 Sekilas Tentang Java
Java adalah bahasa pemrograman berorientasi objek yang dikembangkan oleh Sun Microsystems
sejak tahun 1991. Bahasa ini dikembangkan dengan model yang mirip dengan bahasa C++ dan
Smalltalk, namun dirancang agar lebih mudah dipakai dan platform independent, yaitu dapat
dijalankan di berbagai jenis sistem operasi dan arsitektur komputer. Bahasa ini juga dirancang untuk
pemrograman di Internet sehingga dirancang agar aman dan portabel.
Java pada awalnya dirancang untuk mendukung jaringan komputer. Java dipercaya sebagai
mesin virtual yang aman dan sangat mudah. Java dibendel dengan desain library yang luas untuk
menyediakan abstraksi yang lengkap dari suatu platform. Java adalah bahasa pemrograman
berorientasi objek berjenis statis yang penggunaan syntaxnya mirip dengan bahasa pemrograman C,
tapi tidak kompatibel dengannya. Java didisain dari awal, dengan tujuan agar mudah digunakan dan
dapat diakses oleh khalayak yang lebih luas.
2.3.1 Kelebihan Java
Multiplatform. Kelebihan utama dari Java ialah dapat dijalankan di
beberapa platform / sistem operasi komputer, sesuai dengan prinsip tulis sekali, jalankan di
mana saja. Dengan kelebihan ini pemrogram cukup menulis sebuah program Java dan
dikompilasi (diubah, dari bahasa yang dimengerti manusia menjadi bahasa mesin / bytecode)
sekali lalu hasilnya dapat dijalankan di atas beberapa platform tanpa perubahan. Kelebihan

14. ini memungkinkan sebuah program berbasis java dikerjakan diatas operating system Linux
tetapi dijalankan dengan baik di atas Microsoft Windows. Platform yang didukung sampai
saat ini adalah Microsoft Windows, Linux, Mac OS dan Sun Solaris. Penyebanya adalah
setiap sistem operasi menggunakan programnya sendiri-sendiri (yang dapat diunduh dari situs
Java) untuk meninterpretasikan bytecode tersebut.
OOP (Object Oriented Programming - Pemrogram Berorientasi Objek) Perpustakaan Kelas
Yang Lengkap, Java terkenal dengan kelengkapan library/perpustakaan (kumpulan program program
yang disertakan dalam pemrograman java) yang sangat memudahkan dalam penggunaan oleh para
pemrogram untuk membangun aplikasinya. Kelengkapan perpustakaan ini ditambah dengan
keberadaan komunitas Java yang besar yang terus menerus membuat perpustakaan-perpustakaan baru
untuk melingkupi seluruh kebutuhan pembangunan aplikasi.
2.3.2 Kekurangan Java
Tulis sekali, jalankan di mana saja - Masih ada beberapa hal yang tidak kompatibel
antara platform satu dengan platform lain. Untuk J2SE, misalnya SWT-AWT bridgeyang
sampai sekarang tidak berfungsi pada Mac OS X.
Mudah didekompilasi. Dekompilasi adalah proses membalikkan dari kode jadi menjadi
kode sumber. Ini dimungkinkan karena kode jadi Java merupakan bytecode yang menyimpan
banyak atribut bahasa tingkat tinggi, seperti nama-nama kelas, metode, dan tipe data. Hal
yang sama juga terjadi pada Microsoft .NET Platform. Dengan demikian, algoritma yang
digunakan program akan lebih sulit disembunyikan dan mudah dibajak/direverse-engineer.
Penggunaan memori yang banyak. Penggunaan memori untuk program berbasis Java
jauh lebih besar daripada bahasa tingkat tinggi generasi sebelumnya seperti
C/C++dan Pascal (lebih spesifik lagi, Delphi dan Object Pascal). Biasanya ini bukan
merupakan masalah bagi pihak yang menggunakan teknologi terbaru (karena trend memori
terpasang makin murah), tetapi menjadi masalah bagi mereka yang masih harus berkutat
dengan mesin komputer berumur lebih dari 4 tahun.
2.4 Sekilas Tentang NetBeans IDE 7.3
NetBeans IDE adalah sebuah Integrated Development Environment untuk para pengembang
software. Software ini dapat membantu dalam membuat sebuah aplikasi dimulai dari java, C++, Java
Me, Java EE, Java FX, Java SE dan lain sebagainya. Netbeans sangat membantu bagi para pemrogram
yang masih belajar atau takut terjadi kesalahan pasalnya software ini dapat mendeteksi kesalahan.

15. Netbeans IDE mudah diinstal dan digunakan langsung di luar kotaknya dan berjalan di banyak
platforms termasuk Windows, Linux, Mac OS X dan Solaris.
Feature yang diberikan NetBeans IDE:
 Best Support for Latest Java Technologies
 Fast & Smart Code Editing
 Easy & Efficient Project Management
 Rapid User Interface Development
 Write Bug Free Code
 Support for Multiple Languages
 Cross Platform Support
 Rich Set of Community Provided Plugins
Pada praktikum kali ini saya membuat program dengan menggunakan NetBeans IDE 7.3.
untuk penginstalan NetBeans IDE 7.3 ini kita perlu menginstal JDK terlebih dahulu, Setelah
itu Install NetBeans IDE 7.3.
2.4.1 Instalasi JDK
Langkah pertama adalah penginstalan JDK. Klik dua kali pada file JDK yang telah kita
download. Selanjutnya program akan mennunggu beberapa saat untuk persiapan
penginstalan.
Jika telah muncul jendela seperti di bawah ini klik “Next”.
Gambar 1 (a)

16. Jika telah muncul jendela seperti di bawah, kita dapat merubah atau memilih letak directori file
JDK yang kita buat. Selanjutnya klik Next.
Gambar 1 (b)
Gambar 1 (c)

17. Program mulai melakukan penginstalan.
Penginstalan JDK telah selesai, klik “Close” untuk menutupnya.
2.4.2 Instalasi NetBeans IDE 7.3
Sama seperti sebelumnya, kita hanya perlu membuka file NetBeans yang telah kita
download. Selanjutnya installer akan membutuhkan waktu beberapa detik untuk
mengkonfigurasi dirinya sendiri, lalu setelah itu akan menampilkan selamat datang dan siap
melanjutkan instalasi NetBeans.
Gambar 1 (d)
Gambar 1 (e)
Gambar 1 (a), (b), (c), (d),(e)Proses instalasi JDK

18. Selanjutnya akan muncul seperti di bawah ini.
Seperti halnya pada instalasi Java SDK atau produk-produk berlisensi lain, installer NetBeans
akan menyodorkan halaman persetujuan antara pembuat software dan anda sebagai pemakai.
Centanglah pada check-box berlabel I accept the terms in the license agreement sebagai
tanda bahwa anda menyetujui dan berniat selanjutkan instalasi, lalu klik tombol Next.
Selanjutnya, program akan meminta anda untuk memilih salah satu dari pilihan di atas,
pilihlah “I accept the terms in the license agreement. Install Junit”.
Gambar 2 (a)
Gambar 2 (b)
Gambar 2 (c)

19. Selanjutnya klik tombol Next.
Setelah itu pilihlah tempat lokasi dimana file – file NetBeans akan disimpan. Pilih Browse
untuk merubah lokasi Defaults.
Gambar 2 (d)
Gambar 2 (e)
Gambar 2 (f)

20. Installer NetBeans akan menampilkan kembali lokasi instalasi yang telah dipilih ditahap
sebelumnya, juga menunjukkan besarnya ruang yang diperlukan. Jika anda sudah yakin,
kliklah Next agar instalasi segera dieksekusi.
Proses instalasi akan berjalan dalam beberapa menit. Makin tinggi spesifikasi PC anda, akan
makin cepat proses instalasinya berlangsung. Sebagai contoh, dengan PC berprosesor Celeron
3,06 GHz dan RAM 512 MB, masih sempat untuk mengambil cemilan atau membuat
minuman terlebih dahulu.
Installer akan memberitahu anda saat instalasi selesai. Ada dua penawaran yang bisa anda
centang, yang pertama adalah ikut berkontribusi tidak langsung dengan mengijinkan PC anda
mengirim data untuk statistik penggunaan NetBeans ke situs NetBeans.org (ini jika anda care
pada NetBeans), dan penawaran kedua adalah mendaftarkan NetBeans yang baru saja diinstal
agar bisa mendapatkan fasilitas dari NetBeans.
Gambar 2 (g)
Gambar 2 (h)
Gambar 2 (a),(b),(c),(d),(e),(f),(g),(h) Proses instalasi NetBeans IDE 7.3

21. Centanglah penawaran yang anda suka, atau jika tidak pun tombol Finish tetap dapat diklik
untuk menutup kotak dialog instalasi yang sudah selesai.
Setelah proses instalasi selesai, kita bisa segera menjalankan NetBeans. Defaultnya,
NetBeans bisa dibuka dengan mengklik Start pada Windows XP, lalu pilih Programs, pilih
kelompok menu NetBeans, lalu klik NetBeans IDE.
Gambar 3 Loading memulia NetBeans IDE 7.3
Gambar 4 NetBeans IDE 7.3 telah siap untuk digunakan.

22. BAB III
METODOLOGI
3.1 Praktikum 1 Program Array
Flowchart:
Setelah semua aplikasi yang dibutuhkan telah disiapkan, maka langkah selanjutnya adalah
pembuatan project. Project pada praktikum 1 ialah Searching atau pencarian. Langkah-
langkah pembuatannya adalah:
1. Masuk pada halaman java (Netbeans)
2. Pilih “File” "New Project”
3. Pilih categories  General, Projects Java Aplication
4. Klik “Next”
5. Project Name tulis array03
6. Beri centang pada “create main class”
7. Tulis program dibawah ini
8. Save projet dan jalankan.
Output dataArray
END
Output Nilai
For i=0; i<nilai; i++
START

23. 3.2 Praktikum 2 Penentuan Nilai Tertinggi
Flowchart:
Nilai Array
START
END
Nilai [a] > max
Output nilai tertinggi
Y
N
For a=0; a<nilai;
a++

24. Project pada praktikum 2 ialah pencarian nilai tertinggi. Langkah-langkah pembuatannya
adalah:
1. Masuk pada halaman java (Netbeans)
2. Pilih “File” "New Project”
3. Pilih categories General, Projects Java Aplication
4. Klik “Next”
5. Project Name tulis array_max
6. Beri centang pada “create main class”
7. Tulis program dibawah ini
8. Save projet dan jalankan.

25. 3.3 Praktikum 3 Penentuan Nilai Terendah
Project pada praktikum 3 ialah pencarian nilai terendah. Langkah-langkah pembuatannya
adalah:
1. Masuk pada halaman java (Netbeans)
2. Pilih “File” "New Project”
3. Pilih categories General, Projects Java Aplication
4. Klik “Next”
5. Project Name tulis array_min
6. Beri centang pada “create main class”
7. Tulis program dibawah ini
< min
nilai
terendah

26. 8. Save projet dan jalankan.

27. BAB IV
HASIL DAN ANALISIS
Setelah selesai melakukan Pratikum Konstruksi Kompiler ini, praktikan mendapatkan hasil
dan Analisis dari Metode-metode Percobaan, antara lain sebagaiberikut:
4.1 Hasil Program
4.1.1 Praktikum 1 Program Array
Berikut hasil runing dari program yang sudah dibuat.
Gambar 5 Hasil runing program Array
4.1.2 Praktikum 2 Pencarian Nilai Tertinggi
Berikut hasil runing dari program yang sudah dibuat.
Gambar 6 Hasil runing program Pencarian Nilai Tertinggi

28. 4.1.3 Praktikum 3 Pencarian Nilai Terendah
Berikut hasil runing dari program yang sudah dibuat.
Gambar 7 Hasil runing program Pencarian Nilai Terendah
4.2 Analisis Program
4.2.1 Program Array
Program ini menampilkan data yang tersimpan pada array. Data kemudian diurutkan dari data
pada array ke 1 hingga ke 5, dimana nilai ke 1 adalah 39, nilai ke 2 adalah 61, nilai ke 3 adalah 44,
nilai ke 4 adalah 23, dan nilai ke 5 adalah 15.
4.2.2 Program Pencarian Nilai Tertinggi
Dengan perulangan for, program akan terus mencari data mana yang paling besar. Jika data
pertama lebih besar dari data kedua maka program akan terus mencari hingga mendapatkan nilai
tertinggi. Bila nilai tertinggi sudah ditemukan maka program akan menampilkan data terbesar dari
array tersebut.
4.2.2 Program Pencarian Nilai Terendah
Dengan perulangan for, program akan terus mencari data mana yang paling kecil. Jika data
pertama lebih kecil dari data kedua maka program akan terus mencari hingga mendapatkan nilai
terkecil/terendah. Bila nilai terkecil sudah ditemukan maka program akan menampilkan data terkecil
dari array tersebut.

29. BAB V
PENUTUP
5.1 Kesimpulan
Java dikenal sebagai bahasa pemprograman yang bersifat strongly, yang berarti diharuskan
mendeklarasikkan tipe data dari semua variabel yang apabila salah dalam mengikuti aturan variabel,
maka akan terjadi error pada saat dikompilasi.
Untuk saat ini kita telah mempunyai gambaran tentang bagaimana proses pembuatan program
Java secara sederhana. Tipe data dalam bahasa pemprograman java sama dengan bahasa
pemprograman lainnya yakni integer, float, byte, double, boolean, dan lain-lain.
5.2 Saran
Saran saya terhadap pembaca agar laporan ini dapat dijadikan sebagai bahan referensi
untuk menambah ilmu pengetahuan kita. Terkait program yang dibuat, akan tampak lebih
menarik bila menggunakan JFrame Form.
Kita dapat mencoba mengembangkan program sederhana ini sesuai dengan keinginan kita
tentunya berdasarkan hal-hal yang sudah diketahui. Konsep dasar yang sudah didapatkan
diharapkan dapat terus dikembangkan. Selamat mencoba!

30. DAFTAR PUSTAKA
1. http://lecturer.eepis-its.edu
2. http://cibatok.host56.com/ecibatok/index.php/isi/view/16-Sekilas-Tentang-Bahasa-
Pemograman-Ban-Java---Berb.html
3. Layuk,Tombi,2013. ”Modul pratikum Program Array”,Bontang
4. Layuk,Tombi,2013.” Modul pratikum Program Maximum dan minimum”,Bontang
5. http://www.ilmukomputer.com.