Buku Java
Buku Java
1.3 Langkah pertama yang harus dilakukan agar dapat mengkompilasi dan menjalankan program Java
adalah menginstall system Java. File system Java bisa diperoleh secara Cuma-Cuma pada web site
http://java.sun.com sebagai situs resmi Java. Beberapa syarat penting yang harus kita ketahui sebelum
menginstall system Java adalah:
• Sistem operasi yang digunakan harus mendukung penamaan file lebih dari 8 karakter dan
penamaan ekstensi file lebih dari 3 karakter. Contoh sistem operasi yang bisa digunakan adalah
Mictosoft Windows 2000, baik Profesional maupun Server. Sangat disarankan agar anda
menggunakan sistem operasi ini.
• Harus tersedia ruang kosong pada hard disk minimal 200 Mbyte untuk instalasi yang
membutuhkan fasilitas Help dan dokumentasi.
• Pada komputer harus terpasang mouse untuk memudahkan pemilihan topik Instalasi maupun
instruksi pada fasilitas Help
• Memori yang terpasang minimal 32 Mbyte
• Processor yang digunakan adalah jenis Pentium II atau yang lebih baik
Proses Instalasi dimulai dengan menjalankan file : j21_3_0-Windows.exe yang merupakan sistem Java 1.3.
JDK singkatan dari Java Development Kit. Instalasi di mulai dengan membaca file sumber java.
Pada saat proses Instalasi berlangsung, Komputer akan menanyakan lokasi tempat sistem Java akan
diletakkan. Secara default seluruh program yang di install pada sistem operasi Microsoft Windows akan
diletakkan di directory “C:\Program Files\programs”, namun JDK1.3 akan menggunakan “C:\jdk1.3”
sebagai directory defaultnya.
Error: Reference source not found
Jika button ‘Browse” di-clik, Komputer akan menampilkan sebuah form dialog yang dapat diisi dengan
directory tempat file-file sistem java akan diletakkan.
Kita sudah menentukan directory “c:\jdk1.3” sebagai directory untuk sistem java. Tahap selanjutnya adalh
menentukan library yang akan diinstall.
Pilihlah semua item yang disediakan, kemudian clik button “Next” untuk melanjutkan proses Instalasi.
Sekarang tinggal menunggu proses Instalasi sampai selesai.
Kita memerlukan file Javac.exe untuk mengcompile program Java dan file Java.exe untuk menjalankan
file hasil compile tersebut. Kedua file ini akan kita link dengan EditPlus sehingga proses compile dan
running dapat dijalankan melalui EditPlus. Jika anda ingin mengcompile dan menjalankan program Java
melalui Dos-command, anda harus melakukan beberapa langkah yang membosankan; dan ini yang kita
hindari. Sekarang kita akan melakukan setting data yang berhubungan dengan pembuatan program Java.
Error: Reference source not found
Pada form “Preferences” clik button “ Add Tool>>” lalu pilih sub menu “Program untuk membuat suatu
short-cut sebuah file bertipe application, dengan ekstensi .EXE atau COM.
Langkah pertama adalah kita akan melakukan link dengan file javac.exe. File ini terdapat di directory
tempat kita menginstall sistem Java. Pada area “Menu text” ketikkan komentar yang menunjukkan proses
yang dikerjakan oleh short-cut ini. Gunakan kata-kata yang mudah dimengerti dan singkat. Misalkan
“Compile program Java”.
Gunakan button untuk memilih directory dan nama file yang dibutuhkan,. Arahkan directory pada lokasi
Instalasi Java dan nama file pada file javac.exe (C:\jdk1.3\bin\javac.exe). Langkah selanjutnya adalah
mengisi area “Argument”.
Clik button pada area ini, lalu oilih sub menu “File Nama”. File javac.exe membutuhkan nama file beserta
ekstensi dari program Java yang akan dicompile. Option “File Name” akan mengirimkan nama file dan
ekstensinya (.java) ke file javac.exe. Terakhir pada area “Initial directory” hanya ada satu pilihan yaitu
“File Directory. Clik pada sub menu ini, kemudian proses selesai.
Selanjutnya adalah clik button ‘OK’ atau ‘Apply’ yang ada di bawah form. Disarankan agar anda clik
button ‘Apply’ karena kita akan melanjutkan proses pembuatan short-cut untuk menjalankan program Java.
Sekarang kita akan membuat short-cut untuk menjalankan program Java. Ulangi langkah pertama sampai
terakhir tadi dengan data-data sebagai berikut:
Error: Reference source not found
• Area “Menu text” diisi dengan text “Menjalankan program Java”.
• Area “Command” diisi dengan directory dan nama File Java.exe. (C:\jdk1.3\bin\java.exe)
• Area “Argument” diisi dengan sub menu “File Name Without Extension”.
• Area “Initial directory” diisi dengan “File directory “.
Sekarang kita sudah siap membuat program Java. Pada bagian-bagian selanjutnya kita akan menggunakan
EditPlus ini sebagai editor bagi program Java yang kita buat.
Error: Reference source not found
Jika sekarang anda perhatikan menu “Tools” dari EditPlus maka pada bagian akhir ada tambahan daftar
short-cut yang telah kita definisikan tadi.
Proses kompilasi program Java juga dapat dilakukan dengan menekan kombinasi tombol
‘Ctrl+1’,sedangkan untuk menjalankan program Java dapat digunakan kombinasi penekanan tombol
‘Ctrl+2’.
Bab 2
Pengantar Bahasa Java
B. Tujuan
• Mampu membuat program Java sederhana.
• Mampu membuat program java yang berisi proses input/output data.
• Mampu membuat program Java menggunakan class JOptionPane.
• Mampu membuat program java yang berisi proses menangkap kesalahan proses.
• Mampu membuat program java yang melibatkan kontanta dan komentar.
Mari kita membedah program diatas baris demi baris mulai dari baris 1 :
1 class Satu
Mendeklarasikan sebuah class dengan nama Satu diawali dengan tanda “{“ dan diakhiri dengan “}”. Java
adalah bahasa berorintasi objek murni jadi segala sesuatunya harus berada didalam objek. Class sendiri
dapat dikatakan sebagai spesifikasi/desain dari objek, dalam hal desain yang anda buat adalah class itu
sendiri contoh gedung yang dibangun berdasarkan desain tersebut sebagai objectnya. Dengan demikian
jelas bahwa class adalah suatu spesifikasi/desain dari objek sedangkan objek sendiri adalah
instance(perwujudan) dari class.
baris diatas mendeklarasuikan sutau method dengan nama main. Nama main disini merupakan suatu
keharusan dalam java karena java akan mencari method yang bernama main sebagai titik awal eksekusi
program.
• Public = merupakan access specifer yang menentukan visibility level dari method ini berarti
dapat diakses/dipanggil dari luar class dimana ia mendeklarasikan.
• Main = akan dipanggil dari luar oleh runtime java pada saat program akan dieksekusi sehingga
akses specifer yang dimiliki harus dipublic.
• Static = memungkinkan method main() dipanggil tanpa harus terlebih dahulu membuat instace
dari class Satu. Ini diperlukan karena method main() akan dieksekusi sebelum objek apapun
dibuat dimemori.
• Void = method main() tidak mengembalikan nilai apapun setelah dipanggil/eksekusi.
4 system.out.println(“Hello world”);
intruksi dasar :
• system, adalah nama dari salah satu class standar yang dimiliki oleh java.
• Out, anggota dari class system dan juga merupakan objek tersendiri dalam hal ini adalah layar
komputer anda.
• Println, method yang terdapat diobjek out berfungi mencetak keluaran standart outputnya.
• Hello world merupakan parameter arti method println() yang diterima oleh internal method ini dan
dicetak ke standard output yang dalam hal ini dilayar computer .
• Tanda ; menandakan akhir dari suatu statement/pernyataan/ perintah.
Sebuah program java disimpan sama dengan nama class pada file tersebut contoh program diatas Save As :
Satu.java ekstensi file harus .java ini sebagai indicator file program java.
Langkah selanjutnya adalah mengcompile program ini klik menu Tolls>Compile program java Ctrl+1
java akan menampilkan sebuah Dos based-window selama proses kompilasi. Program java yang sudah
dicompile akan mendapat ekstensi .class FILE inilah yang bisa dijalankan oleh interpreter Java atau Java
Virtual Machine(JVM).
Langkah selanjutnya kita akan dapat menjalankan program tadi dengan klik menu Tools>Menjalankan
program Java , sekali lagi Java akan menggunakan layer DOS untuk menampilkan hasil program.
Langkah-langkah dalam mempersiapkan dan membuat program ini akan terus digunakan untuk membuat
program-program berikutnya. Seringlah latihan membuat program agar anda terbiasa dan terampil
mengasah logika.
Seringkali diperlukan suatu tipe data diproses sebagai tipe data lain, misalnya data string
angka diproses sebagai data numeric. Dalam situasi seperti ini diperlukan konversi data :
Kita akan menghitung “9 / 4” seharusnya perhitungan ini menghasilkan 2..25, tetapi yang terjadi adalah 2.
Variabel yang terlibat dalam perhitungan ini,x dan y, bertipe int; sedangkan variabel untuk menampung
hasil perhitungan, z, bertipe double. Ada satu aturan bahwa jika variabel yang terlibat semuanya bertipe
bilangan bulat, hasil perhitungan pun akan bertipe bilangan bulat tidak tergantung pada tipe variabel
penampungnya; dengan kata lain hanya diambil bagian integernya saja. Konsekuensinya adalah hasil
proses yang terjadi memiliki kesalahan. Jika salah satu atau semua operand yang terlibat dalam ekspresi
Baris 7 kita modifikasi menjadi double z = ( double )x/y; Sekarang program ini memberikan hasil yang
benar. 9 / 4 = 2.25
Penulisan ( double ) x menyatakan bahwa dalam proses perhitungan ini nilai x diubah menjadi tipe double .
Nilai aktualnya tetap dalm tipe int. Perubahan ini hanya bersifat sementara pada saat proses perhitungan
dilakukan. Dalam hal ini yang diubah menjadi pecahan hamya variabel x, sedangkan variabel y tetap Ini
berbeda jika pernyataan( double ) diletakkan didepan y.
Pernyataan system.out.printin (int) (5.5 / 20 ) ); tidak akan menghasilkan 2.75, tetapi 2. Hasil perhitungan
sesungguhnya memang 2.75, tetapi yang ditampilkan hanya bagian integernya saja.
Kadang kala proses konversi data tidak dapat dilakukan dengan cara type-casting, misalnya mengubah nilai
numeric ke string.
1 class KonversiString
2 {
3 public static void main (string[] args)
4 {
5 system.out.println((string)(5.5/2));
6 }
7 }
proses konversi ini tidak boleh pada baris 5 sehingga perlu dicari cara lain. :
System.out.println (Double.toString(5.5/2));
Method lain yang sering digunakan untuk konversi data adalah integer.parselnt( data string ) untuk
mengkonversi variabel data string manjadi tipe integer.
1 class KonversiInteger
2 {
3 public static void main (String[] args)
4 {
5 System.out.println(Integer.parseInt(“5”));
6 }
7 }
Program konversi Integer.Java menunjukkan penggunaan method parselnt() untuk mengubah data string
“5” manjadi data numeric 5. Data string adalah tidak bisa dikenakan operasi matematis seperti
penjumlahan, sedangkan data numeric bisa dikenakn operasi matematis. Output yang diberikan oleh
program ini adalah sebagai berikut:
5
Ilustrasi yang lebih jelas adalah jika kita memberikan hasil konversi ke variabel tg bersesuaian dengan tipe
hasil konversi tersebut misalnya variabel bertipe double digunakan untuk menampung konversi dari
method parseDouble().
1 class VariabelKonversi
2 {
3 public static void main (String[] args)
4 {
5 String data = "7.45";
6 double pecahan = Double.parseDouble(data);
7 System.out.println("isi variable data :" + data);
8 System.out.println("isi variable pecahan :" + pecahan);
9 }
10 }
Variabel data menyimpan data string “7.45”, sedangkan variabel pecahan menyimpan hasil konversi dari
string tersebut dalam format double.
Kebalikan dari konversi data string manjadi data numeric ditunjukkan pada program berikut ini, dimana
kita melakukan konversi data numerik menjadi data string dengan output yang sama dengan program
sebelumnya.
1 class VariabelKonversi2
2 {
3 public static void main (String[] args)
4 {
5 double pecahan=7.45;
6 String data = Double.toString(pecahan);
7 System.out.println("isi variable data :" + data);
8 System.out.println("isi variable pecahan :" + pecahan);
9 }
10 }
2.7 Manipulasi Data
Yang dimaksud dengan manipulasi data adalah proses mengubah isi variabel dengan suatu nilai baru. Nilai
baru ini mungkin berupa nilai mutlak, mungkin juga berupa nilai yang diperoleh dari suatu proses
matematika.
Lalu di dalam tubuh program ada kode untuk mengubah nilai variabel pecahan :
Pecahan =pecahan + 3 ;
Yang menyatakan bahwa isi variabel pecahan yang sekarang adalah isi semula(7.45) ditambah dengan 3,
maka sekarang variabel pecahan menyimpan data 10.45. Bentuk penulisan seperti ini sangat umum
dilakukan pada berbagai bahasa pemrograman. Jv menyediakan cara lain untuk melakukan manipulasi data
dengan cara yang lebih singkat:
Pecahan += 3;
Penulisan seperti ini memiliki arti yang sama dengan penulisan sebelumnya, tetapi lebih singkat. Kita harus
menuliskan “+=” berdaampingan tanpa spasi, sedangkan sebelum dan sesudahnya boleh ada spasi.
Penulisan singkat seperti ini tidak hanya berlaku pada penjumlahan,tetapi bisa diterapkan untuk
pengurangan, perkalian, pembagian dan sisa hasil bagi.
Pecahan /= 3;
Bentuk penulisan ini menyatakan bahwa isi variabel pecahan sekarang adalah isi sebelumnya dibagi dengan
3.
Pecahan += angka * 3;
Sekarang kita akan membuat sebuah program yang mengilustrasikan penggunaan singkat matematika.
Program akan menghitung jumlah pecahan uang dari data yang kita berikan. Misalnya kita memasukkan
angka 13050, maka computer akan melaporkan bahwa uang tersebut terdiri dari:
diasumsikan bahwa pecahan yang tersedia adalah 100.000, 50.000, 20.000, 10.000, 5.000, 500, 100 dan 50.
47 nilaiUang %=50;
48 hasil += "\nLima puluh = "+ Integer.toString (limapuluh);
49 sisa = nilaiUang;
50 hasil += "\nSisa = "+ Integer.toString(sisa);
51 JOptionPane.showMessageDialog (null,hasil);
52 System.exit(0);
53 }
54 }
Compile lalu jalankan program ini. Berikan sebuah data numerik yang menyatakan nialai uang yang akan
di proses , misalnya 13750.
Silahkan anda menganalisa bagaimana proses menghitung banyaknya pecahan uang untuk setiap item.
Yang perlu mendapat perhatian adalah penulisan instruksi pada proses manipulasi data yang bentuknya
dipersingkat. Kita ambil contoh instruksi pada baris 26, 27 dan 28.
Pada baris 26 kita mengubah isi variabel seratus ribu dengan hasil perhitungan nilai uang dibagi 100.000.
Cara yang biasa kita gunakan adalah
Penulisan seperti ini tentu memakan waktu lebih lama karena jumlah karakter yang kita ketik lebih banyak.
Terakhir, pada instruksi pada baris 28 kita mengubah isi variabel string hasil dengan menambahkan isinya
semula dengan data string baru. Kalau kita menggunakan cara lama, maka instruksi tersebut kita tuliskan
Yang tentu saja lebih panjang dan melelahkan. Bentuk khusus untuk mempersingkat penulisan proses
manipulasi data adalah auto-increment dan auto-decrement yang hanya bekerja dengan bilangan satu. Auto
increment adalah proses menambahkan isi suatu variabel dengan satu. Sebaliknya,auto-decrement adalah
proses mengurangi isi suatu variabel dengan satu. Perhatikan ilustrasi berikut ini:
Pecahan ++;
Bentuk ini menyatakan bahwa isi variabel pecahan ditambah dengan satu. Cara penulisan seperti ini disebut
post-increment. Kebalikan dari post-increment adalah pre-increment , dimana kita meletakkan operator dan
post-increment .
15 penampung_1 = pecahan_1++;
16 penampung_2 = ++pecahan_2;
17 System.out.println();
18 System.out.println("Isi variable sekarang");
19 System.out.println("------------");
20 System.out.println("pecahan_1 = "+ pecahan_1);
21 System.out.println("pecahan_2 = "+ pecahan_2);
22 System.out.println("penampung_1 = "+ penampung_1);
23 System.out.println("penampung_1 = "+ penampung_1);
24 }
25 }
Mula-mula variabel pecahan _1 dan pecahan _2 diberi nilai awal 5, dan variabel penampung_1 dan
penampung_2 diberi nilai awal 0. proses selanjutnya adalah mengubah isi variabel penampung _1 dan
penampung_2. proses ini terdapat pada instruksi baris 17 dan 18.
Pre-increment akan menambahkan isi variabel pecahan _2,terlebih dahulu sebelum disalinkan ke variabel
penampung _2, berbeda dengan post-increment yang akan menyalinkan isi variabel pecahan _1 ke variabel
penampung _1 terlebih dahulu sebelum akhirnya ditambahkan dengan satu. Pemahaman yang sama berlaku
juga untuk auto-decrement. Cobalah untuk melatih logika auto-incrementdan auto-decrement ini agar
diperoleh pemahaman yang baik.
Bentuk tampilan angka kiranya perlu mendapat perhatian lebih. Sejumlah angka yang ditampilkan secara
tabuler harus mengikuti kaidah angka satuan ditampilkan paling kanan, diikuti sebelah kirinya dengan
angka puluhan, lalu ratusan ribu, ribuan dan seterusnya. Secara default Java akan menampilkan data
numerik seperti apa adanya. Kita buat sebuah program singkat berikut ini:
9 }
10 }
Kita akan menampilkan empat buah bilangan pada baris terpisah. Program ini memberikan output sebagai
berikut
1000
100
10
1
Bentuk output angka seperti ini tentu tidak tepat untuk menggambarkan urutan angka, misalnya jika semua
angka tersebutakan dijumlahkan. Java menyediakan class Number Format untuk mengatur format tampilan
angka. Program berikut ini merupakan modifikasi dari program diatas, dimana kita sudah menambahkan
fasilitas untuk
memformat tampilan angka.
Latihan Program 2.10
1 import java.text.NumberFormat;
2 class formatBil2
3 {
4 public static void main(String[] args)
5 {
6 NumberFormat nf = NumberFormat.getInstance();
7 nf.setMinimumIntegerDigits(4);
8 System.out.println(nf.format (1000));
9 System.out.println(nf.format (100));
10 System.out.println(nf.format (10));
11 System.out.println(nf.format (1));
12 }
13 }
Output program
1,000
0,100
0,010
0,001
7 nf.setMinimumIntegerDigits(4);
8 nf.setGroupingUsed (false);
9 System.out.println(nf.format (1000));
10 System.out.println(nf.format (100));
11 System.out.println(nf.format (10));
12 System.out.println(nf.format (1));
13 }
14 }
Output program
1000
0100
0010
0001
Pengaturan format bilangan juga dapat dilakukan terhadap bilangan pecahan , misalnya kita ingin
menampilkan seluruh bilangan minimal 3 angka pecahan .
7 nf.setMinimumIntegerDigits(3);
8 System.out.println(nf.format (100.523560));
9 System.out.println(nf.format (100.52326));
10 System.out.println(nf.format (100.523));
11 System.out.println(nf.format (100.5));
12 }
13 }
100.524
100.523
100.523
100.500
Selain menggunakan method setMinimumFractionDigits() untuk mengatur jumlah angka minimal, kita juga
bisa menggunakan method setFractionDigits() untuk mengatur jumlah angka pecahan maksimal.
Latihan Program 2.13
1 import java.text.NumberFormat;
2 class FormatBilPecahan2
3 {
4 public static void main(String[] args)
5 {
6 NumberFormat nf = NumberFormat.getInstance();
7 nf.setMinimumIntegerDigits(3);
8 nf.setMaximumFractionDigits(5);
9 System.out.println(nf.format (100.523560));
10 System.out.println(nf.format (100.52326));
11 System.out.println(nf.format (100.523));
12 System.out.println(nf.format (100.5));
13 }
14 }
100.500
Sampai saat ini kita sudah membahas tentang bagaimana cara untuk menerima dan menginformasikan data
. method readline() digunakan untuk menerima inputan data melalui keyboard dan method print() atau
println() digunakan untuk menampilkan data ke layer. Kedua cara Input dan output ini akan bekerja pada
layer mode teks, seperti pada saat kita bekerja pada system operasi MS-DOS.
Cara lain untuk melakukan proses I/O adalah menggunakan class JOptionPane. Class ini terdapat di
papackage Javax.swing, sehingga setiap program yang menggunakan class JOptionPane harus menuliskan
Javax.swing.JOptionPane. Class JOptionPane menyediakan sarana I/O dengan bentuk tampilan yang lebih
baik , berbasis grafik. Model tampilan ini serupa dengan model tampilan system operasi MS-Windows.
Beberapa method yang akan kita gunakan adalah :
Method showlnputDialog() digunakan untuk menerima inputan dari user melalui keyboard. Data yang
dikembalikan oleh method ini selalu dalam bentuk string., sehingga untuk memperoleh data numerik perlu
dilakukan proses konversi data . pgr berikut ini mengilustrasikan penggunan method showlnputDialog ().
2 class inputDialog1
3 {
4 public static void main (String[] args)
5 {
6 String nama;
Compile dan jalankan program ini. Komputer akan meminta inputan dari kita melalui suatu interface yang
lebih baik daripada sekedar console.
Pada area yang disediakan kita mengetikkan sebuah nama, misalnya “Indah”,lalu kita clik button “OK”
atau menekan tombol “ENTER”. Komputer akan menangkap data yang kita berikan lalu menampilkan
hasilnya ke layer.
Hallo Indah
Kemungkinan yang lain bisa terjadi adalah kita membatalkan pemberian data; dengan kata lain kita clik
button ‘Cancel’ atau kita menekan tombol ‘ESCAPE’. Dalam kasus seperti ini komputer akan menganggap
kita memberikan data kosong atau null.
Hallo Null
2 class inputDialog2
3 {
4 public static void main (String[] args)
5 {
6 String nama;
9 System.exit(0);
10 }
11 }
Jalankan program ini lalu inputkan sebuah nama, misalnya “Indah”. Output yang dibarikan adalah sebagai
berikut :
Variasi lain dari method showMessageDialog() diperhatikan pada pgr berikut . Disini kita menentukan
judul form message (defaultnya string “Message”), lalu kita menentukan jenis pesan yang akan ditampilkan
(default: “INFORMATION_MESSAGE).
9 System.exit(0);
10 }
11 }
Perbedaan output ini dengan sebelumnya adalah judul form message yang sudah kita ganti dengan string
“Informasi”. Ada beberapa jenis message yang bisa kita berikan:
• INFORMATION_MESSAGE
• ERROR_MESSAGE
• WARNING_MESSAGE
• QUESTION_MESSAGE
• PLAIN_MESSAGE
Jenis-jenis message ini digunakan tergantung maksud dan keperluan kita menampilkan suatu message. Jika
message yang akan kita tampilkan dimaksudkan sebagai informasi pesan kesalahan suatu proses , kita dapat
memberikan nilai ERROR_MESSAGE. Efek langsung yang tampak di layar adalah gambar icon yang
ditampilkan pada form message yang diberikan. Misalnya kita membuat sebuah aplikasi yang akan
menyimpan data ke floppy disk, lalu pada saat itu disk drive dalam keadaan terbuka, maka komputer akan
memberikan informasi bahwa data tidak bisa disimpan karena disk drive belum ditutup.
Silahkan anda berkreasi dengan jenis message yang lain dan lihat efek yang muncul di layar . gunakan
jenis-jenis message ini secara tepat agar tidak membingungkan usre.
3. Method showConfirmDialog()
Method showConfirmDialog() digunakan untuk melakukan konfirmasi dengan user tentang suatu proses,
misalnya apakah user akan mengulang input data atau tidak. Langsuna saja sekarang kita akan membuat
sebuah program tg akan terus melakukan input data selama user menghendaki hal itu.
Latihan Program 2.17
1 import javax.swing.JOptionPane;
2 class inputDialog4
3 {
4 public static void main (String[] args)
5 {
6 String nama;
7 do
8 {
9 nama = JOptionPane.showInputDialog("ketik nama Anda :");
Compile lalu jalankan program ini. Mula-mula komputer akan menampilkan form untuk input data:
Setelah kita clik button ‘OK’ muncul proses akan dilanjutkan dengan menampilkan sebuah form message:
Setelah kita clik button ‘OK’ muncul form konfirmasi berikut:
Pada saat form konfirmasi muncul, kita dapat melakukan clik pada button ‘No’ atau Cancel’ untuk
mengakhiri proses. Dalam contoh ini kita menggunakan control program while untuk mengulang suatu
proses. Secara detail pembahasan mengenai while akan dijelaskan pada bab berikutnya.
Secara default form konfirmasi akan ditampilkan dengan tiga button: ‘Yes’, ‘No’ dan ‘Cancel’. Java
memberikan kebebasan kepada kita untuk menggunakan beberapa button yang memang kita perlukan.
Yang tidak bisa kita lakukan adalah mengganti kata-kata pada button dengan kata-kata lain,misalnya
‘Cancel’ diganti dengan ‘Batal’. Dengan sangat terpaksa kita harus menggunakan kata-kata ini.
Untuk mengatur agar form hanya menampilkan button ‘Yes’ dan ‘No’ saja kita bisa menggunakan
statement berikut ini:
Seringkali kita tidak menyadari bahwa kode yang kita tulis bisa menimbulkan kesalahan pada saat program
berjalan (run-time), misalnya kita membuat program yang meminta masukkan berupa data numerik. Jika
user memberikan data karakter maka komputer akan menghentikan program dengan sejumlah informasi
kesalahan proses. Kita belum mengantisipasi kesalahan ini sebelumnya. Sebuah program yang baik harus
bisa menangani kemungkinan terjadinya kesalahan lalu bisa mengarahkan alur secara normal.
Istilah “menangkap kesalahan proses “ merujuk kepada suatu mekanisme untuk mencegah terjadinya
kesalahan proses program yang disebabkan oleh data yang diberikan tidak valid. Bahasa komputernya :
data yang diberikan tidak boleh berupa garbage alias sampah. Kalau kita memberikan data yang salah,
maka secanggih apapun komputer yang dimiliki tetap tidak ada gunanya. Data yang akan diolah harus
benar sesuai kebutuhan.
Java menyediakan mekanisme yang bagus untuk menangkap kesalahan yang terjadi dalam suatu proses.
Perhatikan program berikut ini.
2 class PerangkapKesalahan
3 {
4 public static void main (String[] args)
5 {
6 String input;
7 int bilangan;
8 input = JOptionPane.showInputDialog("ketik sebuah bilangan :");
11 System.exit(0);
12 }
13 }
Jika kita salah memberikan data inputan, misalnya dengan mengetikkan karakter,maka komputer akan
menghentikan proses dengan memberikan informasi tentang kesalahan yang terjadi:
Dan selanjutnya program berhenti. Kejadian seperti ini sangat tidak diharapkan. Seharusnya program kita
bisa memberikan informasi kepada user bahwa data yang diberikan salah, dan program masih bisa berhenti
secara normal.
Mekanisme untuk menangkap kesalahan ada di dalam blok try dan catch. Perhatikan program berikut ini
yang merupakan perbaikan dari program sebelumnya.
Latihan Program 2.19
1 import javax.swing.JOptionPane;
2 class PerangkapKesalahan1
3 {
4 public static void main (String[] args)
5 {
6 String input = "";
7 int bilangan = 0;
8 try
9 {
10 input = JOptionPane.showInputDialog("ketik sebuah bilangan :");
19 }
20 }
Instruksi pada baris berapa pun yang terletak di dalam blok try yang mengalami kesalahan, alur program
akan dipindahkan ke dalam blok catch. Sekarang jika kita akan memindahkan inputan yang
salah,”STIKOM” misalnya, maka komputer akan memindahkan alur proses dan mengerjakan instruksi
yang ada di dalam blok catch.
Class exception pada baris 18 merupakan class yang merujuk kepada jenis kesalahan secara umum.
Statement catch (Exception e)menyebabkan komputer akan menangkap kesalahan yang terjadi, apapun
jenis kesalahan tersebut. Secara spesifik class exception bisa dijabarkan menjadi beberapa jenis kesalahan,
antara lain:
• NumberFormatException, disebabkan oleh kesalahan pemasukan data dengan tipe yang berbeda
dengan tipe variabel penampung.
• ArrayIndexOutOfBoundsException, disebabkan karena kita mencoba mengakses elemen array
pada indeks di luar indeks yang valid, seperti indeks negative atau indeks 5 sementara variabel
array yang kita pakai hanya memiliki 3 elemen.
Variabel ‘e’ atau mungkin anda ingin memberi nama lain, merupakan variabel objek digunakan untuk
menampung kesalahan yang terjadi. Kita bisa mencetak ini variabel ‘e’ ini dengan terlebih dahulu
mengkonversi menjadi data string.
Latihan Program 2.20
1 import javax.swing.JOptionPane;
2 class PerangkapKesalahan2
3 {
4 public static void main (String[] args)
5 {
6 String input = "";
7 int bilangan = 0;
8 try
9 {
10 input = JOptionPane.showInputDialog("ketik sebuah bilangan :");
19 }
20 }
Jika kita memberikan inputan yang salah, misalnya karakter, komputer akan menampilkan pesan kesalahan:
Java. Lang.NumberFormatException merupakan jenis kesalahan yang terjadi. Dengan instruksi catch
( Exception e) kita bisa menangkap berbagai jenis kesalahan yang terjadi. Sekarang karena kita sudah tahu
bahwa kesalahan memasukkan data numerik dengan data string membangkitkan kesalahan
Java.lang.NumberFormat Exception maka kita bisa langsung menangkap kini dalam pernyataan cacth.
Catch (NumberFormat(Exeption e)
Kelemahan dari cara ini adalah program hanya akan bereaksi terhadap kesalahan Java.lang.
NumberFormatException . kesalahan selain itu tidak akan “ditangkap” dan tetap menimbulkan efek
“abnormal program termination” seolah-olah tidak ada perangkap kesalahan.
Cara pertama: mengkonversi error –message menjadi data string dapat dilakukan dengan cara berikut ini:
Cara kedua: mengambil langsung error- message yang terjadi dapat dilakukan dengan cara berikut ini:
Java juga bisa menangkap beberapa kesalahan sekaligus. Untuk ini kita bisa membuat blok try—cacth
secara nested, taitu di dalam sebuahblok try-cacth yang lain. Program berikut ini menunjukkan pemakaian
nested try-cacth yang lain.
Latihan Program 2.21
1 import java.io.*;
2 class MultipleCatch1
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 try
10 {
11 try
12 {
13 System.out.print("angka pertama : ");
14 int x = Integer.parseInt (dis.readLine());
17 int z= x/y;
18 System.out.println("z =" + z);
19 }
20 catch (NumberFormatException nfe)
21 {
22 System.out.println("\nsalah "+ "format angka");
23 }
24 }
25 catch (ArithmeticException ae)
26 {
27 System.out.println("\nPembagian "+ "dengan nol");
28 }
29 }
30 catch (IOException ioe)
31 {
32 System.out.println("\nSalah proses I/O");
33 }
34 }
35 }
Setiap blok try-cacth dipersiapkan untuk menangkap kesalahan yang mungkin terjadi. Jika salah satu dari
baris program pada blok try membangkitkan exception, mula-mula system akan memeriksa apakah
exception tersebut termasuk jenis NumberFormatException ,yaitukes pada saat memasukkan data numerik.
Jika exception yang terjadi bukan dari jenis ini, system akan memeriksa jenisexc itu lebih lanjut: apakah
termasuk jenis ArithmeticException,yaitu terjadi pembagian dengan bilangan nol. Jika bukan maka system
akan memeriksa apakah Exception yang terjadi termasuk ke dalam jenis IOexception. Apapunjen
Exception yang terjadi komputer akan menampilkan pesan yang sesuai pada setiap blok catch. Mari kita
jalankan program ini.
Pada saat komputer meminta inputan angka pertama kita memasukkan data bukan numerik, maka
komputer akan menampilkan pesan “Salah format angka”. Pesan ini dibangkitkan oleh
NumberFormatException. Pesan yang sama juga akan ditampilkan jika kita memasukkan data bukan
numerik pada pertanyaan kedua, jika data pertama kita berikan secara benar.
Angka pertama : 58
Angka kedua : stikom
Jika kedua data itu benar, tetapi data kedua kita beri bilangan nol, maka komputer akn menampilkan pesan
kesalahan ArithmeticException, seperti diperlihatkan berikut ini:
Angka pertama : 58
Angka kedua : 0
Jika seluruh data inputan diberikan secara benar komputer akan menghitung hasil bagi kedua bilangan
tersebut dengan mengambil bilangan bulatnya saja.
Angka pertama : 58
Angka kedua : 6
Z = 9
Cara lain untuk menghandle beberapa blok try- catch seperti ini adalah dengan membuat sebuah blok try
yang diikuti oleh beberapa blok catch. Program berikut ini merupakan modifikasi dari program diatas
dengan menerapkan multiple- catch-blok, dimana sebuah blok try diikuti oleh beberapa blok catch.
Hasilnya sama dengan program di atas.
2 class MultipleCatch2
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 System.out.println("angka pertama : ");
10 int x = Integer.parseInt (dis.readLine());
13 int z= x/y;
14 System.out.println("z =" + z);
15 }
16 catch (NumberFormatException ae)
17 {
18 System.out.println("\nsalah "+ "format angka");
19 }
20 catch (ArithmeticException ae)
21 {
22 System.out.println("\nPembagian "+ "dengan nol");
23 }
24 catch (IOException ioe)
25 {
Variabel yang memiliki data atau nilai yang bersifat tetap disebut konstanta. Nilai yang di simpan di dalam
variabel ini tidak bisa diubah selama program berjalan. Satu-satunya cara mengubah data pada konstanta
adalah dengan memodifikasi kode program, dan ini hanya bisa dilakukan oleh mereka yang mengerti
pemrograman. Konstanta dibutuhkan untuk menentukan suatu tetapan yang bersifat universal, misalnya
nilai ph pada formula matematis.
Sebuah konstanta dideklarasikan dengan menggunakan kata kunci final, yang menyatakan bahwa data yang
tersimpan pada variabel ini sudah tidak bisa di ubah-ubah lagi. Contoh deklarasi konstanta adalah:
Variabel angka adalah variabel dengan nilai yang bersifat tetap; dengan kata lain angka adalah sebuah
konstanta. Selama program berjalan,nilai yang disimpan di variabel angka, dalam hal ini 11, tidak bisa
diubah.
Jika kita mencoba mengubah nilai tersebut dalam salah satu baris program, komputer Java akan
memberikan pesan kesalahan. Perhatikan program berikut ini
Latihan Program 2.23
1 class TestError
2 {
3 public static void main (String[] args)
4 {
5 final int angka = 11;
6 angka =3;
Tidak selamanya kita bisa sgn mudah memahami alur program, apalagi jika program tersebut sangat
kompleks dan dalam pembuatannya melibatkan sebuah team. Ada bagian-bagian tertentu dari program
yang perlu mendapat penjelasan, misalnya mengenai fungsi bagian itu, keterkaitannya dengan bagian lain
dan sebagainya. Satu hal yang paling penting dari pembuatan program adalah adanya dokumentasi tentang
program tersebut, misalnya tanggal pembuatan nama team yang membuatnya dan lain-lain data yang
diperlukan.
Sebuah komputer tidak akan di proses oleh Compiler Java. Komentar tetap menjadi bagian dari kode
program pada file.java, tetapi tidak menjadi bagian file class. Keberadaan komentar akan membantu
pemahaman program yang dibuat dengan lebih baik. Untuk membedakan antara komentar dengan kode
biasa, penulisan komentar di dalam buku ini dibuat agak redup dengan menggunakan warna yang berbeda
dibandingkan dengan kode biasa.
1. menggunakan pasangan karakter double slash”//”. Pasangan karakter ini menyatakan bahwa seluruh
karakter dalam satu baris yang terletak di belakangnya akan di anggap sebagai komentar.
2. menggunakan pasangan karakter”/* dan “*/”. Seluruh tulisan yang diapit oleh pasangan karakter ini
akan di anggap sebagai komentar. Seluruh karakter yang berada setelah pasangan karakter “/*” akan
di anggap sebagai komentar selama belum ditemukan karakter”*/”.
Latihan Program 2.24
1 class Komentar
2 {
3 public static void main (String[] args)
4 {
5 // system.out.println("string ini tidak " + 6 "akan tampilkan");
6 /*
7 system.out.println("string ini juga");
8 system.out.println("tidak akan "+ "ditampilkan");
9 */
BAB III
SRTUKTUR PERCABANGAN
Tujuan materi
Setelah menyelesaikan bagian ini anda diharapkan:
1.1 pengantar
ada kalanya sebuah proses menemui kondisi bercabang dimana harus diambil sebuah pilihan dari sejumlah
alternative yang disediakan. Instruksi "if" digunakan untuk melakukan pemilihan alternative . instruksi "if"
bisa dibuat secara tunggal, bertingkat atau majemuk, tergantung situasi yang harus diselesaikan. Pada
bagian ini akan berbicara tentang mengendalikan alur program menggunakan konsep struktur control
percabangan, meliputi:
1. Bentuk "if"
2. bentuk "if" majemuk
3. bentuk "if" bertingkat
4. penggunaan instruksi switch dan break
5. penggunaan operator “?”
Blok instruksi yang terletak setelah "if" akan dikerjakan jika hasil logika dari pernyataan_relasi di
belakangnya bernilai true. Hasil logika ini bisa dibentukdr satu pernyataan_relasi atau lebih. Jika kita
menggunakan lebih dari satu pernyataan_relasi, kita harus menggunakan operator logika AND (&&) atau
OR(II) untuk menghubungkan antar pernyataan_relasi tersebut. Operator logika NOT(!)digunakan untuk
membalik hasil logika sebuah pernyataan_relasi. Setiap pernyataan_relasi ditulis di dalam pasangan
karakter kurung buka”(“dan kurung tutup”)”. Perlu diperhstikan bahwa tulisan yang ada di dalam pasangan
karakter “[“dan”]” merupakan pernyataan yang bersifat optional, artinya bisa ada dan juga bisa tidak ada.
Penggunaan flowchart bisa mempermudah pemahaman tentang alut percabangan. Kita lihat flowchart
berikut ini yang menggambarkan bagaimana alur program berpindah ke dalam blok "if" jika hasil logika
dari pernyataan_relasi "if" ini, true atau false, alur proses akan masuk ke blok “instruksi selanjutnya”.
0100090000037800000002001c00000000000400000003010800050000000b0200000000050000000c023a
04f204040000002e0118001c000000fb021000070000000000bc02000000000102022253797374656d0004f
20400007cc8110072edc63048661b000c020000f2040000040000002d01000004000000020101001c000000
fb02c4ff0000000000009001000000000440001254696d6573204e657720526f6d616e000000000000000000
0000000000000000040000002d010100050000000902000000020d000000320a3600000001000400000000
00f004380420b71b00040000002d010000030000000000
Kita lihat sebuah contoh program yang mengilustrasikan penggunaan "if" untuk proses percabangan. Kita
diminta memasukkan sebuah bilangan, kemudian komputer akan memeriksa apakah bilangan tersebut
sebelas atau bukan. Jika bilangan tersebut sebelas, komputer akan menampilkan sebuah pesan yang
menyatakan bahwa proses sudah selesai.
Latihan pogram 3.1
1 import java.io.*;
2 class iftunggal_1
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 System.out.print("ketik sebuah bilangan :");
10 String input = dis.readLine();
11 int angka = Integer.parseInt (input);
12 if (angka ==11)
13 {
14 System.out.print("\nAnda mengiputkan " + "angka 11");
15 }
16 }
17 catch (Exception e)
18 {
19 System.out.println("\nTerjadi eror");
20 }
21 System.out.println("\n**Proses selesai**");
22 }
23 }
Compile lalu jalankanprg ini. Pada saat komputer meminta kita untuk memasukkan bilangan, ketikkan
sebuah bilangan.
Jika kita memasukkan angka selain11 komputer tidak melakukan kegiatan apapun.
Sebuah instruksi "if" hanya bisa mengerjakan satu instruksi saja. Beberapa instruksi yang akan dikerjakan
ditulis di dalam tanda blok.
Pesan ***proses selesai*** akan ditampilkan berapapun bilangan yang diinputkan oleh user. Jika instruksi
yang mengikuti blok "if" hanya terdiri dari satu baris, tanda awal dan akhir blok boleh dihilangkan,
sedangkan jika instruksi yang mengikuti blok "if" lebih dari satu tetap harus ditulis di dalam tanda blok..
penulisan sepini dapat di modifikasi menjadi …. Karena blok instruksi yang dikerjakan setelah "if" hanya
satu instruksi. Alur dari program ini dapat kita gambarkan dalam bentuk flowchart berikut ini.
Keadaan “ya”dan”tidak” adalah dua keadaan yang berlawanan. Proses akan berjalan hanya di salah satu
dari kedua kondisi tersebut, tidak mungkin kedua-duanya akan berjalan bersamaan.
Contoh program berikut ini akan menampilkan predikat yang diperoleh seorang mahasiswa sesuia dengan
score nilai ujian mahasiswa tersebut. Mula-mula kita buat dulu criteria penilaian:
2 class iftunggal_2
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 System.out.print("Inputkan nilai ujian :");
12 System.out.print("\nPredikat :");
Sekarang kita compile lalu kita jalankan program ini. Kita coba memberikan sebuah bilangan, misalnya
59.
Mula-mula komputer akan memeriksa apakah bilangan ini masuk range 0 s/d 45 atau tidak . kenyataannya
59 tidak masuk ke dalam range ini, maka hasil logika adalah false. Alur program pindah ke pemeriksaan
berikutnya:apakah bilangan ini masuk dalam range 46 s/55?. Sekali lagi hasil logika yang diperoleh adalah
false. Alur berpindah pada pemeriksaan ketiga: apakah bilangan ini masuk dalam ranfe 56 s/d 65?. Disini
program mendapat hasil true, lalu menampilkan tulisan “ Cukup”.
Anda bisa mencoba dengan memberikan berbagai bilangan yang berbeda termasuk bilangan dengan angka
decimal.
Solusi yang bisa ditempuh adalah memberikan susunan "if" secara majemuk adalah susunan perintah "if"
sedemikian rupa sehingga jika hasil logika true sudah diperoleh, maka perintah "if" sejenis berikutnya tidak
dikerjakan. Dengan kata lain proses akan secepatnya keluar dari blok "if" jika sudah ditemui hasil true. Ini
tentu saja mempercepat waktu proses. Bentuk umum dari seleksi majemuk adalah:
If ([!])pernyataan_relasi [&&/||[!]pernyataan_relasi..]])
{
…intruksi jika hasil logika bernilai true..}
else
{
..intruksi jika hasil logika bernilai false..
}
Kata kunci “else” digunakan sebagai penghubung antar instruksi "if" yang akan diseleksi dalam satu
tingkat.
Kita coba data sebuah program singkat yang mengilustrasikan pemakaian "if" secara majemuk. Program ini
akan menampilkan string “Selamat pagi” atau “Selamat sore” tergantung nilai waktu yang diinputkan.
Latihan program 3.3
1 import java.io.DataInputStream;
2 class ifmajemuk_1
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 System.out.print("Jam berapa sekarang ?");
12 if (jam < 10 )
13 System.out.println("Selamat pagi");
14 else
15 System.out.println("Selamat sore");
16 }
17 catch (Exception e)
18 {
19 System.out.println("\nTerjadi eror");
20 }
21 }
22 }
Pada saat kita memberikan data waktu kurang dari 10 komputer akan menampilkan pesan “Selamat pagi’.
Alur program segera keluar dari blok "if" karena sudah ditemukan kondisi true. Komputer tidak akan
memeriksa kondisi kedua karena sudah pasti salah.
Sekarang kita akan memodifikasi program predikat nilai dengan menggunakan susunan "if" majemuk.
Latihan program 3.4
1 import java.io.DataInputStream;
2 class ifmajemuk_2
3 {
4 public static void main (String[] args)
5 {
6 DataInputStream dis = new DataInputStream(System.in);
7 try
8 {
9 System.out.print("Inputkan nilai ujian :");
12 System.out.print("\nPredikat :");
15 else
16 if ((nilai >= 45) && (nilai <= 55))
17 System.out.println("Kurang");
18 else
19 if ((nilai >= 55) && (nilai <= 65))
20 System.out.println("Cukup");
21 else
22 if ((nilai >= 65) && (nilai <= 80))
23 System.out.println("Baik");
24 else
25 if ((nilai >= 80) && (nilai <= 100))
26 System.out.println("Istimewa");
27 else
28 if ((nilai <= 0) || (nilai > 100))
29 System.out.println("data tidak Valid");
30 }
31 catch (Exception e)
32 {
33 System.out.println("\nTerjadi eror");
34 }
35 }
36 }
Secara mudah bisa kita katakan bahwa kita hanya perlu menambahkan kata kunci “else” pada setiap akhir
blok "if" kecuali pada blok "if" terakhir.
Flowchart yang dibuat juga mengalami perubahan.
0100090000037800000002001c00000000000400000003010800050000000b0200000000050000000c023a
04f204040000002e0118001c000000fb021000070000000000bc02000000000102022253797374656d0004f
20400007cc8110072edc63048661b000c020000f2040000040000002d01000004000000020101001c000000
fb02c4ff0000000000009001000000000440001254696d6573204e657720526f6d616e000000000000000000
0000000000000000040000002d010100050000000902000000020d000000320a3600000001000400000000
00f004380420b71b00040000002d010000030000000000
Jika kita berbicara tentang optimasi-kode-program, instruksi "if" pada baris if ((nilai <= 0) ||
(nilai > 100)) seharusnya tidak ada. Kita sudah memeriksa seluruh nilai yang berada pada range
0s/d100, maka nilai sisanya tentu nilai yang berada diluar range tersebut. Dengan demikian kita dapat
menghilangkan kode pada baris tersebut sehingga menjadi:
if ((nilai >= 80) && (nilai <= 100))
System.out.println("Istimewa");
else
System.out.println("data tidak Valid");
}
catch (Exception e)
Program berikut ini mengilustrasikanpenggunaan "if" bertingkat. Kita diminta memasukkan sebuah
bilangan, kemudian komputer akan memeriksa apakah bilangan tersebut termasuk bilangan negative atau
positif. Tidak hanya itu, komputer juga akan menentukan apakah bilangan itu termasuk bilangan genap atau
bilangan ganjil(gasal). Kedua kelompok bilangan genap dan ganjil memiliki peluang sama besarnya untuk
masuk ke dalam kelompok bilangan positif atau negative.
Latihan program 3.5
1 import javax.swing.JOptionPane;
2 class cekbilangan1
3 {
4 public static void main (String[] args)
5 {
6 String input="";
7 String kesimpulan = "";
8 int bilangan = 0;
11 if (bilangan<0)
12 {
13 if (bilangan % 2 == 0)
14 kesimpulan="bilangan negatif" + "dan genap";
15 else
16 kesimpulan = "bilangan negatif" + "dan gasal";
17 }
18 else
19 {
20 if (bilangan % 2 == 0)
21 kesimpulan="bilangan positif" + "dan genap";
22 else
23 kesimpulan = "bilangan positif" + "dan gasal";
24 }
25 JOptionPane.showMessageDialog(null,kesimpulan);
26 System.exit(0);
27 }
28 }
Untuk memeriksa apakah sebuah bilangan merupakan bilangan genap atau gasal bisa diketahui dari sisa
pembagian bilangan tersebut dengan dua. Jika sisa baginya nol maka bilangan tersebut adalah genap,
sebaliknya jika sisa baginya tidak sama dengan nol maka bilangan tersebut adalah gasal. Instruksi pada
baris if (bilangan % 2 ==0) dan if (bilangan % 2 ==0) menunjukkan penggunaan
operator “%” untuk mencari sisa pembagian dari suatu ekspresi matematis.
Kita compile lalu jalankan program ini. Mula-mula komputer akan menanyakan sebuah bilangan yang akan
diperiksa. Kita beri sembarang nilai, misalnya 1251.
Jika anda masih bingung dengan alur program yang terjadi, berikut ini kita modifikasi program tersebut
agar jelas terlihat alurnya.
Latihan program 3.6
1 import javax.swing.JOptionPane;
2 class cekbilangan2
3 {
4 public static void main (String[] args)
5 {
6 String input="";
7 String kesimpulan = "";
8 int bilangan = 0;
9 input = JOptionPane.showInputDialog("inputkan bilangan :");
10 bilangan = Integer.parseInt (input);
11 kesimpulan = "Bilangan " + bilangan + "adalah :\n";
12 if (bilangan<0)
13 {
14 kesimpulan +="1. bilangan negatif ...\n";
15 if (bilangan % 2 ==0)
16 kesimpulan +="2. Bilangan genap";
17 else
18 kesimpulan = "2. bilangan gasal";
19 }
20 else
21 {
22 kesimpulan +="1. bilangan positif ...\n";
23 if (bilangan % 2 ==0)
24 kesimpulan +="2. Bilangan genap";
25 else
26 kesimpulan = "2. bilangan gasal";
27 }
28 JOptionPane.showMessageDialog(null,kesimpulan);
29 System.exit(0);
30 }
31 }
jadi kepastian tentang positif/negatif bilangan akan diperiksa terlebih dahulu setelah itu baru diperiksa
tentang genap/gasalnya bilangan tersebut.
pemakaian "if" majemuk yang terlalu banyak kadang-kadang mempersulit pembacaan program. Sebagai
contoh kita buat sebuah program untuk menampilkan nama hari sesuai dengan nomor urut hari. Kita
menggunakan nilai 0 untuk menyatakan hari Minggu, nilai 1 untuk hari Senin dan seterusnya sampai nilai 6
untuk hari sabtu. Pemasukan nilai selain ini merupakan data yang tidak valid.
Mula-mula komputer akan menanyakannm urut hari yang kita inginkan. Masukan salah satu angka dari 0
sampai 6.
Berdasarkan nomer ini computer akan menampilkan string yang bersesuain contoh berikan data 5, maka
computer akan menampilkan 5-hari Jum’at jika diberikan diluar angka tang telah ditetapkan computer akan
menampilkan pesan kesalahan “data tidak valid”.
Kita akan memodifikasi program sebelumnya menggunakan instruksi switch
Latihan program 3.8
1 import javax.swing.JOptionPane;
2 class namahari2
3 {
4 public static void main (String[] args)
5 {
6 int noUrut;
7 String input;
13 break;
14 case 1 : JOptionPane.showMessageDialog(null,"1-hari Senin");
15 break;
16 case 2 : JOptionPane.showMessageDialog(null,"2-hari Selasa");
17 break;
18 case 3 : JOptionPane.showMessageDialog(null,"3-hari Rabu");
19 break;
20 case 4 : JOptionPane.showMessageDialog(null,"4-hari Kamis");
21 break;
22 case 5 : JOptionPane.showMessageDialog(null,"5-hari Jum'at");
23 break;
24 case 6: JOptionPane.showMessageDialog(null,"6-hari Sabtu");
25 break;
26 default : JOptionPane.showMessageDialog(null,noUrut + ":Data
tidak valid");
27 }
28 System.exit(0);
29 }
30 }
Mangapa perlu ada instruksi break?
Pada akhir setiap case harus diberikan instruksi break, yang menyatakan bahwa jika seluruh instruksi dalam
case selesai dikerjakan, alur keluar dari blok switch ini. Blok case atau default yang terletak paling
belakang boleh tidak menggunakan break, karena otomatis alur akan keluar dari switch jika seleruh
instruksi telah selesai dikerjakan. Apa yang tenjadi jika instruksi break pada case dihilangka? Kita lihat
program berikut yang merupakan modifikasi dari program sebelumnya dengan menghilangkan break pada
salah satu case yaitu case 0.
Setelah instruksi pada case 0 selesai dikerjakan, kita tidak memberikan instruksi break. Akibatnya dapat
anda lihat pada output berikut ini jika kita memberikan data 0.
Alur program tidak langsung keluar dari blok switch, tapi meneruskan ke baris berikutnya. Hal ini
disebabkan Karena komputer tidak menemukan instruksi yang mengarahkan alur program untuk keluar dari
blok switch setelah mengerjakan suatu instruksi.
Bentuk lain dari instruksi "if" adalah penggunaan operator “?”. Operator ini digunakan jika setelah instruksi
"if" kita memberikan nilai ke sebuah variabel: katakanlah kita mengupdate isi variabel dengan sebuah nilai
tertentu jika instruksi "if" memberikan nilai true dan memberikan nilai lain jika false.
var = (pernyataan_relasi) ?
nilai_jk_true : nilai_jl_false;
Jalankan program ini, inputkan data pertama Lalu inputkan data kedua
Komputer akan memeriksa kedua inputan ini lalu menampilkan pesan String pesan ini disimpan di variabel
pesan, dimana proses penyimpanannya ditentukan oleh hasil perbandingan antara variabel angka 1 dan
angka 2.
BAB IV
SRUKTUR PERULANGAN
Tujuan Materi
Setelah menyelesaikan bagian ini anda diharapkan :
4.1 Pengantar
Selain alur bercabang, sebuah persoalan kadang-kadang harus diselesaikan dengan alur berputar atau
looping. Untuk membuat nomor urut 1 sampai 5 misalnya,kita bisa saja menulis lima baris instruksi dimana
setiap baris bertugas menampilkan sebuah nomor.
…
System.out.prinln(1);
System.out.prinln(2);
System.out.prinln(3);
System.out.prinln(4);
System.out.prinln(5);
…
Kita menulis lima baris instruksi yang akan menampilkan setiap nomor urut. Cara seperti ini tentu tidak
efisien untuk kasus dimana kita ingin menuliskan nomor urut yang lebih banyak lagi,100 misalnya. Untuk
itulah kita perlu cara lain agar kode program yang kita buat menjadi efisien tanpa kehilangan tujuan
membuat program.
Secara umum ada dua jenis perulangan yang bisa kita buat:
1. Perulangan dengan jumlah batas yang diketahui.
2. perulangan dengan jumlah batas yang tidak diketahui.
Pada kebanyakan bahasa pemrograman, instruksi”for”digunakan untuk proses berulang dengan jumlah
perulangan yang sudah diketahui misalnya suatu proses akan di ulang-ulang sebanyak 5 kali.
Instruksi”while”dan “do-while” digunakan untuk proses berulang dimana jumlah perulangannya tidak
diketahui secara pasti, misalnya suatu proses akan diulang-ulang selama data yang diberikan oleh user lebih
besar dari 0.
Java tidak membedakan kedua jenis perulangan ini. Baik instruksi “for” maupun “while / do-while “ dapat
digunakan untuk kedua jenis perulangan tersebut. Terserah kita lebih suka menggunakan yang mana tidak
jadi soal. Melalui beberapa contoh program pada bagian ini anda akan lebih memahami kemampuan ini.
Pada bagian ini kita akan berbicara tentang bagaimana mengendalikan alur program menggunakan konsep
struktur control percabangan meliputi:
1. perulangan “for”
2. perulangan “while”
3. perulangan “do-while”
instruksi”for” dikenal sebagai instruksi untuk mengendalikan proses berulang dengan jumlah yang sudah
ditentukan sebelumnya.
Atau bisa dikatakan bahwa kita sudah tahu berapa kali suatu instruksi atau sebuah blok instruksi harus
diulangi.
Bantuk umum dari perulangan”for”adalah:
For (inisialisasi_counter);(syarat_perulangan);(update_counter){
…instruksi yang akan diulang…
}
• inisialisasi_counter : pada bagian ini kita menentukan variabel apa yang akan kita jadikan sebagai
variabel pengendali dalam proses perulangan . variabel ini akan berisi nilai yang akan terus
berubah setiap kali perulangan terjadi.
• Syarat perulangan : di sini kita menentukan syarat agar proses perulangan dilakukan. Kita bisa
menuliskan syarat ini berdasarkan nilai dari variabel counter,atau berdasarkannilai dari variabel
lainyg kita tulis dalam pernyataan relasi.
• Update_counter : bagian ini merupakan statement untuk mengubah nilai variabel
counter.Perubahan ini mungkin bersifat ascending (menaik), mungkin juga bersifat descending
(menurun).
Ketiga parameter ini bersifat optional. Pada bagian selanjutnya kita akan melihat bagaimana satu atau
seluruh parameter ini kita abaikan dan instruksi “for” tetap dapat bekerja dengan baik.
Didepan kita sudah mengilustrasikan bagaimana untuk menampilkan nomor utut mulai dari satu sampai
lima kita menulis lima baris program dimana masing-masing baris menuliskan sebuah nomor. Sekarang
kita akan membuat program Java yang berisi instruksi “for” untuk menangani proses perulangan tersebut.
Latihan program 4.1
1 class nomorurut
2 {
3 public static void main(String[] args)
4 {
5 int batas =5;
6 int cacah;
7 for (cacah=1; cacah<=batas; cacah++)
8 {
9 System.out.println(cacah);
10 }
11 }
12 }
Kita mendeklarasikan dua variabel batas dan cacah. Variabel batas kita gunakan sebagai batas bagi proses
perulangan,dengan kata lain nomor urut maksimum yang ingin kita tampilkan. Variabel cacah kita gunakan
sebagai counter yang akan mengendalikan proses perulangan.
Sekarang kita perhatikan baris 7. mula-mula kita menginisialisasi variabel cacah dengan memberikan nilai
1. proses inisialisasi ini kita tuliskan sebagai parameter pertama dari “for”. Kemudian selama nilai variabel
cacah kurang dari atau sama dengan 5 komputer akan menampilkan isi variabel ini. Syarat perulangan ini
kita tulis sebagai parameter kedua dari “for”. Terakhir,setiap kali instruksi yang diulang selesai dikerjakan,
nilai variabel cacah akan diupdate dengan cara ditambahkan 1. Jadi variabel cacah akan menyimpan nilai
berturut-turut 1,2,3,4 dan5.
1
2
3
4
5
untuk mempermudah pemahaman , kita bisa membuat flowchart dari program ini, seperti terlihat berikut
ini:
kita coba contoh lain. Program berikut ini akan melakukan proses perkalian untuk bilangan bulat. Notasi
matematis 3x4 bisa ditulis sebagai 4+4+4, ada angka 4 sebanyak 3 buah. Walaupun hasil akhirnya sama
dengan 4x3, namun pengertiannya berbeda. Notasi 4x3 bisa ditulis sebagai 3+3+3+3, ada angka 3 sebanyak
4 buah. Untuk sembarang AxB bisa kita tulis sebagai B+B+B+…+B sebanyak A kali.
3 x 5 = 15
Perhatikan baris 9. kita melakukan inisialisasi variabel cacah bersamaan dengan deklarasi variabel tersebut.
Di dalam Java hal ini diperbolehkan , jadi kita bisa menghemat waktu penulisan kode. Yang perlu menjadi
perhatian adalah variabel cacah yang dideklarasikan dengan cara ini akan menjadi bersifat local,artinya
hanya dikenal di dalam lingkup “for” saja. Jika anda mencoba menampilkan isi variabel cacah di luar blok
“for” ini komputer akan memberikan pesan kesalahan . hal ini berbeda dengan deklarasi variabel cacah
yang kita lakukan sebelumnya.
Tanda blok diperlukan jika kita ingin mengulang-ulang beberapa instruksi.
Sebuah instruksi “for” bisa jadi memiliki instruksi “for” yang lain di dalam. Hal ini dikenal dengan istilah
nested-for. Misalnya kita ingin membuat program untuk menampilkan nomor urut beserta sub-nomornya.
2 {
3 public static void main(String[] args)
4 {
5 for (int nomor=1; nomor<=5; nomor++)
6 for (int subnomor=1; subnomor<=3; subnomor++)
7 System.out.println(nomor+"."+subnomor);
8 }
9 }
Program ini akan menampilkan 5 nomor urut utama dan 3 sub nomor urut.
Instruksi “for” yang pertama harus bertanggung jawab mengulang-ulang instruksi “for” yang kedua, tidak
peduli berapa jumlah instruksi yang ditangani oleh “for” kedua tersebut. Itu sebabnya mengapa kita
menghilangkan tanda blok pada “for” walaupun sekilas tampak bahwa instruksi setelah “for” pertama ini
lebih dari satu. Hal yang sama juga berlaku untuk tingkatan “for” selanjutnya sampai tak terbatas.
Flowchart dari program ini tampak sebagai berikut:
0100090000037800000002001c00000000000400000003010800050000000b0200000000050000000c023a
04f204040000002e0118001c000000fb021000070000000000bc02000000000102022253797374656d0004f
20400007cc8110072edc63048661b000c020000f2040000040000002d01000004000000020101001c000000
fb02c4ff0000000000009001000000000440001254696d6573204e657720526f6d616e000000000000000000
0000000000000000040000002d010100050000000902000000020d000000320a3600000001000400000000
00f004380420b71b00040000002d010000030000000000
Alur pada nested-for tidak boleh bersilangan
Instruksi for terdalam akan dikerjakan terlebih dahulu sampai selesai, baru kemudian counter pada "for" di
luarnya akan diupdate. Instruksi "for" sebelah dalam akan dikerjakan sebanyak jumlah batas dari counter
"for" sebelah luarnya.
Pengandali pada "for" bisa juga dibentuk oleh beberapa pernyataan relasi. Antar pernyataan relasi ini
dihubungkan dengan operator logika AND (&&) atau OR (11). Contoh program berikut ini
menunjukkanbagaimana sebuah instruksi "for" dikendalikan oleh dua pernyataan relasi yang dihubungkan
dengan operator &&.
Latihan program 4.4
1 class forlogika
2 {
3 public static void main(String[] args)
4 {
5 int angka1 =1;
6 int angka2 = 11;
Di dalam blok "for" itu sendiri kita menyisipkan instruksi untuk mengupdate nilai variabel angka1 dan
angka2.
Setiap kali proses iterasi selesai dilakukan, kondisi ( baris 8) untuk memastikan apakah perulangan masih
perlu dilakukan lagi atau tidak. Karena kita menggunakan operator logika AND maka kedua syarat ini
harus bernilai true untuk memperolah hasil akhir true. Jika salah satu atau kedua syarat ini bernilai false
maka hasil akhirnya adalah false.
Java mengijinkan kita menggunakan instruksi "for" dengan jumlah parameter tidak lengkap , bahkan tanpa
parameter sama sekali. Kita mungkintdk ingin memberi nilai awal bagi variabel counter dengan
pertimbangan bahwa pada saat mendeklarasikan variabel kita sudah lanhsung memberi nilai awal. Jadi kita
ingin mengosongkan parameter pertama dari "for".
Program yang telah kita buat di atas akan kita modifikasi dengan menghilangkan parameter pertama pada
"for" . Inisialisasi variabel cacah kita lakukan pada saat kita mendeklarasikan variabel ini.
Latihan program 4.5
1 class modifikasiparameterfor1
2 {
3 public static void main(String[] args)
4 {
5 int angka1 =1;
6 int angka2 = 11;
7 int cacah = 1;
Sekali lagi kita akan memodifikasi program sebelumnya dengan mengosongkan parameter kedua.
Perhatikan bagaimana kita menyisipkan instruksi untuk keluar dari blok "for" pada saat yang tepat.
Latihan program 4.6
1 class modifikasiparameterfor2
2 {
3 public static void main(String[] args)
4 {
5 int angka1 =1;
6 int angka2 = 11;
14 }
15 }
16 }
Instruksi break digunakan untuk keluar dari blok "for" jika kedua syarat terpenuhi. Tentu anda masih ingat
penggunaan instruksi break pada saat kita berbicara tentang struktur control percabangan menggunakan
instruksi switch.
Pada baris 13 kita memeriksa apakah kondisi untuk keluar dari blok "for" sudah terpenuhi atau belum. Jika
kedua kondisi ini sudah terpenuhi, alur program segera keluar dari blok "for". Perlu ditekankan disini
bahwa kitalah yang berperan di dalam mengatur selesainya proses perulangan. Jika kita lupa misalnya
untuk menyisipkan instruksi ini, maka proses akan terus berputar-putar tanpa henti.
Modifikasi terakhir adalah mengosongkan parameter ketiga, yaitu update variabel counter. Sama seperti
modifikasi kedua, disini kita harus menyisipkan di dalam blok "for" instruksi untuk meng update nilai
variabel counter.
Latihan program 4.7
1 class modifikasiparameterfor3
2 {
3 public static void main(String[] args)
4 {
5 int angka1 =1;
6 int angka2 = 11;
Kita memodifikasi parameter "for" ini sesuka kita, kita bisa saja mengosongkan parameter pertama dan
kedua, atau mengosongkan parameter kedua dan ketiga. Yang harus kita ingat adalah jangan sampai alur
program menjadi tidak terkendali. Instruksi "for" memang didesain untuk perulangan yang mudah
dikendalikan.
Instruksi "for" dapat digunakan untuk proses yang tidak pernah berhenti. Dalam hal ini kita mengosongkan
seluruh parameternya. Penulisan berikut ini merupakan bentuk dimana kita ingin mengulang-ulang suatu
instruksi tanpa henti sampai program di-reset secara manual.
Latihan program 4.8
1 class modifikasiparameterfor4
2 {
3 public static void main(String[] args)
4 {
i.int angka1 =1;
5 int angka2 = 11;
6 int cacah = 1;
7 for (; ;)
8 {
9 System.out.println("angka1 =" + angka1 +"\tangka2 = "+angka2+"\tcacah="+cacah);
10 angka1++;
11 angka2--;
12 cacah +=3;
13 }
14 }
15 }
Kita menampilkan isi tiga variabel angka1,angka2 dan cacah secara terus menerus tanpa ada kondisi yang
mengatur kapan proses ini selesai. Sebuah cuplikan output dari program tersebut tampak pada gambar di
bawah ini.
Selainada instruksi break untuk keluar dari blok "for", Java menyediakan instruksi lain, continue , yang
digunakan untuk melanjutkan "for" dengan nilai counter berikutnya . komputer akan mengabaikan
instruksi –instruksi yang berada setelah continue. Proses akan dilanjutkan dengan mengosongkanupdate
nilai counter, baik ascending maupun descending. Instruksi continue biasanya digunakan bersamaan
dengan “if” dan proses berulang (looping).
Program berikut ini akan mengilustrasikan bagaimana instruksi continue bekerja di dalam sebuah blok
"for".
Latihan program 4.9
1 import javax.swing.JOptionPane;
2 class continue1
3 {
4 public static void main(String[] args)
5 {
6 String string="";
7 for (int cacah=0; cacah<+10; cacah++)
8 {
9 if (cacah % 2 ==0)
10 continue;
11 string+=cacah+"";
12 }
13 JOptionPane.showMessageDialog(null, string);
14 System.exit(0);
15 }
16 }
Pada saat variabel cacah merupakan bilangan genap, alur akan kembali ke awal "for" dengan
mengosongkanupdate nilai cacah. Jika variabel cacah menyimpan bilangan gasal maka akan digabungkan
ke variabel string untuk ditampilakan. Output program dapat dilihat berikut ini:
Jika ada nested-for maka instruksi continue akan bekerja terhadap blok "for" dimana dia diletakkan.
Perhatikan contoh program berikut ini
Latihan program 4.10
1 import javax.swing.JOptionPane;
2 class continue2
3 {
4 public static void main(String[] args)
5 {
6 String string="";
10 if (cacah2 % 2 ==0)
11 continue;
12 string += "cacah1=" + cacah1 + "cacah2" + cacah2 + "\n";
13 }
14 }
15 JOptionPane.showMessageDialog (null, string);
16 System.exit(0);
17 }
18 }
Pada saat variabel cacah 2 merupakan bilangan genap, alur akan melanjutkan "for" untuk cacah 2 dengan
mengosongkanupdate nilai cacah 2. jadi yang akan di-concat ke variabel string adalah seluruh nilai cacah 1
baik genap maupun gasal, ditambah dengan nilai cacah 2 yang gasal saja.
Java juga menyediakan sarana dimana kita bisa memerintahkan agar instruksi continue bekerja untuk
sebuah "for" yang bukan menjadi tempatnya. Contoh program diatas misalnya, kita ingin agar jika variabel
cacah 2 bernilai genap alur akan melanjutkan "for" yang pertama, maka kita bisa memodifikasi program
tersebut menjadi seperti berikut ini:
Latihan program 4.11
1 import javax.swing.JOptionPane;
2 class continue3
3 {
4 public static void main(String[] args)
5 {
6 String string="";
7 forluar:
8 for (int cacah1=0; cacah1<=5; cacah1++)
9 {
10 for (int cacah2=0; cacah2<=10; cacah2++)
11 if (cacah2 % 2 ==0)
12 continue forluar;
13 string += "cacah1=" + cacah1 + "cacah2=" + cacah2 + "\n";
14 }
15 }
16 JOptinPane.showMessageDialog(null, string);
17 System.exit(0);
18 }
19 }
Pada baris 7 kita akan memberi nama lokasi tersebut dengan label for luar. Nama label terserah anda, tetapi
sebaiknya mengandung makna. Kemudian pada baris 12 alur program kita alihkan ke label tersebut jika
variabel cacah 2 bernilai genap.
proses berulang juga bisa menggunakan instruksi “while”. Berbeda dengan "for" yang bisa melakukan
auto-update bagi variabel counternya, “while” tidak demikian. Kita harus menyisipkan instruksi untuk
mengosongkanupdate nilai variabel counter ini.
2 {
3 public static void main(String[] args)
4 {
5 int batas = 5;
6 int cacah = 1;
7 while (cacah<=batas)
8 {
9 System.out.println (cacah);
10 cacah++;
11 }
12 }
13 }
Program ini juga bisa kita modifikasi untuk memperoleh jumlah baris yang sedikit. Update variabel cacah
pada baris 12 dapat kita letakkan langsung di baris 10 pada saat ditampilkan.
Latihan program 4.13
1 class nomorurut_while2
2 {
3 public static void main(String[] args)
4 {
5 int batas = 5;
6 int cacah = 1;
7 while (cacah<=batas)
8 {
9 System.out.println (++cacah);
10 }
11 }
12 }
Yang perlu anda perhatikan adalah berhati-hati di dalam menggunakan auto-increment maupun auto-
decrement, karena hal ini bisa menyebabkan alur program kacau dikarenakan nilai counter yang salah.
Ingat bahwa jika kita menggunakan pre-increment maka isi variabel cacah akan ditambah dulu dengan 1 ,
baru kemudian ditampilkan ke layer, sedangkan jika kita menggunakan post-increment maka isi variabel
cacah akan ditampilkan lebih dulu, baru kemudian ditambahkan dengan 1.
Anda bisa memodifikasi seluruh contoh program yang menggunakan bentuk perulangan "for" menjadi
bentuk perulangan “while”.
Terakhir, kita buat sebuah program yang tidak akan memberikan output apapun. Program ini akan kita
bandingkan dengan bentuk perulangan “do-while” yang akan kita bicarakan pada bagian selanjutnya dari
bab ini.
Latihan program 4.14
1 class cetakangka
2 {
3 public static void main(String[] args)
4 {
5 int batas = 5;
6 int cacah = 6;
7 while (cacah<batas)
8 {
9 System.out.println (cacah++);
10 }
11 }
12 }
Mula-mula variabel cacah diinisialisasi dengan nilai 6, kemudian selama nilai variabel cacah masih kurang
dari variabel batas komputer akan menampilkan isi variabel cacah ini. Apa yang terjadi jika program ini
dijalankan?
bentuk terakhir dari proses berulang adalah "do-while". Berbeda dengan “while”, bentuk ini melakukan
pengecekan kondisi pada akhir blok instruksi yang diulang. Dengan demikian blok instruksi setelah "do-
while" akan dikerjakan sekurang-kurangnya satu kali. Bentuk umum dari "do-while" adalah:
do
{
… intruksi yang akan diulang …
}
while (syarat_perulangan);
Sebuah program untuk menampilkan nomor urut seperti contoh sebelumnya akan kita modifikasi
menggunakan "do-while" dengan hasil yang sama dengan program sebelumnya.
Latihan program 4.15
1 class nomorurut2
2 {
3 public static void main(String[] args)
4 {
5 int batas = 5;
6 int cacah = 1;
7 do
8 {
9 System.out.println (cacah);
10 cacah++;
11 }
12 while (cacah<=batas);
13 }
14 }
Atau kalau anda ingin mengoptimasi kode program anda bisa menuliskan program tersebut sebagai berikut:
Latihan program 4.16
1 class nomorurut22
2 {
3 public static void main(String[] args)
4 {
5 int batas = 5;
6 int cacah = 6;
7 do
8 {
9 System.out.println (cacah++);
10 }
11 while (cacah<=batas);
12 }
13 }
Walaupun nilai variabel cacah jelas-jelas diatas variabel batas, tetapi isi variabel cacah tetap tercetak di
layar. Hal ini disebabkan karena pengecekan kondisi berada diakhir blok instruksi yang diulang.,sehingga
sekurang-kurangnya proses akan dikerjakan satu kali. Ini berbeda dengan “while” yang memeriksa kondisi
terlebih dulu baru kemudian memutuskan apakah perulangan dilakukan atau tidak.
BAB V
VARIABEL ARRAY
Tujuan Materi
Setelah menyelesaikan bagian ini anda diharapkan :
• memahami pengertian variable array dijava dan dapat menggunakannya didalam pemrograman
• mampu membuat program yang menerapkan array satu dan dua dimensi
• mampu membuat program untuk mengurutkan data
• mampu membuat program untuk mencari suatu data dari sekumpulan data yang tersedia dengan
kritera tertentu
• Mampu membuat program yang melibatkan penggunaan variabel array secara dinamis
• Mampu membuat program menggunakan konsep vector, stack dan hashtable di dalam melakukan
manajemen data
5.1 pengantar
program yang cukup kompleks membutuhkan variabel dalam jumlah besar. Kita mungkin saja
mendeklarasikan variabel-variabel tersebut satu-persatu. Andaikan sebuah program membutuhkan 5
variabel bertipe int, kita bisa saja mendeklarasikan kelima variabel tersebut dengan cara biasa
persoalan akan timbul jika kita membutuhkan variabel dalam jumlah cukup besar, 100 misalnya.
Bagaimana kita mendeklarasikan seluruh variabel tersebut: apakah dengan cara mengetik satu persatu atau
melakukan trik copy-and paste? Manapun cara yang anda tempuh, cara tersebut akan menghabiskan waktu
cukup banyak. Selain masalah waktu, kita juga akan menemui masalah sulitnya mencari nama yang benar-
benar unik. Ingat bahwa tidak boleh ada dua variabel atau dengan nama sama. Atau anda ingin
menggunakan cara seperti ini.
Pada bagian ini kita akan berbicara tentang konsep array dan contoh implementasinya. Kelebihan dari
penggunaan variable array juga akan kita bicarakan, yaitu sorting dan searching data. Ada beberapa
perbedaan antara array di Java dengan array di bahasa pemrograman yang lain, antara lain kemampuan
untuk mengetahui jumlah elemen array secara otomatis.
Untuk memudahkan pemahaman mengenai variabel array ini, kita akan menggunakan ilustrasi berupa
gambar kotak yang merepresentasikan setiap elemen variabel array. Sebuah variable array bisa kita
gambarkan berupa kotak sebagai berikut:
Elemen array elemen array elemen array elelemn array elemen array
Data 1 Data 2 Data 3 Data… Data N
Indeks 0 1 2 n-1
Indeks adalah sebuah angka yang menyatakan urutan sebuah elemen pada suatu variable array. Karena
seluruh kotak memiliki nama yang sama, maka untuk membedakannya diperlukan suatu cara yaitu dengan
memberi nomor urut. Ibarat deretan rumah pada sebuah jalan, untuk membedakan antara rumah yang satu
dengan yang lain maka setiap rumah diberi nomor unik yang berbeda antara rumah satu dengan rumah
lainnya.
Nomor indeks variable array selalu dimulai dari nol, sehingga nomor indeks bagi elemen terakhir adalah
sebesar (N-1), dimana N adalah jumlah total elemen. Kita bisa mengakses setiap elemen dalam variable
array dengan mengacu pada nomor indeksnya. Awalan nol untuk nmindeks array sering menimbulkan
kerancuan bagi kita yang terbiasa dengan awalan angka 1.
Pada bagian ini kita akan membicarakan tentang penggunaan variable array di dalam pemrograman . topic-
topik yang akan kita bahas adalah:
Tipe data bisa berupa salah satu dari berbagai tipe data seperti int long, double maupun nama class; baik
class standar Java ayau class buatan kita sendiri. Materi tentang class akan kita bicarakan pada bagian ini
selanjutnya dari seri buku ini.
Sekarang akan kita bahas secara terperinci berbagai cara mendeklarasikan variable array.
1. mendeklarasikan variable array tanpa menyebutkan berapa jumlah elemen yang diperlukan.
Int[] angka;
Variabel angka deklarasikan sebagai variable array dimana setiap elemennya akan menyimpan data bertipe
int. kita tidak menyebutkan berapa jumlah elemen dari variabel angka. Kita harus menuliskan di salah satu
baris program instruksi untuk memesan jumlah elemen ini. Sebelum terjadi pemesanan jumlah elemen, kita
tidak bisa menggunakan variable array untuk menyimpan data.
Angka = new int[5];
Instruksi ini menyatakanbah kita memesan 5 elemen untuk variabel angka. Perhatikan ilustrasi berikut ini.
-----------------------------------angka------------------------------------------
Indeks 0 1 2 3 4
Pada bagian selanjutnya dari bab ini kita akan membicarakan bagaimana mengakses setiap elemen pada
variable array.
variable array kita deklarasikan sebagai variable array dimana setiap elemennya akan menyimpan data
bertipe int. pada saat mendeklarasikan ini kita langsung memesan 5 elemen array yang kita perlukan.
Perhatikan ilustrasi berikut ini.
-----------------------------------angka------------------------------------------
Indeks 0 1 2 3 4
Baik pada cara pertama maupun cara kedua seluruh elemen array tidak kita inisialisasi dengan nilai
tertentu. Nilai untuk setiap elemen ini harus kita berikan secara manual satu persatu.
Kita tidak menyebutkan jumlah elemen secara tegas, namun kita mendefinisikan sejumlah data secara
terurut.
Variabel angka kita deklarasikan sebagai variable array dimana setiap elemennya akan menyimpan data
bertipe int. kita tidak menyebutkan berapa elemen yang kita pesan, tetapi kita langsung menentukan nilai
setiap elemen. Karena jumlah data yang kita memberi ada 5, maka komputer akan mengetahui bahwa
jumlah elemen yang kita butuhkan adalah 5. perhatikan ilustrasi berikut ini.
-----------------------------------angka------------------------------------------
5 3 23 99 2
Indeks 0 1 2 3 4
ength untuk mengetahui jumlah elemen dari sebuah variable array. Pernyataan angka length akan
menghasilkan berapa jumlah elemen dari variable array. Entah dengan cara bagaimana kita
mendeklarasikan sebuah variable array . Java tetap dapat melaporkan jumlah elelmen variable tersebut
melalui instruksi length
Latihan program 5.1
1 class jumlahelemenarray
2 {
3 public static void main(String[] args)
4 {
5 int[] angka;
6 angka=new int[5];
7 System.out.println ("jumlah elemen = "+ angka.length);
8 }
9 }
Program berikut ini akan menunjukkan bagaimana Java mengetahui jumlah elemen dari variable array
angka.
Jumlah elemen = 5
Kelebihan dari array pada bahasa Java adalah kemampuannya untuk mengetahui jumlah elemen dari suatu
variable array. Kemampuan ini sangat bermanfaat pada saat kita membuat program yang menggunakan
variable array dan kita ketahui berapa jumlah elemen variable tersebut.
Mengakses suatu variable berarti mengisi data kevariable tersebut atau mengambil data dari variable
tersebut. Mengakses variable array berarti kita mengakses elemen dari variable array tersebut. Pembahasan
berikut ini akan menggunakan deklarasi yang telah kita lakukan sebelumnya.
Untuk mengisi nilai ke variable array kita harus menyebutkan nomor indeks dari elemen yang akan kita isi
dengan suatu nilai.
Angka[0] = 83;
Kita mengisi data 83 ke variable angka pada elemen pertama ( ingat nomor elemen `dimulai dari 0 )
-----------------------------------angka------------------------------------------
83
Indeks 0 1 2 3 4
Program berikut ini digunakan untuk mengisi niali 5 elemen array secara interaktif melalui keyboard>
User diminta memasukkan 5 buah data secara berurutan.
Latihan program 5.2
1 import java.io.*;
2 class entryvariabelarray
3 {
4 public static void main(String[] args)
5 {
6 DataInputStream entry = new DataInputStream(System.in);
7 try
8 {
9 int[] angka = new int[5];
10 System.out.println ("ketikan lima buah =" + " data :");
11 System.out.println ("-----------" + "----");
12 for (int i=0; i<angka.length;i++ )
13 {
14 System.out.println ("Data ke-" +(i+1)+ ":");
15 angka[i] = Integer.parseInt(entry.readLine());
16 }
17 }
18 catch (Exception e)
19 {
20 System.out.println ("salah input data");
21 }
22 }
23 }
Instruksi pada baris 15 digunakan untuk memasukkan data untuk setiap elemen array. Variable I kita
gunakan sebagai counter yang akan menunjukkan nomor indeks elemen array yang akan diisi data.
Untuk mengambil niali dari variable array kita harus menyebutkan nomor indeks dari elemen yang akan
kita ambil isinya.
Instruksi tersebut akan menampilkan isi variable angka elemen pertama ke layer. Kita mungkin saja
mengupdate nilai suatu elemen berdasarkan nilai dari elemen lain dari variable array yang sama.
Instruksi ini akan menjumlahkan isi variable angka elemen kedua dan ketiga lalu menyimpan hasilnya ke
elemen pertama.
Program berikut ini digunakan untuk mengisi nilai acak ke seluruh elemen array lalu menampilkan seluruh
data tersebut ke layer. Kita memanfaatkan instruksi length untuk mengosongkan-counter proses looping.
Latihan program 5.3
1 class updateVariabelArray
2 {
3 public static void main(String[] args)
4 {
5 int[] angka = new int[5];
6 for (int i=0; i<angka.length; i++)
7 angka[i] = (int)(Math.random()*100);
8 for(int i=0; i<angka.length; i++);
9 System.out.println ("isi elemen ke-" + i +"==>" + angka[i]);
10 }
11 }
Instruksi pada baris ke-7 merupakan pernyataan untuk mengisi nilai variable angka. Instruksi
Math.random( ) merupakan instruksi untuk membangkitkan sebuah bilangan pecahan acak antara 0 dan 1.
Untuk memperoleh nilai acak anatara 0 dan 100 kita harus mengalikan hasil random ini dengan 100,
dengan perhitungan :
• Jika hasil fungsi random ( ) adalah 0 maka setelah dikalikan 100 akan tetap 0
• Jika hasil fungsi random( ) adalah angka 1 maka setelah dikalikan 100 manjadi 100 .
• Jika hasil fungsi random ( )antara 0 dan 1 maka setelah dikalikan 100 akan menghasilkan bilangan
yang bersesuaian dengan perkalian tersebut.
Hasil perhitungan fungsi random() yang pecahan ini harus dikonversi menjadi tipe integer agar bisa
disimpan di variabel angka yang bertipe int. untuk keperluan ini kita menggunakan metode type-casting,
yaitu memaksa hasil fungsi random() yang bertipe double agar diubah menjadi int dengan mengambil
bagian bilangan bulatnya saja. Arena nilai yang kita berikan ke setiap elemen bersifat random (acak) maka
setiap kali program ini kita jalankan hasilnya akan berbeda-beda. Contoh output program bisa anda lihat di
bawah ini.
Jika program ini dijalankan untuk yang kedua kalinya, hasil yang mungkin adalah sebagai berikut:
Cara lain dengan hasil serupa dengan program 5.2 diperlihatkan pada program berikut ini.
Latihan program 5.4
1 class dataacakvariabelArray
2 {
3 public static void main(String[] args)
4 {
5 int[] angka = { (int) (Math.random()*100),
6 (int) (Math.random()*100),
7 (int) (Math.random()*100),
8 (int) (Math.random()*100),
9 (int) (Math.random()*100) };
Keunggulan dari penggunaan variable array adalah kita dapat mencari suatu data secara mudah. Misalnya
kita memiliki sejumlah data tersimpan di variable array angka, maka kita bisa melakukan proses pencarian
terhadap satu atau lebih data di dalam deretan elemen variabel angka tersebut. Komputer juga bisa
melaporkan apakah data yang di cari ada dalam deretan elemen array atau tidak ada. Andaikan kita
mendeklarasikan variable array bernama angka yang memiliki 5 elemen, lalu setiap elemennya kita isi
dengan data secara manual. Selanjutnya kita meminta user untuk memasukkan sebuah angka yang akan di
cari oleh komputer apakh angka tersebut ada dalam deretan elemen array atau tidak ada . hasil akhirnya
adalah keputusan tentang ada atau tidaknya data tersebut dalam deretan array.
Latihan program 5.5
1 import java.io.*;
2 class cekdataarray1
3 {
4 public static void main(String[] args)
5 {
6 DataInputStream entry= new DataInputStream(System.in);
7 try
8 {
9 int[] angka= new int[5];
10 //---------------
11 // memasukan data ke array
12 //-----------------------
13 System.out.println("ketik lima " + "buah data :");
14 System.out.println("-----------"+"----------");
29 if (ada==0)
30 System.out.println("\nData yang "+"anda cari tidak ada");
31 else
32 System.out.println("\nData yang "+"anda cari Ada");
33 }
34 catch (Exception e)
35 {
36 System.out.println("salah input data");
37 }
38 }
39 }
Variabel “ada” kita persiapkan sebagai flag atau status yang menyatakan apakah data yang kita cari ada
dalam deretan array atau tidak. Pada saat program baru berjalan nilai variabel ada diset sama dengan 0,
sebagai tanda bahwa data yang kita cari tidak ada. Tentu saja asumsi ini benar karena proses pencarian
belum dilakukan. Di dalam proses iterasi dilakukan pemeriksaan apakah elemen yang sedang diperiksa
bernilai sama dengan data yang kita cari. Jika salah satu elemen bernilai sama dengan data yang di cari,
nilai pada variabel ada bertambah satu.pro iterasi akan terus dikerjakan selama memenuhi 2 kondisi yang
dihubungkan dengan operator logika AND(&&):
program 5.5 bisa kita modifikasi dengan memanfaatkan fungsi random() yang telah kita gunakan sebelum
ini. Penggunaan fungsi random () memungkinkan jumlah elemen dalam array bisa kita kembangkan
sebanyak mungkin.
Latihan program 5.6
1 import java.io.*;
2
3 class cekdataarray2
4 {
5 public static void main(String[] args)
6 {
7 DataInputStream entry = new DataInputStream(System.in);
8 try
9 {
10 int[] angka= new int[5];
11 //---------------
12 // memasukan data ke array secara random
13 //-----------------------
14 System.out.println("lima buah data" + "secara acak :");
15 System.out.println("-----------"+"----------");
19 System.out.print("data ke-"+(i+i)+":"+angka[i]);
20 }
21 //-----------------------
22 // NENCARI DATA di array
23 //-----------------------
24 System.out.print("\nketikan data "+"yang akan dicari :");
30 if (ada==0)
31 System.out.println("\nData yang "+"anda cari tidak ada");
32 else
33 System.out.println("\nData yang "+"anda cari Ada");
34 }
35 catch (Exception e)
36 {
37 System.out.println("salah input data");
38 }
39 }
40 }
Pada baris 11 kita masih memesan jumlah elemen sebanyak 5, namun sesungguhnya dengan menggunakan
fungsi random() kita dapat mengubah jumlah itu menjadi berapa saja tanpa mengubah kode program yang
lain. Seandainya jumlah elemen pada baris 11 kita ubah menjadi misalnya,
Kombinasi penggunaan instruksi length dan fungsi random sangat membantu untuk memperoleh data array
dalam jumlah banyak.
Kami sarankan anda untuk sering berlatih menggunakan instruksi length dan fungsi random() agar
memperoleh pemahaman yang lebih baik. Anda juga bisa mencoba mencari formula bagaimana
memperoleh angka acak suatu range tertentu, misalnya angka acak antara 50 sampai 100 dan sebagainya.
Dalam hal ini diperlukan suatu cara untuk melakukan pemetaan hasil random 0 sampai 1 menjadi 50
sampai 100.
Menyalin data dari suatu variable array ke variable array yang lain identik dengan mengisi data array tujuan
dengan seluruh data dari aaray sumber. Dengan demikian ukuran atau jumlah elemen dari array tujuan
harus sama dengan atau lebih dari array sumber. Kita tidak mungkin menyalin seluruh data array sumber
yang berjumlah banyak ke suatu tempat, dalam hal ini variable array lain, yang berukuran lebih kecil.
Sekurang- kurangnya harus berukuran sama.
Program berikut ini akan menunjukkan bagaimana kita bisa menyalin seluruh data dari suatu variable array
ke variable array yang lain.
Latihan program 5.7
1. class menyalinDataArray
2. {
3. public static void main(String[] args)
4. {
5. int[] sumber = new int[10];
6. int[] tujuan = new int[10];
7. for (int i=0; i<sumber.length ; i++ )
8. sumber[i] = (int) (50 + Math.random()*50);
9. for (int i=0; i<sumber.length ; i++ )
10.tujuan[i] = sumber[i];
11.System.out.println("-------------"+"---------------");
12.System.out.println("No Data sumber "+"Data tujuan");
13.System.out.println("-------------"+"---------------");
14.for (int i=0; i<sumber.length ; i++ )
15.System.out.println(i+1 + ".\t"+sumber[i]
+"\t\t"+tujuan[i]);
16.System.out.println("-------------"+"---------------");
17.}
18.}
Ada dua baris program yang perlu diperhatikan:
• baris 8 merupakan instruksi untuk memasukkan data ke variabel sumber. Setiap elemen dari
variabel ini digunakan untuk menyimpan data acak. Formula yang kita gunakan akan
menghasilkan data acak antara 50 sampai 100. silahkan anda analisa bagaimana formula ini
bekerja untuk menghasilkan angka acak dalam range 50 sampai 100. anda bisa menggunakan
formula ini untuk untuk menghasilkan angka acak dalam range yang sesuai dengan kebutuhan
anda.
• Baris 12 merupakan instruksi untuk menyalin data dari variable array sumber ke variable array
tujuan. Iterasi dilakukan sampai semua elemen variabel sumber disalin ke variabel tujuan pada
indeks yang bersesuaian.
sejumlah data akan mudah dilihat jika ditampilkan secara terurut. Pencarian nomor induk mahasiswa akan
mudah dilakukan jika data-data tersebut ditampilkan secara terurut, baik secara ascending(dari kecil ke
besar) maupun descending (dari besar ke kecil). Bisa anda bayangkan bagaimana sulitnya mencari
informasi seorang mahasiswa berdasarkan nomor induknya dari sekian ratus bahkan sekian ribu mahasiswa
pada suatu list. Tentu membutuhkan waktu yang sangat lama dan cukup melelahkan untuk mencarinya.
Tetapi jika data dalam list sudah tertata rapid an terurut, maka proses pencarian hanya membutuhkan waktu
beberapa detik saja.
Efektifitas suatu algoritma komputasi dihitung dari jumlah langkah yang diperlukan untuk menyelesaikan
masalah, bukan pada banyaknya jumlah baris kode programnya.
Salah satu terapan dari variable array adalah melakukan sorting terhadap sejumlah data. Ada berbagai
algoritma sortir data, misalnya Bubble Sort, Selection Sort dan Quick Sort. Algoritma sort data yang paling
mudah diingat adalah Selection Sort. Program berikut ini akan menampilkan 4 buah data sebelum dan
sesudah dilakukan proses sortir. Kita akan melakukan sortir data secara ascending, dimana data yang lebih
kecil akan ditampilkan lebih dulu lalu dilanjutkan dengan data yang lebih besar sampai data terakhir.
Latihan program 5.8
1 class Sortirdata
2 {
3 public static void main(String[] args)
4 {
5 int[] angka = new int[4];
6 //------------------
7 //inialisasi array
8 //---
9 for (int i=0; i<angka.length ; i++ )
10 angka[i] = (int) (Math.random()*100);
11 //------------------
12 //menampilkan array
13 //------------------
14 System.out.println("data belum disortir");
15 System.out.println("--------------------");
16 for (int i=0; i<angka.length ; i++ )
17 System.out.println(angka[i] + " ");
18 //------------------
19 //proses sortir dengan metode selection
20 //------------------
21 for (int x=0; x<angka.length-1 ; x++ )
22 for (int y=x+1; y<angka.length ; y++ )
23 if (angka[x] > angka[y])
24 {
25 int bantu = angka[x];
26 angka[x] = angka[y];
27 angka[y] = bantu;
28 }
29 //------------------
30 //menampilkan data akhir
31 //------------------
32 System.out.println("\n\nData setelah "+"sortir");
33 System.out.println("--------------------------");
Perubahan kecil ini akan menghasilkan output berupa data yang terurut secara descending, yaitu data yang
lebih besar ditampilkan mendahului data yang lebih kecil sampai akhir data.
mengubah ukuran array bisa berarti mengurangi atau menambah jumlah elemen array. Pengurangan jumlah
elemen array berakibat hilangnya sejumlah data, biasanya data terakhir. Istilah yang umum dikenal untuk
pengurangan jumlah elemen array adalah delete atau menghapus, sedangkan istilah untuk penambahan
jumlah elemen array adalah insert atau penyisipan. Tidak ada trik khusus yang kita gunakan untuk kedua
proses ini. Kita hanya “bermain-main” dengan logika memesan memori untuk array bantuan dan proses
menyalin data sumber ke variabel bantuan tersebut. Pada bagian ini kita akan membahas kedua proses ini
satu-persatu.
Secara umum, logika yang kita gunakan untuk proses menghapus elemen array adalah:
1. memesan variable array baru yang ditujukan sebagai variabel Bantu dengan jumlah elemen sama
dengan jumlah elemen variabel sumber dikurangi 1.
2. menyalin data dari variable array sumber ke variabel Bantu tersebut selama data yang akan disalin
bukan merupakan data yang akan dihapus.
3. mengatur ulang jumlah elemen array sumber dimana jumlah elemennya sama dengan jumlah
elemen variabel Bantu.
4. Menyalin seluruh elemen dari variabel Bantu ke variabel sumber.
Untuk menguji apakah ukuran array setelah proses delete dilakukan benar-benar berkurang dari ukuran
semula, kita bisa memeriksanya menggunakan instruksi length.
Proses berikut ini akan menunjukkan bagaimana kita menghapus sebuah elemen array berdasarkan data
yang ditentukan oleh user. Mula-mula komputer akan mengisi variabel angka dengan sejumlah data secara
acak lalu menampilkan seluruh data tersebut ke layar. User diberi kesempatan untuk menentukan data mana
yang akan dihapus.di bagian akhir program komputer akan menampilkan kembali isi variabel angka setelah
proses penghapusan dilakukan. Perhatikan bagaimana instruksi untuk menampilkan seluruh isi variabel
angka sebelum dan sesudah penghausan ditulis dengan cara yang sama.
Latihan program 5.9
1 import java.io.*;
2 class hapusdataarray
3 {
4 public static void main(String[] args)
5 {
6 DataInputStream entry = new DataInputStream(System.in);
7 try
8 {
9 int[] angka= new int[5];
10 //------------------
11 //inialisasi array
12 //---
32 if(ada == 0)
33 System.out.println("\n\ndata tidak ditemukan :");
34 else
35 {
36 // step 2 salin data ke variabel bantu
37 int [] bantu = new int [angka.length-1];
38 int cacah =0;
instruksi new yang berulang-ulang menyebabkan banyak memori terbuang akibat penciptaan objek baru.
Mula-mula program akan memeriksa apakah data yang akan dihapus ada dalam deretan elemen array atau
tidak. Proses penghapusan akan dilakukan jika data yang dicari ada dalam deretan elemen array. Setelah
proses penghapusan selesai dilakukan, komputer akan melakukan pemesanan ulang memori untuk variable
array angka. Akibat instruksi new, komputer akan mengalokasikan variabel tersebut di lokasi memori yang
lain. Bagaimana dengan lokasi variabel angka sebelumnya? Inilah kelebihan Java, dia mampu memilih
mana lokasi yang sudah tidak digunakan lagi lalu membebaskan lokasi tersebut agar bisa digunakan oleh
proses lain. Bahasa pemrograman lain tidak mengijinkan pengalokasian memori secara berulang terhadap
sebuah variabel,maka sampai akhir program lokasitsg tidak bisa digunakan oleh proses lain. Dengan
adanya pengalokasian ulang ini maka otomatis alokasi yang sebelumnya diberikan sudah tidak berlaku lagi.
Variabel cacah pada proses penyalinan data- baris 47 sampai 55 mrpk variabel yang mencatat pada indeks
ke berapa dari variabel Bantu penyalinan data dilakukan. Proses penghapusan elemen array akan
menyebabkan nilai cacah suatu saat akan berbeda dengan nilai variabel pengendali indeks variabel sumber
yaitu angka.
Diperlukan beberapa latihan agar bisa mahir dalam pemrograman Java . belajar pemrograman tidak
semudah belajar program aplikasi , karena di dalam pemrograman sangat dibutuhkan ketrampilan
menggunakan logika.
1. memesan variable array baru yang ditujukan sebagai variabel Bantu dengan jumlah elemen
sama dengan jumlah elemen variabel sumber ditambah 1.
2. Menyalin data pertama sampai dengan data ke (N-1), dimana N mrpk posisi penyisipan akan
dilakukan.
3. Menyimpan data yang disisipkan.
4. Menyalin data yang tersisa dari dari variabel sumber ke variabel Bantu.
5. Mengatur ulang jumlah elemen array sumber dimana jumlah elemennya sama dengan jumlah
elemen variabel Bantu.
6. Menyalin seluruh elemen dari variabel Bantu ke variabel sumber.
Untuk menguji apakah ukuran array setelah proses insert dilakukan benar-benar bertambah dari ukuran
semula, kita bisa memeriksanya menggunakan instruksi length.
Program berikut ini akan menunjukkan bagaimana kita menyisipkan sebuah data ke dalam array. Mula-
mula komputer akan mengisi variabel angka dengan sejumlah data secara acak lalu menampilkan seluruh
data tersebut ke layar. User diberi kesempatan untuk menentukan data yang akan disisipkan beserta nomor
indeks penyisipan.di bagian akhir program komputer akan menampilkan kembali isi variabel angka setelah
proses penyisipan dilakukan.
Latihan program 5.10
import java.io.*;
class hapusdataarray
{
public static void main(String[] args)
{
DataInputStream entry = new DataInputStream(System.in);
try
{
int[] angka= new int[5];
//------------------
//inialisasi array
//---
for (int i=0; i<angka.length ; i++ )
angka[i] = (int) (Math.random()*100);
//------------------
//menampilkan array
//------------------
System.out.println("--------------------");
System.out.println("data mula-mula");
System.out.println("--------------------");
for (int i=0; i<angka.length ; i++)
System.out.println(angka[i] + " ");
//------------------
//menghapus data
//------------------
System.out.println("\n\nketik data yang akan dihapus :");
// step 1: memesan variabel bantu
int cari = Integer.parseInt(entry.readLine());
int ada =0;
for (int i=0; (i<angka.length)&&(ada==0); i++ )
if (angka[i] == cari) ada++;
if(ada == 0)
System.out.println("\n\ndata tidak ditemukan :");
else
{
// step 2 salin data ke variabel bantu
int [] bantu = new int [angka.length-1];
int cacah =0;
komputer, angka lokasi ini akan dikurangi 1, tentu saja ini harus dilakukan karena penomoran indeks selalu
berawal dari
0. proses penyisipan data ditunjukkan mulai baris 43 sampai 61.
Sejauh ini variable array yang kita gunakan berjenis array satu dimensi. Istilah satu dimensi mengacu
kepada jumlah bilangan yang digunakan sebagai indeks. Perhatikan bahwa bilangan yang kita gunakan
sebagai nomor indeks array hanya satu, tidak perduli berapa jumlah digitnya. Angka 100 merupakan
sebuah bilangan, walaupun jumlah digitnya ada 3.
Pada beberapa kondisi diperlukan penulisan variable array yang menggunakan nomor indeks dua bilangan,
misalnya pada aplikasi matrik. Data pada suatu matrik diketahui berdasarkan nilai baris dan kolomnya.
Baris adalah sebuah bilangan dan kolom adalah sebuah bilangan juga. Tanpa adanya salah satu dari
keduanya kita tidak bisa mengetahui data mana yang dimaksud, jika kita ingin mengambil sebuah data
individu.
Untuk memudahkan pemahaman, bentuk array dua dimensi bisa dihambarkan dalam bentuk petak-petak
sebagai berikut :
N adalah nilai yang menyatakan jumlah baris dari array, sedangkan M menyatakan jumlah kolom dari
array. Sama seperti array satu dimensi, penomoran indeks untuk array dua dimensi juga dimulai dari 0
untuk baris maupun kolomnya. Tidak ada aturan yang mengatakan bahwa urutan untuk nomor indeks
adalah baris dulu baru kolom, tetapi buku ini menggunakan urutan baris-kolom untuk menyatakan indeks
matrik dua dimensi.
Sekarang kita buat sebuah program yang akan mengilustrasikan penggunaan array dua dimensi. Seperti
pada program-program sebelumnya, pada program ini kita menggunakan fungsi random() pada proses entry
data setiap elemen array.
Instruksi pada baris 7 merupakan pernyataan untuk menghitung jumlah baris, atau lebih tepatnya jumlah
array indeks pertama. Untuk setiap barisnya kita bisa mengetahui berapa jumlah kolomnya, atau lebih
tepatnya jumlah array indeks keduanya, dengan pernyataan seperti terlihat pada baris 8.
Salah satu aplikasi dari matrik dua dimensi adalah matrik. Sebuah matrik memiliki data berjejer dalam
baris dan kolom. Matrik A dengan baris sebanyak N dan kolom sebanyak M bisa digambarkan
Dua bagian berikut ini merupakan contoh implementasi array dua dimensi pada proses matrik, berturut-
turut penjumlahan dan perkalian matrik. Anda bisa melakukan latihan mandiri untuk proses matrik lainnya,
seperti matrik transpose maupun matrik invers.
Dua buah matrik bisa dijumlahkan jika memenuhi persyaratan kedua matrik tersebut memiliki ordo yang
sama. Ordo adalah ukuran baris dan kolom. Sebuah matrik berordo 2x3 bisa dijumlahkan dengan matrik
lain yang berordo 2x3 juga. Setiap elemen pada matrik pertama akan dijumlahkan dengan elemen yang
berssesuian dari matrik kedua. Jika diketahui ada dua matrik A dan B masing-masing berordo NxM.
Program berikut ini akan menunjukkan proses perkalian matrik. User diminta memasukkan beberapa data:
• jumlah baris matrik pertama,
• jumlah kolom matrik pertama,
• jumlah kolom matrik kedua
Jumlah baris matrik kedua otomatis bernilai sama dengan jumlah kolom matrik pertama, sehingga tidak
perlu dimasukkan lewat keyboard.
Pada program 5.10 kita telah menerapkan konsep array dinamis. Array dinamis yang dimaksud adalah
array yang ukurannya atau jumlah elemennya bisa diubah sewaktu-waktu. Hal ini berlawanan dengan
konsep array statis, dimana jumlah elemennya sudah tetap dan sudah tidak bisa diubah sejak variabel
tersebut dideklarasikan. Array statis bisa dimanipulasi untuk proses delete dengan sejumlah elemen terakhir
dinyatakan tidak digunakan lagi. Dalam hal ini seluruh elemen yang tidak dihapus akan digeser kedepan
menempati posisi elemen yang dinyatakan ‘dihapus’.
Untuk lebih memperjelas konsep array dinamis, sekarang kita akan membuat sebuah program yang berisi
proses pengubahan ukuran array secara interaktif. Proses akan terus berulang selama user memasukkan
nilai lebih besar dari 0.
Pada baris 11 kita mendeklarasikan variabel angka tanpa menyebutkan berapa jumlah elemennya. Kita
biarkan deklarasi ini mengambang. Baru pada saat proses sedang berjalan kita menentukan jumlah
elemennya.
Java menyediakan beberapa class yang memiliki prinsip serupa dengan variable array dan kita mendukung
konsep dinamisasi array secara mudah..Pd bagian ini kita akan membahas tiga class penunjang tersebut.
Vector, Stack dan Hastable. Ketiga class ini terdapat di dalam package Java.util, sehingga di awal kode
program kita harus menuliskan.
Tergantung class mana yang akan kita gunakan. Kita akan membahas ketiga class ini satu-persatu.
Class vector mengimplementasikan model array-of-object yang bersifat growable, artinya ukuran atau
jumlah elemen yang di simpan bisa bertambah atau berkurang secara dinamis. Dari keseluruhan method
dan constructor yang dimiliki class ini , kita hanya akan membahas beberapa yang dianggap penting dan
mewakili kepentingan kita terhadap proses dinamisasi array.
Sebuah objek yang merupakan instansiasi dari class Vector mendeklarasikan dengan cara:
Objek myvector mendeklarasikan berjenis Vector dengan kapasitas default 10 elemen. Sebenarnya ada 4
cara inisialisasi objek dari claas Vector. Pembahasan hanya difokuskan pada kemudahan pemahaman
materi, bukan pada banyaknya jumlah materi yang diberikan. Anda bisa membaca informasi mengenai
dokumentasi Java dengan cara mencari informasi tersebut dari web-site milik sun microsystem sebagai
produsen Java di alamat http://java.sun.com. Anda bahkan bisa mendownload Java versi terakhir.
Kembali ke topic tentang vactor, setelah mendeklarasikan, selanjutnya kita dapat menambahkan sembarang
elemen ke variabel myvector. Kita juga dapat menampilkan seluruh data yang telah disimpan ke variabel
myVector. Program berikut ini akan menunjukkan penggunaan class Vector yang digunakan untuk
menyimpan sejumlah data yang diinputkan dari keyboard.
Perhatikan baris 32. method add() membutuhkan data objek ke variabel myVector. Karena method add()
membutuhkan data berjenis objek, sementara di lain pihak data angka yang kita inputkan bukan merupakan
tipe objek, maka data tersebut kita kirimkan sebagai parameter dari class Integer.
Hasil dari instruksi ini adalah sebuah objek bertipe integer dengan data sebagaimana yang tersimpan di
variabel angka. Seluruh data yang diinputkan akan disimpan di variabel myVector kecuali angka nol,
karena kita membatasi entry data sampai user memasukkan angka nol.
Baris 45 merupakan pernyataan untuk mengarahkan variabel enumke variabel vector myVector.
Selanjutnya pada baris 47 dan 48 isi yang tersimpan di variabel enum akan ditampilkan selama variabel
enum masih memiliki elemen. Jika method add() digunakan untuk menambahkan data objek ke sebuah
variabel Vector, maka method remove() merupakan kebalikan dari method add(). Method remove()
digunakan untuk menghapus sebuah elemen dari variabel vector pada index tertentu. Seperti variable array,
class vector juga menerapkan konsep index untuk menunjuk data secara individual. Berdasarkan nomor
index ini kita bisa menghapus satu atau lebih data dari variabel vector.
Method size() seperti terlihat pada baris 47 merupakan cara untuk mengetahui brp banyak data yang saat ini
ada di variabel vectormyVector. Berdasarkan hasil method size() ini kita bisa menentukan berapa
seharusnya user memasukkan nilai untuk index. Proses penghapusan diperlihatkan pada baris 60. kita
cukup mengirimkan informasi tentang nomor indeks dari data yang akan kita hapus; selanjutnya biarkan
method remove() menghapus data tersebut.
Sekarang bagaimana jika kita ingin menyalin data suatu variabel vector ke dalam variabel vector lain;
apakah dengan cara membaca data vector sumber satu persatu lalu menyalinkan data tersebut ke vector
tujuan? Java menyediakan method clone() yang berguna untuk menyalin seluruh elemen suatu vector ke
variabel vector lainnya.
Perhatikan baris 37. method clone() tidak bisa digunakan begitu saja walaupun variabel hasil cloning
bertipe vector juga. Kita harus melakukan penylinan seluruh elemen variabel myVector ke variabel
implementasi lain dari array adalah stack. Sebenarnya stack lebih cocok disebut implementasi dari tipe data
pointer. Stack adalah metode mengorganisasi data sedemikian rupa sehingga seluruh data diletakkan
dengan susunan LIFO (Last In First Out), dimans data yang terakhir kali dimasukkan ke dalam stack akan
menjadi data yang pertama kali bisa diambil dari stack, sedangkan data yang pertama kali dimasukkan ke
dalam stack akan menjadi data yang terakhir kali bisa diambil dari stack. Konsep ini bisa dianalogikan
dengan menumpuk piring yang akan dicuci. Piring yang diletakkan paling akhir akan berada ditumpukkan
atas dan akan pertama kali dicuci, sedangkan piring yang diletakkan pertama kali akan menjadi piring
terbawah dan akan dicuci paling akhir.
Struktur data stack berbeda dengan queue. Kalau queue, data yang pertama kali masuk akan di proses
pertama kali juga. Ini identik dengan antrian diloket jalan tol. Kendaraan yang masuk antrian pertama kali
akan dilayani pertama kali , sedangkan kendaraan yang masuk belakangan juga akan dilayani belakangan.
Kembali ke stack, Java menyediakan class stack untuk bertujuan mengimplementasikan struktur data stack.
Class stack memiliki sebuah constructor yaitu stack() yang digunakan untuk mengalokasikan memori bagi
objek stack. Ada lima method yang bisa digunakan dalam pengoperasian stack:
• empty(), digunakan untuk memeriksa apakah stack dalam keadaan kosong atau tidak. Hasil fungsi
true jika stack kosong, dan false jika stack ada isinya.
• Peek(), digunakan untuk melihat data teratas pada stack tanpa mengambil data tersebut dari stack.
• Pop(), digunakan utkmengambil data teratas pada stack.setelah pemanggilan method ini, ukuran
stack akan berkurang satu. Kita tidak bisa mengambil data di dalam stack pada sembarang posisi.
Hanya data terataslah yang bisa diambil.
• Push(data), digunakan untuk memasukkan data ke stack. Setiap data yang baru masuk akan
diletakkan di awal stack.
• Search(data), digunakan untuk mencari apakah data tertentu ada di dalam stack. Jika suatu data
ada di dalam stack, hasil fungsi adalah nilai yang menyatakan lokasi data tersebut di dalam stack.
Program berikut ini akan menunjukkan bagaimana class stack dapat digunakan untuk mengimpletasikan
array dinamis. Secara iterative user diminta memasukkan data yang akan disimpan dist. Proses akan terus
dilakukan sampai user memasukkan angka nol. Angka nol ini tidak ikut dimasukkan ke dalam stack.
Proses menampilkan data dilakukan selama isi stack belum kosong. Method pop() menghasilkan data
bertipe Object, sedangkan kita tahu bahwa data yang kita masukkan ke dalam stack bertipe int, sehingga
kita harus mengkonversi tipe Object menjadi tipe int. Java tidak menyediakan fasilitas ini. Kita
menggunakan tirk lain yaitu mengubah tipe data Object menjadi String menggunakan method to String (),
lalu data string ini dikonversi menjadi data bertipe int menggunakan method parselnt().
Data yang pertama kali kita masukkan akan ditampilakn terakhir kali,. Sedangkan data yang terakhir kali
kita masukkan akan ditampilkan sebagai data pertama. Ini membuktikan bahwa stack menggunakan konsep
LIFO di dalam menyimpan data.
Masih tentang stack, program berikut ini mengimpletasikan stack dimana data yang dimasukkan ke dalam
stack dibangkitkan secara acak. User hanya diminta memasukkan jumlah elemen yang akan disimpan ke
dalam stack.
di depan kita membicarakan tentang class vector dan Stack. Data yang disimpan pada kedua class ini hanya
terdiri dari satu item, misalnya seluruhnya berupa data string dan sebagainya. Keseluruhan data ini bertipe
sama. Class hastable mengimpletasikan struktur data berderet dimana setiap data terdiri dari dua item, yaitu
keyboard dan value. Sembarang tipe data non-null dapat dijadikan sebagai keyboard atau value.
Sebuah objek yang merupakan instansiasi dari class Hastable mendeklarasikan dengan cara:
Data yang tersimpan di dalam objek hastable bisa digambarkan dalam bentuk kotak-kotak sebagai berikut:
Dari bagian ini terlihat adanya kemiripan antara hastable dan stack. Perbedaannya adalah data pada
hastable dapat diambil sembarang pada sembarang posisi. Berdasarkan nilai keyboard yang kita berikan,
komputer akan mencari nilai value yang bersesuaian.
Program berikut ini menunjukkan bagaimana data di dalam objek hastable diorganisasi seperti stack.
Seluruh data kita tampilkan dengan bantuan variabel objek berjenis Enumeration. Sekarang kita akan
menampilkan data berdasarkan nilai keyboard yang akan kita berikan. Program berikut ini akan
menunjukkan bagaimana kita bisa menampilkan data di dalam variabel myHastable secara FIFO( First In
First Out), dimana data yang pertama kali kita masukkan akan muncul pertama kali juga, begitu seterusnya
sampai dengan data terakhir.pengorganisasian data-data tersebut di dalam variabel myHastable tetap
seperti program sebelumnya.
Pencetakan isi variabel my Hastable ke layar dilakukan pada baris 37 sampai 43. variabel urutan kita
gunakan sebagai keyboard untuk memilih value mana yang akan ditampilkan.method put() seperti
diperlihatkan pada baris 27 digunakan untuk memasukkan data ke dalam hastable. Method get() digunakan
untuk mengambil data dari sebuah hastable, seperti ditunjukkan pada baris 39.
Baik pada program 5.20 maupun program 5.21 kita menggunakan data integer sebagai keyboard untuk
dipasangkan dengan sebuah value. Kita juga bisa menggunakan tipe data lain, String misalnya, untuk
menjadi keyboard dalam hastable.
Value 33 dipasangkan dengan key”satu”, value 12 dipasangkan dengan key “dua” dan value 8 dipasangkan
dengan keyboard”tiga”. Untuk menampilkan seluruh value ini kita harus mengirimkan ketiga data string ini
pada method get() sebagai nilai keyboard. Untuk menampilkan value 33 kita cukup memberikan perintah.
Kita telah membicarakan tentang class Vector dan hastable yang digunakan untuk menyimpan sebuah data,
tidak perduli apapun tipe datanya. Timbul pertanyaan: bagaimana jika kita ingin menyimpan sebuah data
vector ke dalam variabel vector lain, sebuah data hastable lain, bahkan bagaimana jika kita ingin
menyimpan sebuah data vector ke dalam variabel bertipe hastable atau sebaliknya.
Pada bagian ini kita akan membahas tentang data dalam sebuah variabel vector berupa data vector yang
lain.
Pada saat awal, dua variabel myVector 1 da myVector 2 kita isi dengan tiga buah data secara acak. Jadi
myVector 1 memiliki 3 data dan myVector 2 memiliki 3 data juga. Selanjutnya kita menambahkan data ke-
4 dari myVector 2 dimana data ke-4 ini merupakan isi dari myVector 1.
Variabel objek bertipe Hastable juga bisa diperlakukan serupa. Sebuah objek hastable boleh memiliki data
value yang berupa objek hastable lain.
Pada saat awal, dua variabel myHastable dan my hastable 2 kita isi dengan 3 buah data secara acak. Jadi
my hastable 1 memiliki 3 data dan my hastable 2 memiliki 3 data juga. Selanjutnya kita menambahkan data
ke-4 dari my hastable 2 dimana data ke-4 ini merupakan isi dari my hastable 1.