Bab.
4 Perulangan
4.1 Introduksi
Seandainya Anda ingin menampilkan
suatu string “JAVA itu Tangguh!” seratus kali, maka hal itu menjadi pekerjaan
yang melelahkan bila harus menuliskan statemen berikut ini seratus kali:
System.out.println("JAVA
itu Tangguh!");
System.out.println("JAVA
itu Tangguh!");
...
System.out.println("JAVA
itu Tangguh!");
Jadi, bagaimana Anda mengatasi hal
ini? JAVA menyediakan suatu konstruksi yang disebut dengan loop yang bisa
mengendalikan berapa kali suatu operasi atau suatu runtun operasi dieksekusi
secara berurutan. Menggunakan suatu statemen loop, Anda hanya perlu memberitahu
komputer untuk menampilkan suatu string seratus kali, tanpa harus menuliskan
kode di atas seratus kali:
int
hitung = 0;
while
(hitung <
100) {
System.out.println("JAVA itu
Tangguh!");
hitung++;
}
Variabel hitung diinisialisasi 0. Loop memeriksa apakah (hitung < 100) bernilai true. Jika ya, program kemudian
mengeksekusi tubuh loop untuk menampilkan pesan “JAVA itu Tangguh!” dan menginkremen hitung sebanyak 1. Program secara berulang mengeksekusi tubuh loop
sampai (hitung < 100) bernilai false. Ketika (hitung < 100) bernilai false
(ketika hitung bernilai 100), maka loop berhenti dan statemen
setelah loop yang akan dieksekusi.
Loop merupakan suatu konstruksi
yang bisa mengendalikan eksekusi berulang atas suatu blok statemen. Konsep loop
sangat penting bagi pemrograman. JAVA menyediakan tiga tipe statemen loop: loop
while, loop do-while, dan loop for.
4.2 Loop while
Sintaks untuk loop while adalah sebagai berikut:
while
(kondisi-loop)
{
// tubuh loop
Statemen-statemen;
}
Gambar 4.1a menunjukkan diagram
alir loop while. Bagian loop yang
memuat statemen-statemen yang akan dieksekusi secara berulang disebut dengan
tubuh loop. Eksekusi satu-kali atas tubuh loop disebut dengan iterasi loop.
Setiap loop memiliki kondisi-loop atau
kondisi-kontinuasi-loop, suatu
ekspresi Boolean yang mengendalikan eksekusi tubuh loop. Kondisi tersebut
dievaluasi setiap iterasi untuk menentukan apakah tubuh loop dieksekusi atau
tidak. Jika hasil evaluasi terhadap kondisi-loop
bernilai true, maka tubuh loop
dieksekusi; jika bernilai false,
maka keseluruhan loop berhenti dan kendali program beralih kepada statemen yang
mengikuti tubuh loop while.
Loop untuk menampilkan JAVA itu Tangguh! seratus kali yang
telah dikenalkan sebelumnya merupakan salah satu contoh suatu loop while. Diagram alir program tersebut
disajikan pada Gambar 4.1b. kondisi-loop
(hitung < 100) dan tubuh loop
yang memuat dua statemen ditampilkan sebagai berikut:
Gambar
4.1
Loop while secara berulang
mengeksekusi statemen-statemen di dalam tubuh loop ketika hasil evaluasi
terhadap kondisi-kontinuasi-loop
bernilai true.
Berikut adalah suatu contoh lain
untuk membantu Anda memahami bagaimana suatu loop while bekerja:
int
jumlah = 0,
i = 1;
while
(i < 10)
{
jumlah = jumlah + i;
i++;
}
System.out.println("Jumlah
adalah " + jumlah); // jumlah adalah 45
Jika (i < 10) bernilai true,
maka program menambahkan i kepada jumlah. Variabel i diinisialisasi 1, kemudian diinkremen menjadi 2, 3, sampai 10.
Ketika i menjadi 10, i < 10 bernilai false, dan loop berhenti. Jadi, jumlah menjadi 1 + 2 + 3 + ... + 9 = 45.
Apa yang bakal terjadi bila loop
secara salah ditulis sebagai berikut:
int
jumlah = 0,
i = 1;
while
(i < 10)
{
jumlah = jumlah + i;
}
Loop ini tidak akan pernah
berhenti, karena i selalu bernilai 1
dan i < 10 selalu bernilai true.
Pastikan bahwa kondisi-kontinuasi-loop pada akhirnya bernilai false
sehingga program akan berhenti. Kesalahan pemrograman yang umum terjadi
adalah karena loop tidak pernah berhenti. Yaitu, program tidak bisa
menghentikan loop karena kondisi-kontinuasi-loop selalu bernilai true.
Programmer juga seringkali mengeksekusi tubuh loop
satu kali lebih atau satu kali kurang dari yang diharapkan. Hal ini dinamai
dengan error off-by-one. Sebagai contoh, loop berikut ini menampilkan JAVA itu Tangguh!
sebanyak 101 kali, bukan 100 kali. Keselahan terletak pada
kondisi-kontinuasi-loop, yang seharusnya adalah hitung < 100,
bukan hitung
<= 100.
int
hitung = 0;
while
(hitung
<= 100) {
System.out.println("JAVA itu
Tangguh!");
count++;
}
|
4.2.1 Masalah: Menebak Angka
Tantangan di sini adalah menebak
angka yang dibangkitkan suatu komputer. Anda akan menulis suatu program untuk
secara acak membangkitkan suatu integer antara 0 sampai 100. Program kemudian
meminta pengguna untuk memasukkan suatu angka secara kontinyu sampai angka
tersebut cocok dengan angka yang dibangkitkan secara acak oleh komputer. Untuk
setiap masukan pengguna, program akan memberitahukan apakah masukan terlalu
rendah atau terlalu tinggi, sehingga pengguna bisa membuat tebakan berikutnya
secara cerdas.
Bagaimana Anda menulis program
ini? Apakah Anda dengan segera mengkode program? Tentu tidak. Anda perlu waktu
untuk berpikir. Berpikir bagaimana Anda akan menyelesaikan masalah tanpa
menulis suatu program. Anda pertama-tama perlu untuk membangkitkan secara acak
suatu angka antara 0 sampai 100, kemudian meminta pengguna untuk memasukkan
sebuah tebakan, dan kemudian membandingkan tebakan tersebut dengan angka acak
yang telah dibangkitkan sebelumnya. Anda mungkin memiliki draft dasar program
pada kode4.1 sebagai berikut:
Kode4.1 TebakAngkaSatuKali.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import java.util.Scanner;
public class TebakAngkaSatuKali {
public
static void main(String[] args) {
// Membangkitkan suatu angka acak untuk
ditebak
int angka = (int)(Math.random() * 101);
Scanner masukan =
new Scanner(System.in);
System.out.println("Tebak suatu angka dari 0 sampai 100");
// Meminta pengguna memasukkan tebakan
System.out.print("\nBerikan tebakan Anda: ");
int tebak = masukan.nextInt();
if (tebak == angka)
System.out.println("Ya,
Anda benar, Angka Magic adalah " + angka);
else
if (tebak > angka)
System.out.println("Tebakan
Anda terlalu tinggi");
else
System.out.println("Tebakan Anda terlalu rendah");
}
}
|
Keluaran:
Tebak suatu angka dari 0 sampai 100
Berikan tebakan Anda: 50
Tebakan Anda terlalu tinggi
Jika Anda menjalankah program ini,
maka pengguna hanya ditawarkan memberi tebakan sekali saja. Untuk membuat
pengguna bisa memasukkan tebakan berkali-kali, Anda perlu menempatkan kode ini
pada baris 11-20 dalam suatu loop sebagai berikut:
while (true)
{
// Meminta
pengguna memasukkan tebakan
System.out.print("\nBerikan tebakan Anda: ");
int
tebak = masukan.nextInt();
if
(tebak == angka)
System.out.println("Ya, Anda benar, Angka Magic adalah
" + angka);
else
if (tebak > angka)
System.out.println("Tebakan Anda terlalu tinggi");
else
System.out.println("Tebakan Anda terlalu rendah");
} // Akhir loop
Loop di atas akan secara berulang
meminta pengguna untuk memberikan tebakan. Akan tetapi, loop ini tidak benar,
karena tidak pernah berhenti. Ketika tebak
cocok dengan angka, maka loop harus
berhenti. Jadi, loop di atas direvisi menjadi:
while (tebak != angka)
{
// Meminta
pengguna memasukkan tebakan
System.out.print("\nBerikan tebakan Anda: ");
int
tebak = masukan.nextInt();
if (tebak == angka)
System.out.println("Ya, Anda benar, Angka Magic adalah
" + angka);
else
if (tebak > angka)
System.out.println("Tebakan Anda terlalu tinggi");
else
System.out.println("Tebakan Anda terlalu rendah");
} // Akhir loop
Kode program utuh ditampilkan pada
kode4.2 sebagai berikut:
Kode4.2 TebakAngka.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import java.util.Scanner;
public class TebakAngka {
public
static void main(String[] args) {
// Membangkitkan suatu angka acak untuk
ditebak
int
angka = (int)(Math.random() *
101);
Scanner masukan =
new Scanner(System.in);
System.out.println("Tebak suatu angka dari 0 sampai 100");
int tebak = -1;
while (tebak != angka) {
// Meminta pengguna memasukkan tebakan
System.out.print("\nBerikan tebakan Anda: ");
int
tebak = masukan.nextInt();
if
(tebak == angka)
System.out.println("Ya,
Anda benar, Angka Magic adalah " + angka);
else
if (tebak > angka)
System.out.println("Tebakan Anda terlalu tinggi");
else
System.out.println("Tebakan Anda terlalu rendah");
} //Akhir loop
}
}
|
Keluaran:
Tebak suatu angka dari 0 sampai 100
Berikan tebakan Anda: 50
Tebakan Anda terlalu tinggi
Berikan tebakan Anda: 25
Tebakan Anda terlalu tinggi
Berikan tebakan Anda: 12
Tebakan Anda terlalu rendah
Berikan tebakan Anda: 20
Tebakan Anda terlalu tinggi
Berikan tebakan Anda: 15
Tebakan Anda terlalu tinggi
Berikan tebakan Anda: 13
Ya, Anda benar, Angka Magic adalah 13
Perhatikan bahwa tebak diinisialisasi dengan -1. Bila
menginisialisasi tebak dengan suatu
angka antara 0 sampai 100 akan menjadi masalah, karena bisa jadi itu angka yang
akan ditebak.
4.2.2 Strategi Perancangan Loop
Menulis suatu loop yang benar
bukanlah perkara mudah bagi programmer pemula. Perhatikan tiga langkah ketika
menulis suatu loop:
Identifikasi
statemen - statemen yang perlu dieksekusi berulangkali.
Gabungkan
statemen-statemen tersebut menjadi seperti ini:
while (true) {
Statemen
- statemen;
}
Kodekan
kondisi-kontinuasi-loop dan tambahkan statemen-statemen yang perlu untuk
mengendalikan loop:
while (kondisi-kontinuasi-loop) {
Statemen
- statemen;
Statemen – statemen tambahan untuk mengendalikan loop;
}
4.2.3 Masalah: Suatu Perangkat Pembelajaran Matematika
Lanjut
Program perangkat pembelajaran
Matematika pada kode3.4, KuisPengurangan.java, hanya menghasilkan satu
pertanyaan pada saat program berjalan. Anda bisa menggunakan suatu loop untuk
menghasilkan beberapa pertanyaan secara berulang. Bagaimana Anda menulis suatu
kode yang bisa menghasilkan lima pertanyaan? Ikuti strategi perancangan loop.
Pertama, identifikasi statemen - statemen yang perlu dieksekusi berulangkali.
Yaitu, statemen-statemen untuk membangkitkan dua integer secara acak, meminta
pengguna untuk memasukkan jawaban hasil pengurangan, dan menilai kebenaran
jawaban. Kedua, gabungkan statemen-statemen tersebut dalam suatu loop. Ketiga,
tambahkan suatu variabel kendali loop dan kondisi-kontinuasi-loop untuk
mengeksekusi loop sebanyak lima kali.
Kode4.3 memberikan suatu program
untuk membangkitkan lima pertanyaan dan, setelah seorang siswa menjawab kelima
pertanyaan tersebut, program kemudian melaporkan jumlah jawaban yang benar.
Program juga menayangkan waktu yang dihabiskan untuk menjawab kelima pertanyaan
tersebut.
Kode4.3 LoopKuisPengurangan.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
import java.util.Scanner;
public class LoopKuisPengurangan {
public static void main(String[] args) {
final
int JUMLAH_PERTANYAAN = 5; // Jumlah pertanyaan
int
hitungBenar = 0; // Menghitung jumlah jawaban yang benar
int
hitung = 0; // Menghitung jumlah
pertanyaan
long waktuMulai =
System.currentTimeMillis();
String
keluaran = ""; // String keluaran diinisialisasi kosong
Scanner masukan = new Scanner(System.in);
while
(hitung < JUMLAH_PERTANYAAN) {
// 1. Membangkitkan
dua integer satu-dijit secara acak
int
angka1 = (int)(Math.random() * 10);
int
angka2 = (int)(Math.random() * 10);
// 2. Jika angka1 < angka2, tukar
angka1 dengan angka2
if
(angka1 < angka2) {
int
temp = angka1;
angka1 = angka2;
angka2 = temp;
}
// 3. Meminta siswa untuk menjawab
"Berapakah angka1 - angka2?"
System.out.print(
"Berapakah
" + angka1 + " - " + angka2 + "? ");
int
jawab = masukan.nextInt();
// 4. Grade the answer and display the
result
if (angka1 - angka2 == jawab) {
System.out.println("Anda benar!");
hitungBenar++;
}
else
System.out.println("Jawaban Anda salah.\n" +
angka1
+ " - " + angka2 + " seharusnya " + (angka1 -
angka2));
// Inkremen hitung
hitung++;
keluaran += "\n" + angka1 + "-" + angka2 + "=" + jawab +
((angka1 - angka2 == jawab) ? " benar" : " salah");
}
long waktuAkhir =
System.currentTimeMillis();
long waktuUji = waktuAkhir -
waktuMulai;
System.out.println("Jumlah yang benar adalah "
+ hitungBenar +
"\nWaktu
uji adalah " + waktuUji / 1000 + " detik\n" + keluaran);
}
}
|
Keluaran:
Berapakah 8 - 2? 4
Jawaban Anda salah.
8 - 2 seharusnya 6
Berapakah 3 - 0? 5
Jawaban Anda salah.
3 - 0 seharusnya 3
Berapakah 7 - 7? 0
Anda benar!
Berapakah 6 - 4? 2
Anda benar!
Berapakah 7 - 5? 3
Jawaban Anda salah.
7 - 5 seharusnya 2
Jumlah yang benar adalah 2
Waktu uji adalah 14 detik
8-2=4 salah
3-0=5 salah
7-7=0 benar
6-4=2 benar
7-5=3 salah
Program menggunakan variabel
kontrol hitung untuk mengendalikan
eksekusi loop. hitung diinisialisasi 0 (baris 7) dan diinkremen sebesar 1 pada
setiap iterasi (baris 39). Pertanyaan pengurangan ditampilkan dan diproses
setiap iterasi. Program mendapatkan waktu sebelum test pada baris 8 dan waktu setelah
test pada baris 45, dan menghitung jeda waktu pada baris 46. Waktu yang
didapatkan dalam ukuran milidetik dan dikonversi menjadi detik pada baris 49.
4.2.4 Mengendalikan Suatu Loop dengan Nilai Sentinel
Cara umum lainnya dalam
mengendalikan suatu loop adalah dengan menetapkan suatu nilai spesial pada saat
membaca dan memproses sekelompok nilai. Nilai masukan spesial ini, yang dikenal
dengan nilai sentinel, menandai akhir
suatu loop. Suatu loop yang menggunakan suatu nilai sentinel untuk
mengendalikan eksekusi disebut juga dengan loop-terkendali-sentinel.
Kode4.4 memberikan suatu program
yang membaca dan menghitung penjumlahan atas sejumlah integer. Masukan 0
menandakan akhir loop. Apakah Anda perlu mendeklarasikan suatu variabel baru
untuk setiap nilai masukan? Tidak. Anda bisa hanya menggunakan satu variabel, data, pada baris 12, untuk menyimpan
nilai masukan dan menggunakan suatu variabel, jumlah, pada baris 15, untuk menyimpan total penjumlahan. Kapan
saja suatu nilai dibaca, akan ditugaskan kepada data dan, jika nilai masukan tidak bernilai 0, maka akan
ditambahkan kepada jumlah (baris
17).
Kode4.4 NilaiSentinel.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import java.util.Scanner;
public class NilaiSentinel {
/** Metode utama */
public static void main(String[] args) {
// Menciptakan suatu
Scanner
Scanner masukan = new Scanner(System.in);
// Membaca data
inisial
System.out.print(
"Masukkan suatu nilai int (program
berhenti bila masukan adalah 0): ");
int
data = masukan.nextInt();
// Tetap membaca sampai masukan adalah 0
int
jumlah = 0;
while (data != 0) {
jumlah += data;
// Membaca data selanjutnya
System.out.print(
"Masukkan suatu nilai int (program
berhenti bila masukan adalah 0): ");
data = masukan.nextInt();
}
System.out.println("Jumlah
adalah " + jumlah);
}
}
|
Keluaran:
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 3
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 4
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 5
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 0
Jumlah
adalah 12
Jika data tidak 0, maka data
ditambahkan ke jumlah (baris 17) dan
masukan berikutnya dibaca (baris 20 – 22). Jika data bernilai 0, maka tubuh
loop tidak akan dieksekusi dan loop while
berhenti. Nilai masukan 0 merupakan nilai sentinel bagi loop while ini. Perhatikan bahwa bila nilai
masukan pertama dibaca bernilai 0, maka tubuh loop tidak akan pernah
dieksekusi.
Jangan gunakan nilai pecahan untuk pengendali loop.
Karena nilai pecahan merupakan pendekatan dari nilai sebenarnya, maka
menggunakannya dalam kendali loop akan menyebabkan hasil yang tidak tepat.
Perhatikan kode berikut ini untuk menghitung 1 + 0.9 + 0.8 + ... + 0.1:
double
item = 1;
double sum = 0;
while
(item != 0)
{ // Tidak ada jaminan item akan bernilai 0
jumlah += item;
item -= 0.1;
}
System.out.println(jumlah);
Nilai variabel item dimulai dari 1 dan direduksi sebesar 0.1 setiap kali
tubuh loop dieksekusi. Loop akan berhenti bila item
bernilai 0. Akan tetapi, tidak ada jaminan item akan 0 secara eksak, karena aritmatika pecahan
bersifat pendekatan. Loop di atas kelihatan tidak masalah, tetapi sebenarnya
merupakan loop tak-berhingga.
|
4.2.5 Redireksi Masukan dan Keluaran
Pada contoh sebelumnya, jika Anda
memiliki data yang sangat banyak untuk dimasukkan, maka akan sangat melelahkan
bila mengetikkannya lewat keyboard.
Anda bisa menyimpan data tersebut dalam suatu file teks (masing-masing item
data dipisahkan oleh spasi putih), misalnya masukan.txt, dan menjalankan
program menggunakan perintah berikut ini:
java NilaiSentinel < masukan.txt
Perintah ini disebut pula dengan redireksi masukan. Program mengambil
masukan dari file masukan.txt, bukan dari keyboard.
Seandainya isi file masukan.txt adalah
2
3 4 5 6 7 8 9 12 23 32
23 45 67 89
92 12 34 35 3 1 2 4 0
maka program akan menghasilkan jumlah sebesar 518.
Dengan cara yang sama, ada juga
redireksi keluaran, yang mengirimkan keluaran ke suatu file (bukan ditampilkan
pada konsol). Perintah untuk redireksi keluaran adalah
java NilaiSentinel > keluaran.txt
Redireksi masukan dan keluaran
dapat digunakan dalam perintah yang sama. Sebagai contoh, perintah berikut
memperoleh masukan dari file masukan.txt dan mengirimkan keluarannya kepada
file keluaran.txt:
java NilaiSentinel < masukan.txt > keluaran.txt
4.3 Loop do-while
Loop do-while merupakan
variasi dari loop while. Sintaks
loop ini adalah sebagai berikut:
do
{
// Tubuh loop;
Statemen-statemen;
} while (kondisi-kontinuasi-loop);
Diagram alir eksekusi loop do-while
diberikan pada Gambar 4.2.
Gambar
4.2
Loop do-while mengeksekusi tubuh loop terlebih dahulu, kemudian memeriksa kondisi-kontinuasi-loop untuk
menentukan apakah loop berhenti atau lanjut.
Tubuh loop dieksekusi terlebih
dahulu. Kemudian kondisi-kontinuasi-loop
dievaluasi. Jika hasil evaluasi tersebut bernilai true, maka tubuh loop dieksekusi kembali; jika bernilai false, maka loop do-while berhenti.
Perbedaan antara loop while dan loop
do-while adalah urutan evaluasi terhadap kondisi-kontinuasi-loop dan
eksekusi tubuh loop. Anda bisa menulis-ulang kode4.4 menggunakan loop do-while,
seperti yang ditampilkan pada kode4.5:
Kode4.5 UjiDoWhile.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import java.util.Scanner;
public class UjiDoWhile {
/** Metode utama */
public static void main(String[] args) {
int data;
int jumlah = 0;
// Menciptakan suatu
Scanner
Scanner masukan = new Scanner(System.in);
// Tetap membaca
sampai masukan adalah 0
do {
// Membaca data
selanjutnya
System.out.print(
"Masukkan suatu nilai
int (program berhenti bila masukan adalah 0): ");
data =
masukan.nextInt();
jumlah += data;
} while (data != 0);
System.out.println("Jumlah adalah " + jumlah);
}
}
|
Keluaran:
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 3
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 5
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 6
Masukkan
suatu nilai int (program berhenti bila masukan adalah 0): 0
Jumlah
adalah 14
4.4 Loop for
Anda mungkin sering menuliskan
loop dalam format umum seperti ini:
i
= nilaiAwal; // Menginisialisasi variabel kontrol loop
while
(i <
nilaiAkhir) {
// Tubuh loop
...
i++; // Memperbarui variabel kontrol loop
}
Suatu loop for dapat digunakan untuk menyederhanakan loop di atas:
for
(i =
nilaiAwal; i < nilaiAkhir; i++) {
// Tubuh loop
...
}
Pada umumnya, sintaks untuk suatu
loop for ditunjukkan di bawah ini:
for
(aksi-awal;
kondisi-kontinuasi-loop; aksi-setelah-tiap-iterasi) {
// Tubuh loop;
Statemen - statemen;
}
Diagram alir loop for ditampilkan pada Gambar 4.3a.
Statemen loop for diawali dengan
katakunci for, diikuti dengan
sepasang kurung yang mengapit struktur kontrol loop. Struktur ini memuat aksi-awal, kondisi-kontinuasi-loop, dan aksi-setelah-tiap-iterasi.
Struktur kontrol diikuti oleh tubuh loop yang diapit oleh sepasang kurung
kurawal (bila lebih dari satu baris statemen). aksi-awal, kondisi-kontinuasi-loop,
dan aksi-setelah-tiap-iterasi
dipisahkan oleh tanda koma.
Gambar
4.3 Suatu loop for melakukan suatu aksi
awal sekali, kemudian secara berulang mengeksekusi statemen-statemen dalam
tubuh loop, dan terakhir melakukan suatu aksi setelah suatu iterasi dimana di
dalamnya evaluasi terhadap kondisi-kontinuasi-loop
bernilai true.
Suatu loop for biasanya menggunakan suatu variabel untuk mengendalikan berapa kali tubuh loop akan dieksekusi dan menentukan kapan loop akan berhenti. Variabel ini disebut juga dengan variabel kontrol. aksi-awal menginisialisasi variabel kontrol, aksi-setelah-tiap-terasi menginkremen atau mendekremen variabel kontrol, dan kondisi-kontinuasi-loop menguji apakah variabel kontrol telah meraih suatu nilai terminasi. Sebagai contoh, loop for berikut ini menampilkan JAVA itu Tangguh! sebanyak seratus kali:
int
i;
for
(i = 0;
i < 100; i++) {
System.out.println("JAVA itu Tangguh!");
}
Diagram alir kode di atas
ditampilkan pada Gambar 4.3b. Loop for
menginisialisasi i dengan 0,
kemudian secara berulang mengeksekusi statemen println dan mengevaluasi i++
pada saat i kurang dari 100.
aksi-setelah-tiap-iterasi, i++, adalah suatu statemen yang memperbarui variabel kontrol.
Statemen ini dieksekusi setelah (akhir) tiap iterasi. Statemen ini menginkremen
variabel kontrol. Pada gilirannya, nilai variabel kontrol memaksa kondisi-kontinuasi-loop menjadi
bernilai false. Kalau tidak, maka
loop akan menjadi tak-berhingga.
Variabel kontrol loop dapat
dideklarasikan dan diinisialisasi di dalam loop. Berikut adalah contohnya:
for
(int i = 0
; i < 100; i++) {
System.out.println("JAVA itu Tangguh!");
}
Jika hanya terdapat satu statemen
dalam tubuh loop, maka kurung kurawal dapat diabaikan.
Variabel kontrol harus dideklarasikan di dalam
struktur kontrol atau sebelum loop. Jika variabel kontrol loop hanya
digunakan di dalam loop, tidak di tempat lain, maka mendeklarasikannya di
dalam aksi-awal loop for merupakan suatu teknik pemrograman yang baik. Jika
variabel kontrol dideklarasikan di dalam struktur kontrol, maka variabel
tersebut tidak bisa direferensikan di luar loop.
aksi-awal
di dalam suatu loop for dapat berupa beberapa ekspresi penugasan atau beberapa
statemen deklarasi yang masing-masing dipisahkan oleh tanda koma. Sebagai
contoh,
for
(int
i = 0, j = 0 ; (i + j < 10);
i++, j++) {
// Lakukan sesuatu
}
aksi-setelah-tiap-iterasi di dalam suatu loop for dapat berupa beberapa
statemen deklarasi yang masing-masing dipisahkan oleh tanda koma. Sebagai
contoh,
for (int i
= 1; i < 100; System.out.println(i), i++);
Contoh di atas memang benar, namun merupakan contoh
teknik pemrograman yang buruk, karena membuat kode susah untuk dibaca.
Normalnya, Anda mendeklarasikan dan menginisialisasi suatu variabel kontrol
sebagai aksi-awal dan menginkremen dan mendekremen variabel kontrol
sebagai aksi-setelah-tiap-iterasi.
Jika kondisi-kontinuasi-loop di dalam loop for diabaikan, maka secara implisit hal itu benar. Jadi,
statemen yang ada pada (a) di bawah ini, yang merupakan suatu loop
tak-berhingga, ekivalen dengan (b). Untuk menghidari kebingungan, loop
ekivalen diberikan pada (c):
 |
4.5 Loop Mana yang Digunakan?
Loop for dan loop while
disebut dengan loop pretest karena kondisi kontinuasi diperiksa sebelum tubuh
loop dieksekusi. Loop do-while disebut dengan loop posttest karena kondisi kontinuasi
diperiksa setelah tubuh loop dieksekusi. Tiga format loop: for, while dan do-while
adalah ekivalen. Oleh karena itu, Anda bisa membuat salah satu dari ketiga
format loop untuk melakukan tugas yang sama. Sebagai contoh, suatu loop while pada (a) dapat selalu dikonversi
menjadi loop for pada (b):
Menambahkan titik koma pada akhir for,
sebelum tubuh loop, merupakan suatu kesalahan yang umum terjadi, seperti yang
ditampilkan pada (a) di bawah ini. Pada (a) titik koma menandakan akhir loop
secara prematur. Tubuh loop pada kasus tersebut sebenarnya kosong, seperti
yang ditunjukkan pada (b). Jadi, (a) dan (b) adalah ekivalen.
Hal yang sama, loop pada (c) juga salah dan ekivalen
dengan loop pada (d):
Error-error di atas terjadi karena penggunaan gaya
blok next-line. Penggunaan gaya blok end-of-line dapat menghindarkan error
ini.
Pada kasus loop do-while, tanda titik koma dibutuhkan
untuk mengakhiri loop.
 |
4.6 Loop Nested
Loop nested memuat suatu loop sebelah luar dan satu atau lebih loop
sebelah dalam. Setiap kali loop sebelah luar diulangi, loop-loop sebelah dalam
juga diulangi.
Kode4.6 TabelPerkalian.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class TabelPerkalian {
/** Metode utama */
public static void main(String[] args) {
// Menampilkan kepala tabel
System.out.println(" Tabel Perkalian");
// Menampilkan judul angka
System.out.print(" ");
for (int j = 1; j <= 9; j++)
System.out.print(" " + j);
System.out.println("\n———————————————————————————————————————");
// Mencetak tubuh tabel
for (int i = 1; i <= 9; i++) {
System.out.print(i
+ " | ");
for (int j
= 1; j <= 9; j++) {
// Menampilkan
perkalian dan ratakan secara layak
System.out.printf("%4d", i *
j);
}
System.out.println();
}
}
}
|
Keluaran:
Tabel
Perkalian
1 2
3 4 5
6 7 8 9
———————————————————————————————————————
1 | 1 2
3 4 5
6 7 8 9
2 | 2 4
6 8 10 12 14
16 18
3 | 3 6
9 12 15 18 21
24 27
4 | 4 8
12 16 20 24 28
32 36
5 | 5 10
15 20 25 30 35
40 45
6 | 6 12
18 24 30 36 42
48 54
7 | 7 14
21 28 35 42 49
56 63
8 | 8 16
24 32 40 48 56
64 72
9 | 9 18
27 36 45 54 63
72 81
4.7 Meminimalkan Error Numerik
Error numerik yang melibatkan
angka-angka pecahan merupakan sesuatu yang tidak bisa dihindari. Bagain ini
ditujukan untuk mendiskusikan bagaimana meminimalkan error jenis ini lewat
contoh.
Kode4.7 menyajikan suatu contoh
yang menghitung jumlah suatu deret yang dimulai dari 0.01 dan berakhir dengan
1.0. Angka-angka dalam deret ini akan diinkremen sebesar 0.01, seperti 0.01 +
0.02 + 0.03 dan seterusnya.
Kode4.7 TestJumlah.java
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class TestJumlah {
public
static void main(String[] args) {
// Menginisialisasi jumlah
float
jumlah = 0;
// Tambahkan 0.01, 0.02, ..., 0.99, 1
kepada jumlah
for (float i = 0.01f; i <= 1.0f; i = i + 0.01f)
jumlah += i;
// Tampilkan hasil
System.out.println("Jumlah adalah " + jumlah);
}
}
|
Keluaran:
Jumlah adalah 50.499985
Loop for (baris 7-8) secara berulang menjumlahkan variabel kontrol i kepada jumlah. Variabel ini, dimulai dengan 0.01, diinkremen sebesar 0.01
pada akhir setiap iterasi. Loop berhenti ketika i melebih 1.0.
aksi-awal pada loop for dapat berupa sembarang statemen, tetapi
seringkali digunakan untuk menginisialisasi suatu variabel kontrol. Dari contoh
ini, Anda dapat melihat bahwa suatu variabel kontrol dapat berupa suatu tipe float.
jumlah secara eksak sebenarnya
adalah 50.50, tetapi keluaran yang diberikan adalah 50.499985. Hasil ini tidak tepat karena
komputer menggunakan komputer menggunakan sejumlah bit yang tetap untuk
merepresentasikan angka-angka pecahan, jadi kadangkala terdapat beberapa angka
pecahan yang tidak direpresentasikan secara tepat. Jika Anda mengubah float menjadi double, sebagai berikut, Anda pasti melihat sedikit perbaikan dalam
kepresisian, karena suatu variabel double
menyediakan 64-bit, sedangkan float
hanya menyediakan 32 bit, untuk merepresentasikan angka pecahan.
//
Menginisialisasi jumlah
double jumlah
= 0;
//
Menambahkan 0.01, 0.02, ..., 0.99, 1 kepada jumlah
for
(double i = 0.01; i <= 1.0;
i = i + 0.01)
jumlah += i;
Namun, Anda juga akan heran bila
keluarannya menjadi 49.50000000000003. Apa yang salah? Jika Anda
menampilkan i untuk setiap iterasi dalam loop, Anda akan melihat bahwa i
yang terakhir lebih besar sedikit dari 1 (tidak persis 1). Hal ini menyebabkan i
yang terakhir tidak dijumlahkan kepada jumlah. Masalah fundamental di
sini adalah karena angka-angka pecahan direpresentasikan dengan pendekatan.
Untuk mengatasi masalah ini, gunakan suatu integer hitung untuk
memastikan bahwa semua angka dijumlahkan kepada jumlah. Inilah loop
tersebut:
double
nilaiSekarang
= 0.01;
for
(int hitung = 0; hitung < 100; hitung++) {
jumlah += nilaiSekarang;
nilaiSekarang += 0.01;
}
Setelah loop tersebut dieksekusi, jumlah sebesar 50.50000000000003. Loop ini
menjumlahkan angka-angka dari kecil ke besar. Apa yang terjadi bila Anda
menjumlahkan angka-angka dari besar ke kecil (yaitu, 1.0, 0.99, 0.98, ...,
0.02, 0.01) sebagai berikut:
double
nilaiSekarang
= 1.0;
for
(int hitung = 0; hitung < 100; hitung++) {
jumlah += nilaiSekarang;
nilaiSekarang -= 0.01;
}
Setelah loop ini dieksekusi, jumlah menjadi sebesar
50.49999999999995.
Menjumlahkan angka-angka dari besar ke kecil kurang akurat bila dibandingkan
dengan menjumlahkan dari kecil ke besar. Jadi di sini disimpulkan bahwa
penjumlahan angka-angka pecahan dari kecil ke besar dapat dipakai untuk
meminimalkan error numerik.
4.8 Studi Kasus
Loop merupakan hal yang vital
dalam pemrograman. Kemampuan untuk menuliskan suatu loop dalam program JAVA
merupakan hal penting. Jika Anda bisa
menulis program menggunakan loop, berarti Anda tahu bagaimana memprogram!.
Karena alasan ini, bab ini menyajikan tiga contoh tambahan tentang bagaimana
menyelesaikan masalah menggunakan loop.
4.8.1 Masalah: Mencari GCD
GCD (greatest common divisor, pembagi bersama terbesar) atas dua integer 4 dan 2 adalah 2. GCD antara
16 dan 24 adalah 8. Bagaimana Anda menemukan GCD? Dimisalkan dua masukan
integer n1 dan n2. Anda tahu bahwa satu bisa jadi merupakan suatu pembagi bersama,
tetapi 1 tidak mungkin menjadi pembagi bersama terbesar. Jadi, Anda perlu
memeriksa apakah k ( untuk k = 2, 3, 4, dan seterusnya) adalah
suatu pembagi bersama terbesar untuk n1
dan n2, sampai k lebih besar dari n1
atau n2.
Pembagi bersama yang ditemukan
disimpan dalam suatu variabel, gcd.
Pada saat awal, gcd diberi nilai 1.
Kapan saja suatu pembagi bersama yang baru ditemukan, maka nilai tersebut
menjadi nilai gcd yang baru. Ketika
semua pembagi bersama mulai dari 2 sampai n1
atau n2 selesai diperiksa, maka
nilai gcd yang terakhir menjadi
nilai GCD. Ide ini diterjemahkan menjadi loop berikut ini:
int
gcd = 1;
// Inisialisasi gcd dengan 1
int
k = 2;
// gcd yang mungkin
while
(k <= n1
&& k <= n2) {
if (n1 % k == 0 && n2 % k == 0)
gcd = k; //
Memperbarui gcd
k++; //
gcd berikutnya yang mungkin
}
Kode4.8 menyajikan program yang
meminta pengguna untuk memasukkan dua integer positif dan yang mencari GCD atas
dua integer tersebut.
Kode4.8 PembagiBersamaTerbesar.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import java.util.Scanner;
public class PembagiBersamaTerbesar {
/** Metode utama */
public static void main(String[] args) {
// Menciptakan Scanner
Scanner masukan = new Scanner(System.in);
// Meminta pengguna
memasukkan dua integer
System.out.print("Masukkan integer positif pertama: ");
int n1 = masukan.nextInt();
System.out.print("Masukkan integer positif kedua: ");
int n2 = masukan.nextInt();
int gcd = 1; // nilai awal gcd
int k = 2; // gcd yang
mungkin
while (k <= n1 && k <= n2) {
if (n1 % k == 0 && n2 % k ==
0)
gcd = k; // Update
gcd
k++;
}
System.out.println("Pembagi Bersama Terbesar untuk
" + n1 +
" dan " + n2 + "
adalah " + gcd);
}
}
|
Keluaran:
Masukkan integer positif pertama: 125
Masukkan integer positif kedua: 5635
Pembagi Bersama Terbesar untuk 125 dan 5635 adalah 5
Masukkan integer positif pertama: 234
Masukkan integer positif kedua: 26728
Pembagi Bersama Terbesar untuk 234 dan 26728 adalah 26
Bagaimana Anda menulis program tersebut?
Apakah Anda langsung menuliskannya? Tentu tidak. Sangat penting bagi Anda untuk
berpikir sebelum menulis. Berpikir dapat memampukan Anda untuk menghasilkan
solusi logis untuk masalah yang sedang dihadapi. Begitu Anda menemukan
solusinya, Anda hanya perlu menerjemahkannya dalam program JAVA. Penerjemahan
ide menjadi program JAVA bukanlah unik. Sebagai contoh, Anda bisa menggunakan
suatu loop for untuk kode4.8 sebagai berikut:
for
(int k
= 2; k <= n1 && k <= n2; k++) {
if (n1 % k == 0 && n2 % k == 0)
gcd = k;
}
Suatu masalah seringkali memiliki
banyak penyelesaian. Masalah GCD sendiri bisa diselesaikan dengan banyak cara.
Salah satu solusi yang efisien adalah menggunakan algoritma Euclidean.
4.8.2 Masalah: Memprediksi Uang Kuliah
Dimisalkan uang kuliah tahun ini
adalah sebesar Rp. 10.000 dan bertambah setiap tahun sebesar 7%. Dalam berapa
tahunkah uang kuliah menjadi dua kali lipat?
Sebelum Anda menulis suatu program
untuk menyelesaikan masalah ini, pertama-tama selesaikan secara analitik dengan
tangan. Besar uang kuliah tahun kedua adalah 1.07 * uang kuliah tahun pertama.
Besar uang kuliah tahun depan adalah 1.07 * uang kuliah tahun ini. Jadi, besar
uang kuliah setiap tahun dapat dihitung sebagai berikut:
double
uang_kul = 10000;
int tahun = 1 // Tahun 1
uang_kul
= uang_kul * 1.07; tahun++; // Tahun
2
uang_kul
= uang_kul * 1.07; tahun++; // Tahun
3
uang_kul
= uang_kul * 1.07; tahun++; // Tahun
4
...
Jika terus dihitung, maka akan
ditemukan tahun dimana nilai uang_kul
paling sedikit 20000. Pada saat itu, Anda akan mengetahui berapa tahun yang
dibutuhkan agar uang kuliah menjadi dua kali lipat. Sekarang Anda bisa
menerjemahkan logika di atas menjadi loop sebagai berikut:
double
uang_kul = 10000;
// Tahun 1
int
tahun = 1;
while
(uang_kul
< 20000) {
uang_kul = uang_kul * 1.07;
tahun++;
}
Program utuh ditampilkan pada
kode4.9 berikut ini:
Kode4.9 PrediksiUangKuliah.java
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class PrediksiUangKuliah {
public
static void main(String[] args) {
double
uang_kul = 10000; // Tahun 1
int
tahun = 1;
while (uang_kul < 20000) {
uang_kul =
uang_kul * 1.07;
tahun++;
}
System.out.println("Uang Kuliah akan menjadi dua kali lipat dalam "
+ tahun + " tahun");
}
}
|
Keluaran:
Uang Kuliah akan menjadi dua kali lipat dalam 12 tahun
Loop while (baris 5-8) digunakan untuk secara berulang menghitung uang
kuliah setiap tahun. Loop berhenti bila uang_kul
lebih besar atau sama dengan 20000.
4.8.3 Masalah: Simulasi Monte Carlo
Simulasi Monte Carlo menggunakan
bilangan acak dan probabilitas dalam menyelesaikan masalah. Metode ini memiliki
terapan-terapan yang luas mulai dari fisika, kimia, matematika, sampai
keuangan. Pada saat ini, akan disajikan bagaimana Monte Carlo dimanfaatkan
untuk mengestimasi
.
Untuk mengestimasi
menggunakan metode Monte Carlo, suatu
lingkaran digambarkan dengan batas persegi, seperti ditampilkan pada gambar di
bawah ini:
Diasumsikan bahwa radius lingkaran
adalah 1. Jadi, luas lingkaran adalah
dan luas persegi adalah 4. Jika suatu titik
dibangkitkan secara acak di dalam persegi, maka probabilitas titik tersebut
jatuh di dalam lingkaran adalah luasLingkaran
/ luasPersegi =
.
Tulislah suatu program yang secara
acak membangkitkan 1000000 titik di dalam persegi dan biarkan jumlahJatuh menandakan jumlah titik
yang jatuh di dalam lingkaran. Jadi, jumlahJatuh
secara pendekatan didefinisikan sebagai 1000000
*
dan
dapat didekati dengan persamaan 4 * jumlahJatuh / 1000000. Program utuh
ditampilkan pada kode4.10 sebagai berikut:
Kode4.10 SimulasiMonteCarlo.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class SimulasiMonteCarlo {
public
static void main(String[] args) {
final
int JUMLAH_PERCOBAAN = 10000000;
int
jumlahJatuh = 0;
for
(int i = 0; i < JUMLAH_PERCOBAAN; i++) {
double x =
Math.random() * 2.0 - 1;
double y =
Math.random() * 2.0 - 1;
if
(x * x + y * y <= 1)
jumlahJatuh++;
}
double pi = 4.0 * jumlahJatuh /
JUMLAH_PERCOBAAN;
System.out.println("PI
adalah " + pi);
}
}
|
Keluaran:
PI adalah 3.1417252
Program secara berulang membangkitkan
suatu titik acak (x, y) di dalam persegi pada baris 7-8:
double x = Math.random() * 2.0 - 1;
double y = Math.random() * 2.0 - 1;
Jika
,
maka titik berada di dalam lingkaran dan jumlahJatuh diinkremen sebesar 1.
dapat didekati dengan 4 * jumlahJatuh / JUMLAH_PERCOBAAN (baris 13).
4.9 Katakunci continue
dan break
Anda telah menggunakan katakunci break di dalam suatu statemen switch. Anda juga bisa menggunakan break di dalam suatu loop untuk
memberhentikan loop secara mendadak. Kode4.11 menyajikan suatu program untuk
mendemonstrasikan pengaruh penggunaan suatu break di dalam loop.
Kode4.11 TestBreak.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class TestBreak {
public
static void main(String[] args) {
int
jumlah = 0;
int
angka = 0;
while
(angka < 20) {
angka++;
jumlah += angka;
if (jumlah >= 100)
}
System.out.println("Angka adalah " + angka);
System.out.println("Jumlah adalah " + jumlah);
}
}
|
Keluaran:
Angka adalah 14
Jumlah adalah 105
Program pada kode4.11 menambahkan
integer-integer 1 sampai 20 secara berurutan kepada variabel jumlah sampai jumlah lebih besar atau sama dengan 100. Tanpa statemen if (baris 9), program akan menjumlahkan
integer-integer 1 sampai 20 tanpa adanya interupsi. Tetapi dengan statemen if, loop berhenti ketika jumlah lebih besar atau sama dengan
100. Tanpa statemen if, maka
keluaran akan menjadi:
Angka adalah 20
Jumlah adalah 210
Anda juga bisa menggunakan
katakunci continue dalam suatu loop.
Ketika ini terjadi, maka kendali program mengarah ke akhir tubuh loop. Dengan
kata lain, continue membuat program
keluar dari satu iterasi sedangkan break
membuat program keluar dari loop. Kode4.12 menyajikan suatu program untuk
mendemonstrasikan pengaruh penggunaan continue
di dalam suatu loop.
Kode4.12 TestContinue.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class TestBreak {
public
static void main(String[] args) {
int
jumlah = 0;
int
angka = 0;
while
(angka < 20) {
angka++;
if (angka == 10 || angka == 11)
jumlah += angka;
}
System.out.println("Jumlah adalah " + jumlah);
}
}
|
Keluaran:
Jumlah adalah 189
Program dalam kode4.12
menjumlahkan integer-integer dari 1 sampai 20, kecuali 10 dan 11, kepada jumlah. Dengan statemen if (baris 8), statemen continue dieksekusi ketika angka 10
atau 11. Statemen continue
mengakhiri iterasi sehingga sisa statemen di dalam tubuh loop tidak akan
dieksekusi; oleh karena itu, angka
tidak dijumlahkan kepada jumlah
ketika angka bernilai 10 atau 11.
Tanpa statemen if, keluaran program
menjadi:
Jumlah adalah 210
Pada kasus ini, semua angka
dijumlahkan kepada jumlah, meski
bila angka bernilai 10 atau 11. Oleh
karena itu, hasilnya adalah 210, lebih 21 dari hasil ketika statemen if digunakan.
Program dalam kode4.2 memberikan
permainan menebak angka. Anda bisa menulis-ulangnya menggunakan suatu statemen break, seperti yang ditunjukkan pada
kode4.13:
Kode4.13 TebakAngkaMenggunakanBreak.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import java.util.Scanner;
public class TebakAngkaMenggunakanBreak {
public
static void main(String[] args) {
// Membangkitkan suatu angka acak untuk
ditebak
int
angka = (int)(Math.random() *
101);
Scanner masukan = new Scanner(System.in);
System.out.println("Tebak suatu angka dari 0 sampai 100");
while (true) {
// Meminta pengguna memasukkan tebakan
System.out.print("\nBerikan tebakan Anda: ");
int
tebak = masukan.nextInt();
if
(tebak == angka) {
System.out.println("Ya, Anda benar, Angka Magic adalah
" + angka);
break;
}
else
if (tebak > angka)
System.out.println("Tebakan Anda terlalu tinggi");
else
System.out.println("Tebakan Anda terlalu rendah");
}
}
}
|
Keluaran:
Tebak suatu angka dari 0 sampai 100
Berikan tebakan Anda: 50
Tebakan Anda terlalu rendah
Berikan tebakan Anda: 95
Tebakan Anda terlalu tinggi
Berikan tebakan Anda: 91
Ya, Anda benar, Angka Magic adalah 91
4.9.1 Masalah: Menampilkan Bilangan Prima
Suatu integer lebih besar dari 1
dikatakan prima bila pembagi positifnya adalah 1 atau dirinya sendiri. Sebagai
contoh, 2, 3, 5, dan 7 merupakan angka prima, tetapi 4, 6, 8, dan 9 bukan angka
prima.
Masalah di sini adalah bagaimana
mencari 50 angka prima pertama dan menampilkannya dalam lima baris, yang
masing-masing baris terdiri-dari 10 angka prima. Masalah ini dapat dipecah
menjadi beberapa tugas sebagai berikut:
- Menentukan apakah suatu angka prima atau tidak.
- Untuk angka = 2, 3, 4, 5, 6, ..., diuji keprimaannya.
- Menghitung jumlah angka prima yang didapatkan.
- Menampilkan setiap angka prima, sepuluh angka prima tiap baris.
Sekarang jelas terlihat bahwa Anda
membutuhkan suatu loop untuk secara berulang memeriksa apakah suatu angka prima
atau tidak. Jika angka adalah prima,
maka hitung diinkremen sebesar 1.
Variabel hitung diinisialisasi
dengan 0. Ketika hitung berjumlah
50, maka loop akan berhenti.
Berikut merupakan algoritma untuk
masalah keprimaan ini:
Tetapkan
jumla angka prima yang akan ditampilkan sebagai suatu konstanta bernama
JUMLAH_PRIMA;
Gunakan
hitung untuk menjejak jumlah angka prima dan inisialisasi dengan 0;
Inisialisasi
angka dengan 2;
while (hitung < JUMLAH_PRIMA) {
Uji apakah suatu angka prima atau bukan;
if angka adalah prima {
Tampilkan angka prima dan inkremen hitung
sebesar 1;
}
Inkremen angka dengan 1;
}
Untuk menguji apakah suatu angka
itu prima atau bukan, periksa apakah angka tersebut dapat dibagi (tanpa sisa)
oleh 2, 3, 4, sampai angka/2. Jika
suatu pembagi ditemukan, maka angka itu bukanlah angka prima. Algoritma ini
dapat dideskripsikan sebagai berikut:
Gunakan
suatu variabel Boolean apaPrima untuk menandakan apakah
suatu
angka prima atau tidak; Inisialisasi apaPrima dengan true;
for
(int pembagi
= 2; pembagi <= angka / 2; pembagi++) {
if (angka % pembagi == 0) {
Tetapkan apaPrima sebagai false;
Keluar loop;
}
}
Program utuh ditampilkan pada
kode4.14 sebagai berikut:
Kode4.14 AngkaPrima.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
public class AngkaPrima {
public
static void main(String[] args) {
final
int JUMLAH_PRIMA = 50; // Jumlah prima yang akan ditampilkan
final
int JUMLAH_PRIMA_PER_BARIS = 10; // Menampilkan 10 per baris
int
hitung = 0; // Menghitung jumlah angka
prima
int
angka = 2; // Angka yang akan diuji keprimaannya
System.out.println("50 angka prima pertama adalah \n");
// Secara berulang mencari angka-angka
prima
while (hitung < JUMLAH_PRIMA) {
// Asumsikan angka
prima
boolean
apaPrima = true;
// Menguji apakah suatu angka prima atau
tidak
for (int
pembagi = 2; pembagi <= angka / 2; pembagi++) {
if (angka % pembagi == 0) { // jia
true, angka tidak prima
apaPrima = false; // Tetapkan apaPrima
menjadi false
break; // Keluar loop
}
}
// Menampilkan
angka prima dan menambah hitung
if
(apaPrima) {
hitung++; // Menginkremen hitung
if (hitung % JUMLAH_PRIMA_PER_BARIS
== 0) {
// Menampilkan angka prima dan ganti
baris
System.out.println(angka);
}
else
System.out.print(angka + "
");
}
// Periksa apakah angka berikutnya
adalah prima
angka++;
}
}
}
|
Keluaran:
50 angka prima pertama adalah
2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97 101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229
Untuk menentukan apakah suatu
angka prima atau tidak, periksa angka tersebut apakah dapat dibagi (tanpa sisa)
oleh suatu angka antara 2 sampai angka/2
(baris 16). Jika ya, maka angka tersebut bukan prima (baris 18); sebaliknya
angka itu prima. Jika hitung dapat
dibagi (tanpa sisa) oleh 10 (baris 27-30), maka dipaksa untuk ganti baris.
Program berakhir bila hitung meraih
nilai 50.
Program menggunakan statemen break pada baris 19 agar keluar dari
loop begitu angka yang diuji tidak bilangan prima. Anda bisa menulis-ulang
(baris 16-21) tanpa menggunakan statemen break, sebagai berikut:
for
(int pembagi
= 2; pembagi <= angka / 2 && apaPrima; pembagi++) {
// Jika true, angka bukan prima
if (angka % pembagi ==
0) {
// Tetapkan Apaprima menjadi false, bila
angka bukan prima
apaPrima = false;
}
}
Anda dapat memperhatikan bahwa
penggunaan statemen break dapat
membuat progam menjadi lebih mudah dibaca dan dimengerti.
4.10 Mengendalikan Loop dengan Kotak Konfirmasi
Suatu loop yang terkendali oleh
nilai sentinel dapat diimplementasikan dengan dialog konfirmasi. Jawaban Yes untuk lanjut atau No untuk memberhentikan loop. Template
loop akan seperti ini:
int
opsi =
JOptionPane.YES_OPTION;
while
(opsi ==
JOptionPane.YES_OPTION) {
System.out.println("loop
berlanjut");
opsi = JOptionPane.showConfirmDialog(null,
"Lanjut?");
}
Kode4.15 menulis-ulang kode4.4,
NilaiSentinel.java, menggunakan suatu kotak dialog konfirmasi. Screenshot hasil
keluaran program diberikan pada Gambar 4.4.
Gambar
4.4
Pengguna mengentri 3 pada (a), klik Yes
pada (b), memasukkan 5 pada (c), klik No
pada (d), dan hasil ditampilkan pada (c)
Kode4.15 NilaiSentinelMenggunakanKotakDialog.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import javax.swing.JOptionPane;
public class NilaiSentinelMenggunakanKotakDialog {
public
static void main(String[] args) {
int
jumlah = 0;
// Tetap membaca data sampai pengguna
menjawab No
int
opsi = JOptionPane.YES_OPTION;
while
(opsi == JOptionPane.YES_OPTION) {
// Membaca data berikutnya
String dataString =
JOptionPane.showInputDialog(
"Masukkan
suatu nilai int: ");
int
data = Integer.parseInt(dataString);
jumlah += data;
opsi =
JOptionPane.showConfirmDialog(null, "Lanjut?");
}
JOptionPane.showMessageDialog(null,
"Jumlah adalah " + jumlah);
}
}
|
Program menampilkan suatu kotak
masukan untuk meminta pengguna memasukkan suatu integer (baris 11) dan
menambahkannya kepada jumlah (baris
15). Baris 17 menampilkan suatu konfirmasi dialog untuk membiarkan pengguna
apakah melanjutkan atau tidak. Jika pengguna mengklik Yes, loop akan berlanjut; sebaliknya loop akan keluar. Akhirnya program menampilkan hasil di dalam
kotak dialog pesan (baris 20).
No comments:
Post a Comment