Java With Eclipse

Untuk kelas pengecualian yang mewajibkan penanganan pengecualian, siatuasinya sedikit berbeda. Jika suatu subrutin bisa melempar pengecualian seperti ini, maka klausa [code]throws

harus ditulis pada definisi subrutin. Jika tidak, maka compiler

akan menampilkan kesalahan sintaks. Di sisi lain, misalnya suatu pernyataan dalam program dapat melemparkan pengecualian yang mewajibkan penanganan pengecualian. Pernyataan tersebut bisa berasal dari pernyataan throw yang sengaja dilemparkan atau hasil dari pemanggilan suatu subrutin yang melempar pengecualian tersebut. Pengecualian ini harus ditangani dengan salah satu dari dua cara, yaitu : Menggunakan pernyataan try yang memiliki klausa catch untuk

menangani pengecualian tersebut. Atau dengan menambahkan klausa throws di kepala definisi subrutin. Jika klausa throws digunakan, maka subrutin lain yang memanggil subrutin kita akan bertanggung jawab menangani pengecualian tersebut. Jika kita tidak menangani pengecualian tersebut dengan cara-cara di atas, maka Java akan menganggap sebagai kesalahan sintaks. Penanganan pengecualian menjadi wajib untuk kelas yang bukan kelas turunan dari Error atau RuntimeException. Pengecualian yang wajib biasanya merupakan kondisi yang berada di luar jangkauan programmer. Misalnya, input ilegal atau aksi ilegal oleh user. Program tangguh harus bisa menangani kondisi seperti ini. Desain Java tidak memungkinkan programmer untuk mengabaikan kondisi tersebut. Di antara pengecualian yang mewajibkan penanganan pengecualian adalah yang berhubungan dengan rutin input/output. Artinya kita tidak boleh menggunakan rutin ini jika kita mengetahui bagaimana menangani pengecualian. Bagian berikutnya akan membahas tentang contoh-contoh input/output dan penanganan pengecualian dengan lebih gamblang. Pemrograman dengan Pengecualian Pengecualian bisa digunakan untuk membantu kita menulis program tangguh. Pengecualian adalah pendekatan yang terstruktur dan terorganisir untuk membuat program tangguh. Tanpa pengecualian, program akan dipenuhi dengan pernyataan if untuk menguji berbagai macam kondisi kesalahan. Dengan pengecualian, kita bisa menulis program yang algoritma yang lebih jelas, di mana kasus-kasus pengecualian akan ditangani di bagian lain, yaitu di dalam klausa catch. Membuat Kelas Pengecualian Baru Ketika suatu program menemukan kondisi yang tidak biasa dan tidak ada cara yang masuk akal untuk ditangani pada saat itu juga, program akan melempar pegecualian. Dalam beberapa kasus, mungkin akan lebih mudah apabila pengecualian yang dilemparkan merupakan

objek

dari

salah

IllegalArgumentException

satu

kelas

pengecualian

bawaah

Java,

seperti

atau IOException.

Akan tetapi, jika tidak ada kelas standar yang cukup mewakili jenis pengecualian tersebut, programmer bisa membuat kelas pengecualian baru. Kelas baru tersebut harus diturunkan dari kelas standar Throwable atau kelas turunannya. Secara umum, kelas baru merupakan

turunan dari kelas RuntimeExceptionatau kelas turunannya jika programmer tidak mewajibkan penanganan kesalahan. Untuk membuat kelas pengecualian baru yang mewajibkan penanganan kesalahan, programmer dapat membuat turunan dari kelas Exception

atau salah satu kelas turunannya.

Berikut ini adalah contoh suatu kelas yang merupakan turunan dari kelas Exception yang mewajibkan penanganan kesalahan apabila ia dilemparkan : public class KelasahanBaca extends Exception { public KelasahanBaca(String pesan) { // Konstruktor. Membuat objek dari KesalahanBaca yang berisi // pesan kesalahan super(pesan); } }

Kelas tersebut hanya memiliki konstruktor sehingga kita bisa membuat objek dari kelas KesalahanBaca

yang berisi pesan kesalahan. (Pernyataan "super(pesan)" memanggil

konstruktor di kelas supernya, yaitu Exception. Lihat bagian sebelumnya). Tentunya kelas tersebut juga mewariskan metode getMessage() dan printStackTrace() dari kelas supernya. Jika e merujuk pada objek dengan tipe KesalahanBaca maka perintah e.getMessage()

akan mengambil pesan kesalahan yang diberikan pada konstruktornya.

Apabila objek dengan tipe KesalahanBaca dilempar, ini berarti jenis kesalahan tertentu telah terjadi. (Mungkin misalnya terjadi apabila pembacaan suatu String yang diproses program tidak sesuai dengan format yang diharapkan). Pernyataan throw bisa digunakan untuk melempar kesalahan dengan tipe KesalahanBaca. Konstruktor objek ini harus memiliki pesan kesalahan, misalnya : throw new ParseError("Ditemukan bilangan negatif ilegal.");

atau throw new ParseError("Kata '" + word + "' bukan nama file yang benar.");

Jika pernyataan throw tidak terdapat dalam pernyataan try yang menangkap kesalahan tersebut, maka subrutin yang melemparnya harus dideklarasikan di awal bahwa subrutin tersebut bisa melempar KesalahanBaca, yaitu dengan menambah klausa "throws KesalahanBaca".

Misalnya :

void ambilNamaUser() throws KesalahanBaca { . . . }

Klausa ini tidak diperlukan apabila KesalahanBaca didefinisikan sebagai turunan dari kelas RuntimeException, karena pengecualian ini tidak wajib untuk ditangani.

Suatu subrutin yang ingin menangani KesalahanBaca dapat menggunakan pernyataan try dengan klausa catch untuk menangkap KesalahanBaca. Misalnya try { ambilNamaUser(); olahNamaUser(); } catch (KesalahanBaca kb) { . . .

// Tangani kesalahan

}

Ingat bahwa karena KesalahanBaca adalah kelas turunan dari Exception, maka klausa catch

dalam bentuk "catch (Exception e)" juga akan menangkap KesalahanBaca dan

juga objek yang bertipe Exception. Kadang-kadang, ada gunanya untuk menyimpan data dalam objek pengecualian, misalnya : class KapalMeledak extends RuntimeException { Kapal kapal;

// Kapal yang meledak

int lokasi_x, lokasi_y;

// Lokasi tempat kapal meledak

KapalMeledak(String pesan, Kapal k, int x, int y) { // Konstruktor: Buat objek KapalMeledak yang menyimpan // pesan kesalahan dan informasi bahwa kapal k // meledak pada lokasi x,y pada layar super(pesan); kapal = k; lokasi_x = x; lokasi_y = y; } }

Di sini, objek KapalMeledak berisi pesan kesalahan dan informasi tambahan tentang kapal yang meledak, yang bisa digunakan dalam perintah berikut: if ( kapalUser.isTertembak() ) throw new KapalMeledak("Anda Tertembak!", kapalUser, xLok, yLok);

Ingat bahwa kondisi objek KapalMeledak mungkin bukan suatu kesalahan. Mungkin hanya merupakan jalan lain dari alur suatu game. Pengecualian bisa juga digunakan sebagai percabangan besar seperti ini dengan cara yang lebih rapi. Kelas dan Subrutin Pengecualian Kemungkinan untuk melempar pengecualian akan berguna dalam penulisan subrutin dan kelas umum yang digunakan oleh lebih dari satu program. Dalam hal ini orang yang menulis subrutin atau kelas tersebut tidak memiliki cara yang umum untuk menangani

kesalahan tersebut. Terutama karena ia tidak tahu bagaimana subrutin atau kelas tersebut akan digunakan. Dalam kondisi seperti itu, programmer pemula biasanya lebih memilih untuk mencetak pesan kesalahan dan melanjutkan program, akan tetapi cara ini tidak memuaskan karena mungkin akan ada masalah di kemudian hari. Mencetak pesan kesalahan dan menghentikan program juga bukan solusi karena program tidak berkesempatan untuk mengatasi kesalahan tersebut. Program yang memanggil subrutin atau menggunakan kelas tersebut perlu tahu bahwa suatu kesalahan telah terjadi. Dalam bahasa yang tidak memiliki pengecualian, satusatunya alternatif adalah mengembalikan nilai khusus atau mengeset nilai variabel tertentu untuk memberi tahu bahwa suatu kesalahan telah terjadi. Misalnya, fungsi ambilDouble() bisa saja mengembalikan nilai NaN jika input dari user salah. Akan tetapi, cara ini hanya efektif jika program utama mengecek nilai keluarannya. Pengecualian akan lebih rapi jika suatu subrutin memiliki cara untuk tahu apabila suatu kesalahan telah terjadi. Asersi Ingat bahwa kondisi awal adalah kondisi yang harus benar pada suatu titik di dalam program sehingga program akan berjalan benar dari titik tersebut dan seterusnya. Dalam hal ini, ada kemungkin bahwa suatu kondisi awal mungkin tidak bisa dipenuhi. Untuk itu, akan lebih baik jika kita letakkan pernyataan if untuk mengujinya. Pertanyaan berikutnya adalah apa yang harus kita lalukan jika kondisi awal tidak benar? Salah satunya adalah melempar pengecualian, yang kemudian akan menghentikan program kecuali jika pengecualian tersebut ditangkap dan ditangani di tempat lain. Bahasa pemrograman seperti C dan C++ memiliki fasilitas untuk menambah asersi (assertions) dalam program. Asersi dapat berbentuk assert(kondisi), di mana kondisi adalah ekspresi bernilai boolean. Kondisi adalah suatu kondisi awal yang harus benar pada satu titik di dalam program. Ketika komputer menemukan asersi dalam eksekusi suatu program, ia akan mengevaluasi kondisi tersebut. Jika kondisi tersebut salah, maka program akan berhenti. Jika benar, maka program akan terus berjalan. Asersi dalam bentuk ini tidak tersedia pada Java, akan tetapi sesuatu yang mirip seperti ini bisa dilakukan dengan pengecualian. Bentuk asersi assert(kondisi) dapat diganti dalam bahasa Java dalam bentuk : if (kondisi == false) throw new IllegalArgumentException("Asersi gagal.");

Kita bisa mengganti pesan kesalahan dengan pesan yang lebih baik, dan mungkin akan lebih cantik apabila kelas pengecualiannya juga diganti dengan kelas yang lebih spesifik.

Asersi sangat umum digunakan dalam pengujian dan debugging. Setelah kita merilis program kita, kita tidak ingin program kita crash. Akan tetapi banyak program yang dibuat pada dasarnya seperti try { . .

// Jalankan program

. } catch (Exception e) { System.out.println("Pengecualian dalam program terjadi."); System.out.println("Harap kirimkan pesan bug kepada programmernya."); System.out.println("Detail kesalahan:"): e.printStackTrace(); }

Jika suatu program memiliki banyak asersi, maka akan menyebabkan program lebih lambat. Salah satu keuntungan asersi pada C dan C++ adalah asersi bisa "dimatikan". Dalam arti jika program dikompilasi dengan cara lain, maka asersi akan dibuang dari dalam program utama. Versi rilis dari program dikompilasi dengan asersi yang dimatikan. Dengan cara ini versi rilis akan lebih efisien, karena komputer tidak perlu mengevaluasi semua asersi tersebut. Keuntungan lainnya adalah kita tidak perlu membuang asersi tersebut dari kode sumber programnya. Ada cara seperti ini yang mungkin juga bisa diterapkan pada Java, yang tergantung dari seberapa canggih kompiler kita. Misalnya kita tentukan suatu konstanta static final boolean DEBUG = true;

dan kita menulis asersi seperti if

(DEBUG

==

true &&

kondisi

<span style="color:

#00bb00;">==

false) throw new IllegalArgumentException("Asersi Gagal.");

Karena DEBUG bernilai true, maka nilai "DEBUG == true && kondisi == false" sama dengan nilai kondisi, sehingga pernyataan if ini sama dengan pengujian suatu kondisi awal. Sekarang misalnya kita telah selesai melakukan debugging. Sebelum kita mengkompilasi versi rilis suatu program, kita ganti definisi DEBUG menjadi static final boolean DEBUG = false;

Sekarang, nilai "DEBUG == true && kondisi == false" selalu bernilai false, dan kompiler canggih akan bisa mendeteksi ini pada saat kompilasi. Karena nilai if ini akan selalu bernilai false, kompiler canggih akan mengabaikan perintah ini dalam hasil

kompilasinya, karena if ini tidak akan pernah dieksekusi. Hasilnya, kode ini tidak akan dimasukkan ke dalam versi rilis program. Dan kita hanya cukup mengganti satu baris saja pada kode sumbernya. Bab VIII - Pengenalan Struktur Data dan Algoritma Komputer bisa menjadi canggih seperti sekarang karena struktur data. Struktur dala adalah koleksi dari suatu data yang saling berhubungan. Suatu objek adalah struktur data, tapi tipe struktur data seperti ini -- yang memiliki sedikit variabel instansi -- hanya awalnya saja. Dalam banyak hal, programmer akan membuat struktur data kompleksnya sendiri, yaitu dengan menghubungkan objek satu sama lain. Bab ini akan membahas tentang array dan beberapa struktur data dalam Java. Array Array adalah struktur data yang terdiri dari item berurutan, di mana semua itemnya bertipe sama. Dalam Java, item dalam array selalu dinomori dari nol hingga nilai maksimum tertentu, yang nilainya ditentukan pada saat array tersebut dibuat. Misalnya, suatu array berisi 100 bilangan bulat, yang dinomori dari nol hingga 99. Item dalam array bisa bertipe salah satu tipe Java primitif. Item-item ini bisa juga berupa referensi ke objek, sehingga, misalnya kita bisa membuat array yang berisi semua komponen dalam applet. Bagian ini akan membahas bagaimana array dibuat dan digunakan pada Java. Juga mencakup kelas standar java.util.ArrayList. Suatu objek bertipe ArrayList sangat mirip dengan array dari Object, akan tetapi ia bisa bertambah ukuran secara dinamis. Membuat dan Menggunakan Array Jika sekumpulan data digabungkan dalam satu unit, hasilnya adalah suatu struktur data. Data struktur dapat berupa struktur yang sangat kompleks, akan tetapi dalam banyak aplikasi, data struktur yang cocok hanya terdiri dari kumpulan data berurutan. Struktur data sederhana seperti ini bisa berupa array atau record. Istilah "record" sebetulnya tidak digunakan pada Java. Suatu record pada intinya mirip dengan objek pada Java yang hanya memiliki variabel instansi tanpa metode instansi. Beberapa bahasa pemrograman lain yang tidak mendukung objek biasanya mendukung record. Dalam bahasa C yang bukan bahasa berorientasi objek, misalnya, memiliki tipe data record, dimana pada C disebut "struct". Data pada record -- dalam Java, adalah variabel instansi suatu objek -- disebut field suatu record. Masing-masing item disebut nama field. Dalam Java, nama field adalah nama variabel instansi. Perbedaan sifat dari suatu record adalah bahwa item pada record dipanggil berdasarkan namanya, dan field yang berbeda dapat berupa tipe yang berbeda. Misalnya, kelas Orang didefisikan sebagai :

class Orang { String nama; int nomorID; Date tanggalLahir; int umur; }

maka objek dari kelas Orang bisa disebut juga sebagai record dengan 4 field. Nama fieldnya adalah nama, nomorID, tanggalLahir dan umur. Lihat bahwa tipe datanya berbeda-beda yaitu String, int, dan Date. Karena record hanya merupakan bagian lebih kecil dari objek, kita tidak akan bahas lebih lanjut di sini. Seperti record, suatu array adalah kumpulan item. Akan tetapi, item pada record dipanggil dengan nama, sedangkan item pada array dinomori, dan masing-masing item dipanggil besarkan nomor posisi pada array tersebut. Semua item pada array harus bertipe sama. Definisi suatu array adalah : kumpulan item bernomor yang semuanya bertipe sama. Jumlah item dalam suatu array disebut panjang array. Nomor posisi dari array disebut indeks item tersebut dalam array. Tipe dari item tersebut disebut tipe dasar dari array. Tipe dasar suatu array bisa berupa tipe Java apa saja, baik berupa tipe primitif, nama kelas, atau nama interface. Jika tipe dasar suatu array adalah int, maka array tersebut disebut "array int". Suatu array bertipe String disebut "array String". Akan tetapi array bukan urutan int atau urutan String atau urutan nilai bertipe apapun. Lebih baik jika array adalah urutan variabel bertipe int atau String atau tipe lainnya. Seperti biasa, ada dua kemungkinan kegunaan variabel : sebagai nama suatu lokasi di memori, dan nama suatu nilai yang disimpan pada lokasi memori. Setiap posisi pada array bersifat seperti variabel. Setiap posisi dapat menyimpan nilai dengan tipe tertentu (yaitu tipe dasar array). Isinya bisa diganti kapanpun. Nilai tersebut disimpan di dalam array. Array merupakan kontainer bukan kumpulan nilai. Item pada array (maksudnya setiap anggota variabel dalam array tersebut) sering juga disebut elemen array. Dalam Java, elemen array selalu dinomori mulai dari nol. Yaitu, indeks dari elemen pertama suatu array adalah nol. Jika panjang array adalah N, maka indeks elemen terakhir adalah N-1. Sekali array dibuat, maka panjangnya tidak bisa diubah lagi. Dalam Java, array adalah objek. Ada beberapa konsekuensi yang lahir dari fakta ini. Array harus dibuat dengan operator new. Variabel tidak bisa menyimpan array; variabel hanya bisa merujuk pada array. Variabel lain yang bisa merujuk array juga bisa bernilai null

yang berarti ia tidak merujuk pada lokasi memori apapun. Seperti objek lain, array juga bagian dari suatu kelas, di mana seperti kelas lain adalah kelas turunan dari kelas Object. Elemen array pada dasarnya adalah variabel instansi dalam objek array, kecuali mereka dipanggil dalam indeksnya bukan namanya. Meskipun array berupa objek, ada beberapa perbedaan antara array dan objek lainnya, dan ada beberapa fitur khusus Java untuk membuat dan menggunakan array. Misalnya A adalah variabel yang merujuk pada suatu array. Maka indeks k di dalam A bisa dipanggil dengan A[k]. Item pertama adalah A[0], yang kedua adalah A[i], dan seterusnya. A[k]

adalah suatu variabel dan bisa digunakan seperti variabel lainnya. Kita bisa

memberinya nilai, bisa menggunakannya dalam ekspresi, dan bisa diberikan sebagai parameter pada subrutin. Semuanya akan didiskusikan di bawah nanti. Untuk sekarang ingat sintaks berikut variabel_array [ekspresi_integer]

untuk merujuk pada suatu array. Meskipun setiap array merupakan suatu objek, kelas array tidak harus didefinisikan sebelumnya. Jika suatu tipe telah ada, maka kelas array dari tipe tersebut otomatis ada. Jika nama suatu tipe adalah TipeDasar, maka nama kelas arraynya adalah TipeDasar[]. Artinya, suatu objek yang diciptakan dari kelas TipeDasar[] adalah array dari item yang tiap itemnya bertipe TipeDasar. Tanda kurung "[]" dimaksudkan untuk mengingat sintaks untuk mengambil item di dalam suatu array. "TipeDasar[]" dibaca seperti "array TipeDasar". Mungkin perlu juga dijelaskan bahwa jika KelasA adalah kelas turunan dari KelasB

maka KelasA[] otomatis menjadi kelas turunan KelasB[].

Tipe dasar suatu array dapat berupa tipe apapun yang ada atau sudah didefinisikan pada Java. Misalnya tipe primitif int akan diturunkan kelas array int[]. Setiap elemen di dalam array int[] adalah variabel yang memiliki tipe int dan bisa diisi dengan nilai dengan tipe int. Dari kelas yang bernama String diturunkan tipe array String[]. Setiap elemen di dalam array String[] adalah variabel dengan tipe String, yang bisa diisi dengan nilai bertipe String. Nilai ini bisa null atau referensi ke objek yang bertipe String

(dan juga kelas turunan dari String)

Mari kita lihat contoh lebih konkrotnya menggunakan array bilangan bulat sebagai contoh pertama kita. Karena int[] adalah sebuah kelas, maka kita bisa menggunakannya untuk mendeklarasikan variabel. Misalnya, int[] daftar;

yang membuat variabel bernama daftar dengan tipe int[]. Variabel ini bisa menunjuk pada array int, akan tetapi nilai awalnya adalah null (jika merupakan variabel anggota suatu kelas) atau tak tentu (jika merupakan variabel lokal di dalam suatu metode). Operator new

digunakan untuk membuat objek array baru, ayng kemudian bisa diberikan kepada

daftar.

Sintaksnya sama seperti sintaks sebelumnya, yaitu :

daftar = new int[5];

membuat array 5 buah integer. Lebih umum lagi, konstruktor "new TipeDasar[N]" digunakan untuk membuat array bertipe TipeDasar[]. Nilai N di dalam kurung menyatakan panjang array, atau jumlah elemen yang bisa ditampung. Panjang array adalah variabel instansi di dalam objek array, sehingga array tahu berapa panjangnya. Kita bisa mendapatkan panjang suatu array, misalnya daftar menggunakan daftar.length (akan tetapi kita tidak bisa mengubahnya) Hasil dari pernyataan "daftar = new int[5];" dapat diilustrasikan sebagai berikut

Perlu dicatat bahwa array integer secara otomatis diisi dengan nol. Dalam Java, array yang baru dibuat akan selalu diisi dengan nilai tertentu: nol untuk angka, false untuk boolean, karakter dengan nilai Unicode 0 untuk char dan null untuk objek. Elemen di dalam array daftar dapat dirujuk dengan daftar[0], daftar[1], daftar[2], daftar[3],

dan daftar[4] (ingat juga bahwa nilai indeks terbesar adalah panjangnya

array dikurang satu). Akan tetapi, referensi array sebetulnya lebih umum lagi. Tanda kurung di dalam referensi array bisa berisi ekspresi apapun yang nilainya suatu integer. Misalnya

jika

idks

daftar[2*idks+3]

adalah

variabel

bertipe

int,

maka

daftar[idks]

secara sintaks benar.

Contoh berikut akan mencetak semua isi integer di dalam array daftar ke layar : for (int i = 0; i < daftar.length; i++) { System.out.println( daftar[i] );

dan

}

Perulangan pertama adalah ketika i = 0, dan daftar[i] merujuk pada daftar[0]. Jadi nilai yang disimpan pada variabel daftar[0] akan dicetak ke layar. Perulangan kedua adalah i = 1, sehingga nilai daftar[i] dicetak. Perulangan berhenti setelah mencetak daftar[4]

dan i menjadi sama dengan 5, sehingga kondisi lanjutan "i

daftar.length"

<

tidak lagi benar. Ini adalah contoh umum dari menggunakan perulangan

untuk mengolah suatu array. Penggunaan suatu variabel dalam suatu program menyatakan lokasi di memori. Pikirkan sesaat tentang apa yang akan komputer lakukan ketika ia menemukan referensi ke elemen suatu array daftar[k] ketika program berjalan. Komputer harus menentukan lokasi memori di mana ia dijadikan referensi. Untuk komputer, daftar[k] berarti : "Ambil pointer yang disimpan di dalam variabel daftar. Ikuti pointer ini untuk mencari objek array. Ambil nilai k. Pergi ke posisi ke-k dari array tersebut, dan di sanalah alamat memori yang Anda ingin." Ada dua hal yang bisa salah di sini. Misalnya nilai daftar adalah null. Dalam kasus ini, maka daftar tidak memiliki referensi sama sekali. Percobaan merujuk suatu elemen pada suatu array kosong adalah suatu kesalahan. Kasus ini akan menampilkan pesan kesalahan "pointer kosong". Kemungkinan kesalahan kedua adalah jika daftar merujuk pada suatu array, akan tetapi k berada di luar rentang indeks yang legal. Ini akan terjadi jika k < 0 atau jika k >= daftar.length. Kasus ini disebut kesalahan "indeks array keluar batas". Ketika kita menggunakan array dalam program, kita harus selalu ingat bahwa kedua kesalahan tersebut mungkin terjadi. Dari kedua kasus di atas, kesalahan indeks array keluar batas adalah kesalahan yang lebih sering terjadi. Untuk suatu variabel array, seperti variabel lainnya, kita bisa mendeklarasikan dan mengisinya dengan satu langkah sekaligus, misalnya : int[] daftar = new int[5];

Jika daftar merupakan variabel lokal dalam subrutin, maka perintah di atas akan persis sama dengan dua perintah : int[] daftar; daftar = new int[5];

(Jika daftar adalah variabel instansi, tentukan kita tidak bisa mengganti "int[] daftar = new int[5];"

dengan "int[] daftar; daftar = new int[5];" karena ini hanya

bisa dilakukan di dalam subrutin)

Array yang baru dibuat akan diisi dengan nilai awal yang tergantung dari tipe dasar array tersebut seperti dijelaskan sebelumnya. Akan tetapi Java juga menyediakan cara untuk memberi isi array baru dengan daftar isinya. Dalam pernyataan yang untuk membuat array, ini bisa dilakukan dengan menggunakan penginisialiasi array (array initializer), misalny : int[] daftar = { 1, 4, 9, 16, 25, 36, 49 };

akan membuat array baru yang berisi 7 nilai, yaitu 1, 4, 9, 16, 25, 36, dan 49, dan mengisi daftar

dengan referensi ke array baru tersebut. Nilai daftar[0] berisi 1, nilai daftar[1]

berisi 4, dan seterusnya. Panjang daftar adalah 7, karena kita memberikan 7 nilai awal kepada array ini. Suatu penginisialisasi array memiliki bentuk daftar angka yang dipisahkan dengan koma dan diapit dengan tanda kurung kurawal {}. Panjang array tersebut tidak perlu diberikan, karena secara implisit sudah bisa ditentukan dari jumlah daftar angkanya. Elemen di dalam penginisialisasi array tidak harus selalu berbentuk konstanta. Juga bisa merupakan variabel atau ekspresi apa saja, asalkan nilainya bertipe sama dengan tipe dasar array tersebut. Misalnya, deklarasi berikut membuat array dari delapan jenis Color beberapa warna telah dibentuk dengan ekspresi "new Color(r,g,b);" Color[] palette = { Color.black, Color.red, Color.pink, new Color(0,180,0),

// hijau gelap

Color.green, Color.blue, new Color(180,180,255),

// biru muda

Color.white };

Inisialisasi array bentuk seperti ini hanya bisa digunakan dalam deklarasi suatu variabel baru, akan tetapi tidak bisa digunakan seperti operator pemberi nilai (=) di tengah-tengah suatu program. Akan tetapi ada cara lain yang bisa digunakan sebagai pernyataan pemberian nilai atau diberikan ke dalam subrutin. Yaitu menggunakan jenis lain dari operator new untuk membuat atau menginisialisasi objek array baru. (Cara ini agak kaku dengan sintaks aneh, seperti halnya sintaks kelas anonim yang telah didiskusikan sebelumnya). Misalnya untuk memberi nilai kepada suatu variabel daftar, kita bisa menggunakan : daftar = new int[] { 1, 8, 27, 64, 125, 216, 343 };

Sintaks umum dari bentuk operator new seperti ini adalah new TipeDasar [ ] { daftar_nilai_nilai }

Ini adalah suatu ekspresi yang isinya merupakan objek, dan bisa digunakan untuk banyak situasi di mana suatu objek dengan tipe TipeDasar dipentingkan. Misalnya buatTombol merupakan metode yang mengambil array String sebagai parameter, maka kita bisa menuliskan buatTombol( new String[] { "Stop", "Jalan", "Berikut", "Sebelum" } );

Catatan terakhir : untuk alasan sejarah, maka deklarasi int[] daftar;

akan bernilai sama dengan int daftar[];

di mana sintaks tersebut digunakan dalam bahasa C dan C++. Akan tetapi sintaks alternatif ini tidak begitu masuk akan dalam Java, atau mungkin lebih baik dihindari. Lagian, maksudnya adalah mendeklarasikan variabel dengan tipe tertentu dan namanya adalah int[].

Akan lebih masuk akan untuk mengikuti siintaks "nama_tipe nama_variabel"

seperti pada bentuk bertama. Pemrograman dengan Array Array merupakan jenis struktur data yang sangat dasar dan sangat penting. Teknik pengolahan array merupakan teknik pemrograman yang paling penting yang kita harus kuasai. Dua jenis teknik pengolahan array -- pencarian dan pengurutan -- akan dibahas kemudian. Bagian ini akan memperkenalkan beberapa ide dasar pengolahan array secara umum. Dalam banyak hal, pengolahan array berarti menggunakan operasi yang sama kepada setiap elemen di dalam array. Biasanya sering dilakukan dengan perulangan for. Perulangan untuk mengolah semua elemen dalam array A dapat ditulis dalam bentuk : // lakukan inisialiasi yang diperlukan sebelumnya for (int i = 0; i < A.length; i++) { . . . // proses A[i] }

Misalnya, A adalah array dengan tipe double[]. Misalnya kita ingin menjumlah semua nilai dalam array tersebut. Algoritma umum untuk melakukannya adalah : Mulai dengan 0; Tambah A[0];

(proses elemen pertama di dalam A)

Tambah A[1];

(proses elemen kedua di dalam A)

. .

. Tambah A[ A.length - 1 ];

(proses elemen terakhir di dalam A)

Dengan menggunakan pengetahuan yang kita telah pelajari tentang perulangan, kita bisa ubah algoritma di atas menjadi bentuk perulangan for seperti berikut: double jumlah;

// Jumlah nilai di dalam A

jumlah

// Mulai dengan 0

= 0;

for (int i = 0; i < A.length; i++) jumlah += A[i];

// tambah A[i] ke dalam jumlah untuk i = 0, 1, ...,

A.length - 1

Lihat bahwa kondisi kelanjutan "i < A.length" menyatakan bahwa nilai i terakhir yang akan diolah adalah A.length - 1 yaitu elemen terakhir dalam array. Ingat bahwa kita menggunakan "<" bukan "<=" karena dengan "<=" komputer akan memberikan kesalahan indeks di luar batas. Pada akhirnya, nanti Anda akan bisa membuat perulangan seperti di atas di luar kepala. Kita akan lihat beberapa contohnya. Di sini perulangan akan menghitung banyaknya elemen di dalam array A yang nilainya kurang dari nol : int hitung;

// Untuk menghitung elemen

hitung = 0;

// Mulai dengan nol

for (int i = 0; i < A.length; i++) { if (A[i] < 0.0)

// Jika elemen ini kurang dari nol

hitung++;

// tambah hitung dengan 1

} // Di sini nilai "hitung" adalah banyaknya elemen yang kurang dari 0.

Kita bisa mengganti "A[i] < 0.0" jika kita ingin menghitung banyaknya elemen di dalam array yang memiliki sifat tertentu. Variasinya akan memiliki tema yang sama. Misalnya kita ingin menghitung banyaknya elemen di dalam array A yang sama dengan elemen sesudahnya. Elemen setelah A[i] adalah A[i+1], sehingga kita bisa mengganti klausa if dengan "if (A[i] == A[i+1])". Akan tetapi tunggu dulu : Tes ini tidak bisa digunakan apabila A[i] adalah elemen terakhir dalam array, karena tidak ada lagi array sesudahnya. Komputer akan menolak pernyataan ini. Sehingga kita harus berhenti satu elemen sebelum array terakhir, sehingga menjadi int hitung = 0; // lihat kondisi for berubah dibandingkan dengan contoh sebelumnya for (int i = 0; i < A.length - 1; i++) { if (A[i] == A[i+1]) hitung++; }

Masalah umum lainnya adalah mencari nilai terbesar di dalam array A. Strateginya adalah lihat semua isi array, catat nilai terbesar saat itu. Kita akan simpan nilai terbesar yang kita temui dalam variabel maks. Pada saat kita melihat elemen array satu per satu, kapanpun kita melihat nilai elemen tersebut lebih besar dari maks kita akan mengganti nilai maks dengan nilai yang lebih besar tersebut. Setelah semua elemen array diproses, maka maks merupakan nilai elemen terbesar di dalam array tersebut. Pertanyaannya adalah, apa nilai awal maks? Salah satu kemungkinannya adalah mulai dengan nilai maks sama dengan A[0],

baru kemudian melihat isi elemen array lainnya mulai dengan A[1]. Misalnya,

double maks = A[0];

// nilai maks berisi elemen array pertama

for (int i = 1; i < A.length; i++) {

// i mulai dari elemen kedua

if (A[i] > maks) max = A[i]; } // Di sini maks berisi nilai elemen array yang paling besar

(Ada masalah yang lebih penting di sini. Java membolehkan array memiliki panjang nol. Artinya bahkan A[0] pun tidak ada di dalam array, sehingga memanggil A[0] akan menghasilkan kesalahan indeks keluar batas. Akan tetapi array biasanya array dengan panjang nol biasanya sesuatu yang kita ingin hindarkan dalam kehidupan sehari-hari. Lagian apa artinya mencari nilai terbesar di dalam suatu array yang panjangnya nol?) Contoh terakhir dari operasi array, misalnya kita ingin mengkopi suatu array. Untuk mengkopi array A, tidak cukup untuk menggunakan perintah double[] B = A;

karena perintah ini tidak membuat objek array baru. Yang dibuat di sini adalah variabel baru yang merujuk pada objek yang sama dengan A. (Sehingga perubahan yang terjadi pada A[i] akan juga menyebabkan B[i] berubah). Untuk membuat array baru yang merupakan kopi dari array A, kita harus membuat objek array baru, dan mengkopi isinya satu per satu dari array A ke array baru, sehingga // Buat objek array baru, yang panjangnya sama dengan panjang A double[] B = new double[A.length]; for (int i = 0; i < A.length; i++) B[i] = A[i];

// Kopi setiap elemen dari A ke B

Mengkopi nilai dari satu array ke array yang lain adalah operasi umum sehingga Java memiliki subrutin untuk melakukannya, yaitu System.arraycopy(), yang merupakan subrutin anggota statik dari kelas standar System. Deklarasinya memiliki bentuk seperti : public static void arraycopy(Object arraySumber, int indeksAwalSumber,

Object arrayTujuan, int indeksAwalTujuan, int jumlah)

di mana arraySumber dan arrayTujuan bisa berbentuk array dengan tipe apapun. Nilai akan dikopi dari arraySumber ke arrayTujuan. jumlah adalah berapa banyak elemen yang

akan

dikopi.

dan

indeksAwalSumber indeksAwalTujuan.

Nilai

akan

akan

dikopi

dari

arraySumber

mulai

dari

posisi

disimpan

pada

arrayTujuan

mulai

dari

posisi

Misalnya kita akan mengkopi array A, maka kita bisa menggunakan

perintah double B = new double[A.length]; System.arraycopy( A, 0, B, 0, A.length );

Suatu tipe array, misalnya double[] adalah tipe Java biasa, sehingga kita bisa menggunakannya seperti tipe-tipe Java lainnya. Termasuk juga digunakan sebagai parameter formal di dalam suatu subrutin. Juga bisa digunakan sebagai tipe keluaran suatu fungsi. Misalnya, kita bisa menulis fungsi yang membuat kopi array dengan tipe double sebagai berikut : double[]

kopi( double[] sumber ) {

// Membuat dan mengembalikan kopi array sumber // Jika sumber null, maka kembalikan null if ( sumber == null ) return null; double[]

kpi;

// Kopi array sumber

kpi = new double[sumber.length]; System.arraycopy( sumber, 0, kpi, 0, sumber.length ); return kpi; }

Rutin main() memiliki parameter dengan tipe String[] yang merupakan array String. Ketika sistem memanggil rutin main(), string di dalam array ini adalah parameter dari baris perintah. Jika kita menggunakan konsol, user harus mengetikkan perintah untuk menjalankan program. User bisa menambahkan input tambahan dalam perintah ini setelah nama program yang akan dijalankan. Misalnya, jika kelas yang memiliki rutin main() bernama programKu, maka user bisa menjalankan kelas tersebut dengan perintah "java programKu" di konsol. Jika kita tulis dengan "java programKu satu dua tiga", maka parameter dari baris perintahnya adalah "satu", "dua", dan "tiga". Sistem akan memasukkan parameter-parameter ini ke dalam array String[] dan memberikan array ini pada rutin main().

Berikut ini adalah contoh program sederhana yang hanya mencetak parameter dari baris perintah yang dimasukkan oleh user. public class CLDemo { public static void main(String[] args) { System.out.println("Anda memasukkan " + args.length + " parameter dari baris perintah"); if (args.length > 0) { System.out.println("Parameter tersebut adaah :"); for (int i = 0; i < args.length; i++) System.out.println("

" + args[i]);

} } // akhir main() } // akhir kelas CLDemo

Perhatikan bahwa parameter args tidak mungkin null meskipun tidak ada parameter yang dimasukkan. Jika tidak ada parameter dari baris perintah yang dimasukkan, maka panjang array ini adalah nol. Hingga sekarang, contoh yang telah diberikan adalah bagaimana mengolah array dengan mengakses elemennya secara berurutan (sequential access). Artinya elemen-elemen array diproses satu per satu dalam urutan dari awal hingga akhir. Akan tetapi salah satu keuntungan array adalah bahwa array bisa digunakan untuk mengakses elemennya secara acak, yaitu setiap elemen bisa diakses kapan saja secara langsung. Misalnya, kita ambil contoh suatu masalah yang disebut dengan masalah ulang tahun: Misalnya ada N orang di dalam suatu ruangan. Berapa kemungkinan dua orang di dalam ruangan tersebut memiliki ulang tahun yang sama (yang dilahirkan pada tanggal dan bulan yang sama, meskipun tahunnya berbeda)? Kebanyakan orang salah menerka jawabannya. Sekarang kita lihat dengan versi masalah yang berbeda: Misalnya kita memilih orang secara acak dan menanyakan ulang tahunnya. Berapa orang yang Anda harus tanya untuk mendapatkan hari ulang tahun yang sama dengan orang sebelumnya? Tentunya jawabannya akan tergantung pada faktor yang bersifat acak, akan tetapi kita bisa simulasikan dengan program komputer dan menjalankan beberapa kali hingga kita tahu berapa kira-kira orang harus dicek. Untuk mensimulasikan percobaan ini, kita harus mencatat semua ulang tahun yang kita sudah tanyakan. Ada 365 kemungkinan hari ulang tahun (Kita abaikan sementara tahun kabisat). Untuk setiap kemungkinan hari ulang tahun, kita perlu tahu, apakah hari ulang

tahun tersebut telah digunakan? Jawabannya adalah nilai boolean true atau false. Untuk menyimpan data ini, kita bisa gunakan array dari 365 nilai boolean: boolean[] sudahDitanya; sudahDitanya = new boolean[365];

Tanggal-tanggal pada satu tahun dinomori dari 0 hingga 364. Nilai sudahDitanya[i] akan bernilai true jika orang yang kita tanya berulang tahun pada hari tersebut. Pada awalnya semua nilai pada array sudahDitanya[i] bernilai false. Ketika kita memilih satu orang dan menanyakan hari ulang tahunnya, misalnya i, kita akan mengecek terlebih dahulu apakah sudahDitanya[i] bernilai true. Jika tidak maka orang ini adalah orang kedua dengan ulang tahun yang sama. Artinya kita sudah selesai. Jika sudahDitanya[i] bernilai false, maka belum ada orang sebelum ini yang memiliki hari ulang tahun tersebut. Kita akan ganti sudahDitanya[i] dengan true, kemudian kita akan tanyakan lagi kepada orang lain, dan begitu seterusnya hingga semua orang di dalam ruangan ditanyakan. static void masalahUlangTahun() { // Melakukan simulasi dengan memilih seseorang secara acak // dan mengecek hari ulang tahunnya. Jika hari ulang tahunnya // sama dengan orang yang pernah kita tanya sebelumnya, // hentikan program dan laporkan berapa orang yang sudah dicek boolean[] sudahDitanya; // Untuk mencatat ulang tahun yang sudah ditanyakan // Nilai true pada sudahDitanya[i] berarti orang lain // sudah ada yang berulang tahun pada hari i int hitung; // Jumlah orang yang sudah pernah ditanya sudahDitanya = new boolean[365]; // Awalnya, semua nilai adalah false hitung = 0; while (true) { // Ambil ulang tahun secara acak dari 0 hingga 364 // Jika ulang tahun telah ditanya sebelumnya, keluar // Jika tidak catat dalam array

int ultah;

// Ulang tahun seseorang

ultah = (int)(Math.random()*365); hitung++; if ( sudahDitanya[ultah] ) break; sudahDitanya[ultah] = true; } System.out.println("Ulang

tahun

yang

sama

ditemukan

setelah

menanyakan " + hitung + " orang."); } // akhir masalahUlangTahun()

Subrutin ini menggunakan fakta bahwa array boolean yang baru dibuat memiliki seluruh elemen yang bernilai false. Jika kita ingin menggunakan array yang sama untuk simulasi kedua, kita harus mereset ulang semua elemen di dalamnya menjadi false kembali dengan perulangan for for (int i = 0; i < 365; i++) sudahDitanya[i] = false;

Array paralel adalah menggunakan beberapa array dengan indeks yang sama. Misalnya kita ingin membuat beberapa kolom secara paralel -- array x di kolom pertama, array y di kolom kedua, array warna di kolom ketiga, dan seterusnya. Data untuk baris ke-i bisa didapatkan dari masing-masing array ini. Tidak ada yang salah dengan cara ini, akan tetapi cara ini berlawanan dengan filosofi berorientasi objek yang mengumpulkan data yang berhubungan di dalam satu objek. Jika kita mengikuti aturan seperti ini, amaka kita tidak harus membayangkan hubungan data yang satu dan yang lainnya karena semua data akan dikelompokkan di dalam satu tempat. Misalnya saya menulis kelas seperti class DataString { // Data dari salah satu pesan int x,y;

// Posisi pesan

Color warna;

// Warna pesan

}

Untuk menyimpan data dalam beberapa pesan, kita bisa menggunakan array bertipe DataString[],

sehingga

yang kemudian dideklarasikan sebagai variabel instansi dengan nama data

DataString[] data;

Isi dari data bernilai null hingga kita membuat array baru, misalnya dengan data = new DataString[JUMLAH_PESAN];

Setelah array ini dibuat, nilai setiap elemen array adalah null. Kita ingin menyimpan data di dalam objek yang bertipe DataString, akan tetapi tidak ada objek yang dibuat. Yang kita sudah buat hanyalah kontainernya saja. Elemen di dalamnya berupa objek yang belum pernah kita buat. Untuk itu elemen di dalamnya bisa kita buat dengan perulangan for seperti : for (int i = 0; i < JUMLAH_PESAN; i++) data[i] = new DataString();

Sekarang kita bisa mengambil data setiap pesan dengan data[i].x, data[i].y, dan data[i].warna.

Terakhir berkaitan dengan pernyataan switch. Misalnya kita memiliki nilai bulan dari 0 hingga 11, yang melambangkan bulan dalam satu tahun dari Januari hingga Desember. Kita ingin mencetaknya di layar, dengan perintah switch (bulan) { case 0: bulanString = "Januari"; break; case 1: bulanString = "Februari"; break; case 2: bulanString = "Maret"; break; case 3: bulanString = "April"; break; . . . case 11: bulanString = "Desember"; break; default: bulanString = "Salah bulan"; }

Kita bisa mengganti keseluruhan perintah switch tersebut dengan menggunakan array, misalnya dengan array namaBulan yang dideklarasikan sebagai berikut : static String[] namaBulan = { "Januari", "Februari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember" };

Kemudian kita bisa ganti keseluruhan switch di atas dengan bulanString = namaBulan[bulan];

Sangat mudah bukan? Array Dinamis Panjang suatu array tidak bisa diubah setelah dibuat. Akan tetapi, sering kali jumlah data yang disimpan dalam array bisa berubah setiap saat. Misalnya dalam contoh berikut : Suatu array menyimpan baris teks dalam program pengolah kata. Atau suatu array yang menyimpan daftar komputer yang sedang mengakses halaman suatu website. Atau array yang berisi gambar yang ditambahkan user oleh program gambar. Di sini jelas, bahwa kita butuh sesuatu yang bisa menyimpan data di mana jumlahnya tidak tetap. Array Setengah Penuh Bayangkan suatu aplikasi di mana sejumlah item yang ingin kita simpan di dalam array akan berubah-ubah sepanjang program tersebut berjalan. Karena ukuran array tidak bisa diubah, maka variabel terpisah digunakan untuk menyimpan berapa banyak sisa tempat kosong yang masih bisa diisi di dalam array. Bayangkan misalnya, suatu program yang membaca bilangan bulat positif dari user, kemudian menyimpannya untuk diproses kemudian. Program akan berhenti membaca input apabila input yang diterima bernilai 0 atau kurang dari nol. Bilangan input n tersebut kita simpa di dalam array bilangan dengan tipe int[]. Katakan banyaknya bilangan yang bisa disimpan tidak lebih dari 100 buah. Maka ukuran array bisa dibuat 100. Akan tetapi program tersebut harus melacak berapa banyak bilangan yang sudah diambil dari user. Kita gunakan variabel terpisah bernama jmlBilangan. Setiap kali suatu bilangan disimpan di dalam array, nilai jmlBilangan akan bertambah satu. Sebagai contoh sederhana, masi kita buat program yang mengambil bilangan yang diinput dari user, kemudian mencetak bilangan-bilangan tersebut dalam urutan terbalik. (Ini adalah contoh pengolahan yang membutuhkan array, karena semua bilangan harus disimpan pada suatu tempat. Banyak lagi contoh program misalnya, mencari jumlah atau rata-rata atau nilai maksimum beberapa bilangan, bisa dilakukan tanpa menyimpan bilangan tersebut satu per satu)

public class BalikBilanganInput { public static void main(String[] args) { int[] bilangan;

// Array untuk menyimpan nilai input dari user

int jmlBilangan;

// Banyaknya bilangan yang sudah disimpan

dalam array int bil;

// Bilangan yang diambil dari user

bilangan = new int[100];

// Buat array dengan 100 bilangan int

jmlBilangan = 0;

// Belum ada bilangan yang

disimpan System.out.println("Masukkan

bilangan

bulat

positif

(paling

banyak 100 bilangan)" + ", masukkan nol untuk mengakhiri."); while (true) { System.out.print("? "); bil = KonsolIO.ambilInt(); if (bil <= 0) break; bilangan[jmlBilangan] = bil; jmlBilangan++; } System.out.println("\nBilangan

yang Anda masukkan

dalam

urutan

terbalik adalah :\n"); for (int i = jmlBilangan - 1; i >= 0; i--) { System.out.println( bilangan[i] ); } } // akhir main(); }

// akhir kelas BalikBilanganInput

Penting untuk diingat bahwa jmlBilangan memiliki dua peran. Yang pertama, adalah melacak banyaknya bilangan yang sudah dimasukkan di dalam array. Yang kedua adalah menentukan di mana indeks kosong berikutnya di dalam array. Misalnya, jika 4 bilangan

sudah dimasukkan ke dalam array, maka bilangan-bilangan tersebut diisi pada array di posisi 0, 1, 2, dan 3. Maka posisi kosong berikutnya adalah posisi 4. Ketika kita akan mencetak angka di dalam array, maka poisisi penuh berikutnya adalah di lokasi jmlBilangan - 1, sehingga perulangan for mencetak bilangan dari jmlBilangan - 1

hingga 0.

Mari kita lihat contoh lain yang lebih realistis. Misalkan kita ingin menulis program game, di mana pemain bisa masuk ke dalam game dan keluar dari game setiap saat. Sebagai programmer berorientasi objek yang baik, mungkin kita memiliki kelas bernama Pemain sebagai lambang pemain di dalam game. Daftar pemain yang sedang ada di dalam game, bisa disimpan di dalam array ArrayPemain dengan tipe Pemain[]. Karena jumlah pemain bisa berubah-ubah maka kita bisa menggunakan variabel bantu, misalnya jumlahPemainAktif untuk mencatat banyaknya pemain yang sedang aktif berada di dalam game. Misalnya jumlah maksimum pemain di dalam game adalah 10 orang, maka kita bisa mendeklarasikan variabelnya sebagai : Pemain[] ArrayPemain = new Pemain[10]; int jumlahPemainAktif = 0;

// Hingga 10 pemain.

// Di awal game, tidak ada pemain yang aktif

Setelah beberapa pemain masuk ke dalam game, variabel jumlahPemainAktif akan lebih dari 0, dan objek pemailn akan disimpan dalam array, misalnya ArrayPemain[0], ArrayPemain[1],

ArrayPemain[2],

ArrayPemain[jumlahPemainAktif]

dan

seterusnya.

Ingat

bahwa

pemain

tidak ada. Prosedur untuk menambah pemain baru,

secara sederhana : // Tambah pemain di tempat kosong ArrayPemain[jumlahPemainAktif] = pemainBaru; // And increment playerCt to count the new player. jumlahPemainAktif++;

Untuk menghapus seorang pemain mungkin sedikit lebih sulit karena kita tidak ingin meninggalkan lubang di tengah-tengah array. Misalnya kita ingin menghapus pemain pada indeks k pada ArrayPemain. Jika kita tidak peduli urutan pemainnya, maka salah satu caranya adalah memindahkan posisi pemain terakhir ke posisi pemain yang meninggalkan game, misalnya : ArrayPemain[k] = ArrayPemain[jumlahPemainAktif - 1]; jumlahPemainAktif--;

Pemain yang sebelumnya ada di posisi k, tidak lagi ada di dalam array. Pemain yang sebelumnya ada di posisi jumlahPemainAktif -1 sekarang ada di array sebanyak 2 kali. Akan tetapi sekarang ia berada di bagian yang valid, karena nilai jumlahPemainAktif kita

kurangi dengan satu. Ingat bahwa setiap elemen di dalam array harus menyimpan satu nilai, akan tetapi satu-satunya nilai dari posisi 0 hingga jumlahPemainAktif - 1 akan tetap diproses seperti biasa. Misalnya kita ingin menghapus pemain di posisi k, akan tetapi kita ingin agar urutan pemain tetap sama. Untuk melakukannya, semua pemain di posisi k+1 ke atas harus dipindahkan satu posisi ke bawah. Pemain k+ mengganti pemain k yang keluar dari game. Pemain k+2 mengganti pemain yang pindah sebelumnya, dan berikutnya. Kodenya bisa dibuat seperti for (int i = k+1; i < jumlahPemainAktif; i++) { ArrayPemain[i-1] = ArrayPemain[i]; } jumlahPemainAktif--;

Perlu ditekankan bahwa contoh Pemain di atas memiliki tipe dasar suatu kelas. Elemennya bisa bernilai null atau referensi ke suatu objek yang bertipe Pemain, Objek Pemain sendiri tidak disimpan di dalam array, hanya referensinya saja yang disimpan di sana. Karena aturan pemberian nilai pada Java, objek tersebut bisa saja berupa kelas turunan dari Pemain,

sehingga mungkin juga array tersebut menyimpan beberapa jenis Pemain

misalnya pemain komputer, pemain manusia, atau pemain lainnya, yang semuanya adalah kelas turunan dari Pemain. Contoh lainnya, misalnya kelas BentukGeometri menggambarkan suatu bentuk geometri yang bisa digambar pada layar, dan ia memiliki kelas-kelas turunan yang merupakan bentuk-bentuk khusus, seperti garis, kotak, kotak bertepi bulat, oval, atau oval berisi warna, dan sebagainya. (BentukGeometri sendiri bisa berbentuk kelas abstrak, seperti didiskusikan sebelumnya). Kemudian array bertipe BentukGeometri[] bisa menyimpan referensi objek yang bertipe kelas turunan dari BentukGeometri. Misalnya, perhatikan contoh pernyataan berikut BentukGeometri[]

gambar

=

new

BentukGeometri[100];

//

Array

untuk

menyimpan 100 gambar. gambar[0] = new Kotak();

// Letakkan beberapa objek di dalam

array. gambar[1] = new Garis();

// (Program betulan akan menggunakan

beberapa gambar[2] = new OvalBerwarna(); int jmlGambar = 3;

// parameter di sini

// Lacak jumlah objek di dalam array

bisa diilustrasikan sebagai berikut.

Array tersebut bisa digunakan dalam program gambar. Array bisa digunakan untuk menampung gambar-gambar yang akan ditampilkan. Jika BentukGeometri memiliki metode "void gambarUlang(Graphics g)" untuk menggambar pada grafik g, maka semua grafik dalam array bisa digambar dengan perulangan sederhana for (int i = 0; i < jmlGambar; i++) gambar[i].gambarUlang(g);

Pernyataan "gambar[i].gambarUlang(g);" memanggil metode gambarUlang() yang dimiliki oleh masing-masing gambar pada indeks i di array tersebut. Setiap objek tahu bagaimana menggambar dirinya sendiri, sehingga perintah dalam perulangan tersebut sebetulnya melakukan tugas yang berbeda-beda tergantung pada objeknya. Ini adalah contoh dari polimorfisme dan pengolahan array. Array Dinamis Dalam contoh-contoh di atas, ada batas tententu dalam jumlah elemennya, yaitu 100 int, 100 Pemain, dan 100 BentukGeometris. Karena ukuran array tidak bisa berubah, array tersebut hanya bisa menampung maksimum sebanyak elemen yang didefinisikan pada pembuatan array. Dalam banyak kasus, adanya batas maksimum tersebut tidak diinginkan. Kenapa harus bekerja dengan hanya 100 bilangan bulat saja, bukan 101? Alternatif yang umum adalah membuat array yang sangat besar sehingga bisa digunakan untuk dalam kehidupan sehari-hari. Akan tetapi cara ini tidak baik, karena akan sangat banyak memori komputer yang terbuang karena tidak digunakan. Memori itu mungkin lebih baik digunakan untuk yang lain. Apalagi jika komputer yang akan digunakan tidak memiliki memori yang cukup untuk menjalankan program tersebut.

Tentu saja, cara yang lebih baik adalah apabila kita bisa mengubah ukuran array sesuka kita kapan saja. Ingat bahwa sebenarnya variabel array tidak menyimpan array yang sesungguhnya. Variabel ini hanya menyimpan referensi ke objek tersebut. Kita tidak bisa membuat array tersebut lebih besar, akan tetapi kita bisa membuat array baru yang lebih besar, kemudian mengubah isi variabel array tersebut ke array baru itu. Tentunya kita harus mengkopi semua isi di array yang lama ke array baru. Array lama akan diambil oleh pemulung memori, karena ia tidak lagi digunakan. Mari kita lihat kembali contoh game di atas, di mana ArrayPemain adalah array dengan tipe Pemain[] dan jumlahPemainAktif[/code] adalah jumlah pemain yang sudah digunakan array tersebut. Misalnya kita tidak ingin membuat limit banyaknya pemainnya yang bisa ikut main. Jika pemain baru masuk dan array tersebut sudah penuh, kita akan membuat array baru yang lebih besar. Variabel ArrayPemain akan merujuk pada array baru. Ingat bahwa setelah ini dilakukan, ArrayPemain[0]

akan menunjuk pada lokasi memori yang berbeda, akan tetapi nilai

ArrayPemain[0]

sama dengan sebelumnya. Berikut ini adalah kode untuk melakukan hal

di atas: // Tambah pemain baru, meskipun array sudah penuh if (jumlahPemainAktif == ArrayPemain.length) { // Array sudah penuh. Buat array baru yang lebih besar, // kemudian kopi isi array lama ke array baru lalu ubah // ArrayPemain ke array baru. int ukuranBaru = 2 * ArrayPemain.length; Pemain[] temp = new Pemain[ukuranBaru];

// Ukuran array baru // Array baru

System.arraycopy(ArrayPemain, 0, temp, 0, ArrayPemain.length); ArrayPemain = temp;

// Ubah referensi ArrayPemain ke array baru.

} // Di sini kita sudah tahu bahwa pasti ada tempat di array baru. ArrayPemain[jumlahPemainAktif] = pemainBaru; // Tambah pemain baru... jumlahPemainAktif++;

//

... dan tambah satu jumlahPemainAktif nya

Jika kita akan melakukan hal ini terus menerus, akan lebih indah jika kita membuat kelas untuk menangani hal ini. Objek mirip array yang bisa berubah ukuran untuk mengakomodasi jumlah data yang bisa ia tampung disebut array dinamis. Array dinamis memiliki jenis operasi yang sama dengan array : mengisi nilai pada posisi tertentu dan

mengambil nilai di posisi tertentu. Akan tetapi tidak ada batas maksimum dari jumlah array (hanya tergantung pada jumlah memori komputer yang tersedia). Dalam kelas array dinamis, metode put dan get akan diimplementasikan sebagai metode instansi. Di sini misalnya, adalah kelas yang mengimplementasikan array dinamis int : public class ArrayDinamisInt { private int[] data;

// Array untuk menyimpan data

public DynamicArrayOfInt() { // Konstruktor. data = new int[1];

// Array akan bertambah besar jika diperlukan

} public int get(int posisi) { // Ambil nilai dari posisi tertentu di dalam array. // Karena semua posisi di dalam array adalah nol, maka //

jika

posisi

tertentu

di

luar

data

array,

nilai

0

akan

dikembalikan if (posisi >= data.length) return 0; else return data[posisi]; } public void put(int posisi, int nilai) { // Simpan nilai ke posisi yang ditentukan di dalam array // Data array tersebut akan bertambah besar jika diperlukan if (posisi >= data.length) { // Posisi yang ditentukan berada di luar array data // Besarkan ukuran array 2x lipat. Atau jika ukurannya masih // terlalu kecil, buat ukurannya sebesar 2*posisi int ukuranBaru = 2 * data.length; if (posisi >= ukuranBaru) ukuranBaru = 2 * posisi; int[] dataBaru = new int[ukuranBaru]; System.arraycopy(data, 0, dataBaru, 0, data.length); data = dataBaru; // Perintah berikut hanya untuk demonstrasi System.out.println("Ukuran array dinamis diperbesar menjadi "

+ ukuranBaru); } data[posisi] = nilai; } } // akhir kelas ArrayDinamisInt

Data pada objek ArrayDinamisInt disimpan dalam array biasa, akan tetapi arraynya akan dibuang dan diganti dengan array baru yang lebih besar apabila diperlukan. Jika bilangan adalah variable bertipe ArrayDinamisInt, maka perintah bilangan.put(pos,nilai) akan menyimpan bilangan pada posisi pos di array dinamis tersebut. Fungsi bilangan.get(pos)

mengambil nilai yang disimpan pada posisi pos.

Pada contoh pertama, kita menggunakan array untuk menyimpan bilangan bulat positif yang dimasukkan oleh user. Kita bisa menulis ulang program tersebut dengan menggunakan

ArrayDinamisInt.

bilangan.get[i].

Referensi

ke

bilangan[i]

diganti

dengan

Perintah "bilangan[jmlBilangan] = bil;" kita ganti dengan

"bilangan.put(jmlBilangan,bil);". Berikut ini adalah programnya: public class BalikBilanganInput { public static void main(String[] args) { ArrayDinamisInt bilangan;

// Array untuk menyimpan nilai input

dari user int jmlBilangan;

// Banyaknya bilangan yang sudah disimpan

dalam array int bil;

// Bilangan yang diambil dari user

bilangan = new ArrayDinamisInt(); jmlBilangan = 0;

// Belum ada bilangan yang

disimpan System.out.println("Masukkan bilangan bulat positif, masukkan nol untuk mengakhiri."); while (true) { System.out.print("? "); bil = KonsolIO.ambilInt(); if (bil <= 0) break; bilangan.put(jmlBilangan,bil);

jmlBilangan++; } System.out.println("\nBilangan

yang Anda masukkan

dalam

urutan

terbalik adalah :\n"); for (int i = jmlBilangan - 1; i >= 0; i--) { System.out.println( bilangan.get(i) ); } } // akhir main(); }

// akhir kelas BalikBilanganInput

ArrayLists dan Vector ArrayList Kelas ArrayDinamisInt bisa digunakan jika kita membutuhkan array dengan batas maksimum yang tak terbatas. Akan tetapi jika kita ingin menyimpan BentukGeometri misalnya, kita harus membuat kelas baru. Kelas tersebut mungkin bernama ArrayDinamisBentukGeometri,

dengan

beberapa

perubahan

dan akan tampak sama persis dengan ArrayDinamisInt di

mana

"int"

muncul

akan

diganti

dengan

"BentukGeometri". Juga demikian jika kita ingin membuat kelas ArrayDinamisDouble, ArrayDinamisPemain,

dan sebagainya.

Yang agak sedikit lucu adalah kelas tersebut sangat mirip isinya, hanya kelas-kelasnya saja yang berlainan. Akan sangat lebih baik apabila kita bisa membuat kelas umum yang berlaku untuk semua kelas. Hal ini disebut dengan pemrograman generik. Beberapa bahasa pemrograman seperti C++ memiliki fasilitas untuk melakukan pemrograman generik. Java tidak memiliki fasilitas seperti itu (maksudnya tidak sama persis). Tapi kita bisa membuat sesuatu yang mirip dengan itu pada Java dengan menggunakan struktur data yang memiliki tipe "Object". Pada Java, setiap kelas adalah kelas turunan dari kelas yang bernama Object. Artinya setiap objek dapat dirujuk oleh variabel bertiipe Object. Semua objek dapat dimasukkan dalam array bertipe Object[]. Jika suatu subrutin memiliki parameter formal bertipe Object,

maka objek apapun bisa diberikan kepada subrutin tersebut.

Jika kita buat kelas ArrayDinamisObject, maka kita bisa menyimpan objek apapun. Ini sebenarnya bukan programming generik sebenarnya, dan tidak berlaku untuk tipe primitif

seperti int dan double. Sebenarnya, kita tidak perlu membuat kelas ArrayDinamisObject sendiri, karena Java telah memiliki kelas standar yang dinamakan ArrayList yang sifatnya mirip dengan yang kita sebutkan sebelumnya. ArrayList ArrayList

disimpan dalam paket java.util, jadi jika kita ingin menggunakan kelas dalam

sebuat

java.util.ArrayList;"

program,

kita

harus

memberikan

"import

atau "import java.util.*;" di awal program kita.

Kelas ArrayList berbeda dengan kelas ArrayDinamisInt dalam arti, objek ArrayList selalu memiliki ukuran tertentu, dan kita tidak boleh mengambil posisi di luar ukuran ArrayList.

Dalam hal ini, ArrayList mirip seperti array biasa. Akan tetapi, ukuran

ArrayList

bisa bertambah kapan saja jika diperlukan. Kelas ArrayList memiliki banyak

metode instansi. Kita akan jelaskan sebagian yang sangat berguna. Misalnya daftar adalah variabel dengan tipe ArrayList. 

daftar.size()

-- Fungsi ini menghasilkan ukuran ArrayList saat ini. Posisi valid

dalam daftar adalah yang bernomor 0 hingga daftar.size() - 1. Ingat bahwa ukurannya bisa nol. Panggilan konstruktor new ArrayList() akan membuat ArrayList 

dengan ukuran nol.

daftar.add(obj)

-- Menambah objek di akhir ArrayList, kemudian menambah

ukurannya dengan 1. Parameter obj merujuk pada objek dengan tipe apapun, atau bisa bernilai null. 

daftar.get(N) N

-- Mengambil nilai yang disimpan pada posisi N pada ArrayList.

harus bertipe bilangan bulat antara 0 hingga daftar.size() - 1. Jika N berada

di luar rentang ini, pesan kesalahan akan ditampilkan. Memanggil fungsi ini mirip dengan memanggil array seperti A[N] untuk suatu array A. Akan tetapi kita tidak bisa menggunakan daftar.get(N) pada ekspresi di sebelah kiri daftar.get(N) = 5 

tidak boleh dilakukan)

daftar.set(N, obj)

-- Mengisi suatu objek obj di posisi N dari suatu ArrayList,

dan mengganti apapun yang sudah disimpan sebelumnya pada posisi N. Bilangan bulat N harus berada pada rentang 0 hingga daftar.size() - 1. Perintah ini mirip dengan perintah A[N] = obj pada array A. 

daftar.remove(obj)

-- Jika objek tersebut ada di dalam ArrayList, maka objek

tersebut akan dibuang. Elemen lain setelah posisi objek tersebut di dalam ArrayList

akan digeser satu posisi. Kemudian ukuran ArrayList akan berkurang

1. Jika obj terdapat dalam ArrayList lebih dari satu kali, hanya yang pertama saja yang dibuang. 

daftar.remove(N)

-- Untuk bilangan bulat N, maka perintah ini akan menghapus

posisi ke-N pada ArrayList. N harus berada pada rentang 0 hingga daftar.size() - 1.

Elemen setelah ini akan digeser satu posisi. Kemudian

ukuran ArrayList berkurang 1. 

daftar.indexOf(obj)

-- Fungsi untuk mencari suatu objek obj di dalam

ArrayList. Jika objek ditemukan, maka posisinya di dalam ArrayList akan dikembalikan. Jika tidak, maka fungsi ini akan mengembalikan -1. Misalnya,kita akan membuat pemain dalam game yang digambarkan dengan objek dengan tipe Pemain. Pemain yang berada dalam game disimpan dalam ArrayList bernama paraPemain.

Variabel ini dideklarasikan seperti :

ArrayList paraPemain;

dan kita inisialisasikan dengan objek kosong dengan perintah paraPemain = new ArrayList();

Jika pemainBaru adalah variabel yang bertipe Pemain, maka pemain baru tersebut bisa ditambahkan ke dalam ArrayList dan ke dalam game dengan perintah : paraPemain.add(pemainBaru);

dan jika pemain nomor i keluar dari game, maka kita hanya perlu memberikan perintah paraPemain.remove(i);

Atau jika pemain adalah objek bertipe Pemain yang akan kita keluarkan dari game, maka kita bisa menggunakan perintah paraPemain.remove(pemain);

Semuanya terlihat sangat mudah. Satu-satunya kesulitan yang akan kita temui adalah ketika kita ingin mengambil nilai yang disimpan pada posisi i di dalam ArrayList. Tipe keluaran fungsi ini adalah Object. Dalam hal ini objek yang diambil oleh fungsi ini sebenarnya bertipe Pemain. Supaya kita bisa menggunakan hasil keluarannya, maka kita perlu menggunakan casting tipe untuk mengubahnya menjadi tipe Player, dengan cara : Pemain pmn = (Pemain)paraPemain.get(i);

Misalnya, jika kelas Pemain memiliki metode instansi yang dinamakan jalan() yang dipanggil ketika seorang pemain menjalankan dadu atau kartu, maka kita bisa menuliskan kode untuk memberi giliran kepada semua pemain untuk jalan, yaitu dengan for (int i = 0;

i < paraPemain.size();

i++) {

Pemain pmn = (Pemain)paraPemain.get(i); pmn.jalan();

}

Dua baris di dalam perulangan for tersebut dapat digabungkan dengan satu perintah : ((Pemain)paraPemain.get(i)).jalan();

Perintah ini akan mengambil elemen pada ArrayList mengcasting tipenya, kemudian memanggil metode jalan() pada pemain yang baru diambil tersebut. Tanda kurung di sekitar "(Pemain)paraPemain.get(i)" diperlukan karena aturan dalam Java sehingga perintah dalam kurung akan dijalankan terlebih dahulu sebelum metode jalan() dipanggil. Vector Kelas ArrayList diperkenalkan pada Java versi 1.2, sebagai salah satu kumpulan kelas yang digunakan untuk bekerja dengan sekumpulan koleksi objek. Jika akan bahas lebih lanjut tentang "kelas koleksi" pada bagian berikutnya. Versi awal Java tidak memiliki ArrayList,

akan tetapi memiliki kelas yang sangat mirip yaitu java.util.Vector. Kita

masih bisa melihat Vector digunakan pada program lama, dan dalam beberapa kelas standar Java, sehingga kita perlu tahu tentang kelas ini. Menggunakan Vector mirip dengan menggunakan ArrayList. Perbedaannya adalah nama metode yang berbeda untuk melakukan tugas yang sama, atau nama metode yang berbeda untuk melakukan tugas yang sama. Seperti ArrayList, suatu Vector mirip dengan array Object yang bisa berkembang jika diperlukan. Konstruktor new Vector() membuat vektor tanpa elemen. Misalnya vec adalah suatu Vector. Maka : adalah fungsi untuk mengembalikan jumlah elemen di dalam vektor.



vec.size()



vec.addElement(obj)

akan menambahkan Object obj di akhir vektor. Sama

dengan metode add() pada ArrayList. 

vec.removeElement(obj)

menghapus obj dari dalam vektor, kalau ada. Hanya

objek pertama yang ditemui akan dihapus. Sama dengan remove(obj) pada kelas ArrayList 

vec.removeElementAt(N)

menghapus elemen ke-N. N harus berada pada rentang

0 hingga vec.size() - 1. Sama dengan remove(N) pada ArrayList 

vec.setSize(N)

akan mengubah ukuran vektor menjadi N. Jika di dalam vektor

terdapat elemen yang jumlahnya lebih banyak dari N, maka elemen lainnya akan dihapus. Jika lebih sedikit, maka tempat kosong akan diisi dengan null. Kelas ArrayList

tidak memiliki metode seperti ini.

Kelas Vector memiiki banyak metode lagi, akan tetapi ini adalah metode yang sering digunakan. Array Multi Dimensi Tipe apapun bisa digunakan sebagai tipe dasar suatu array. Kita bisa membuat array int, array String, array Object dan seterusnya. Terutama, karena array adalah tipe Java kelas satu, kita bisa membuat array yang bertipe array. Misalnya suatu array bertipe int[], juga otomatis memiliki array bertipe int[][], yaitu "array bertipe array int". Array tersebut disebut array 2 dimensi. Tentunya, dengan tipe int[][],

kita juag bisa membuat arraynya dengan tipe int[][][], yang merupakan array

3 dimensi, dan seterusnya. Tidak ada batasan berapa dimensi array yang kita buat, akan tetapi bukan sesuatu yang biasa dilakukan untuk membuat array lebih dari 3 dimensi. Pembahasan kita akan lebih dikhususkan pada array 2 dimensi. Tipe TipeDasar[][] biasanya dibaca "array 2 dimensi bertipe TipeDasar" atau "array dari array TipeDasar". Deklarasi pernyataan "int[][] A;" adalah membuat variabel bernama A dengan tipe int[][].

Variabel ini berisi objek yang bertipe int[][]. Pernyataan pemberian nilai "A =

new int[3][4];"

akan membuat objek array 2 dimensi dan mengisi A ke objek yang baru

dibuat tersebut. Seperti biasa, deklarasi dan pemberian nilai bisa digabung menjadi satu pernyataan, seperti "int[][] A = new int[3][4];". Objek yang baru dibuat adalah objek yang merupakan array dari array int. Bagian int[3][4] menyatakan bahwa ada 3 array int di dalam array A, dan di setiap array int tersebut terdapat 4 int. Cara seperti itu mungkin sedikit membingungkan, akan tetapi akan lebih mudah apabila kita bayangkan array tersebut seperti matriks. Istilah "int[3][4]" bisa disebut sebagai matriks dengan 3 baris dan 4 kolom, seperti pada ilustrasi berikut ini :

Untuk banyak hal, kita bisa mengabaikan kenyataan di atas, dan membayangkan bentuk matriks seperti di atas. Kadang-kadang kita juga harus ingat bahwa setiap baris sebenarnya juga merupakan suatu array. Array-array ini bisa dirujuk dengan A[0], A[1], dan A[2]. Setiap baris bertipe int[]. Pernyataan A[1] merujuk pada salah satu baris pada array A. Karena A[1] itu sendiri sebenarnya adalah array int, kita bisa menambah indeks lain untuk merujuk pada posisi pada baris tersebut. Misalnya A[1][3] adalah elemen nomor 3 pada baris 1. Seperti biasa, ingat bahwa posisi baris dan kolom dimulai dari 0. Jadi pada contoh di atas, A[1][3] bernilai 5. Lebih umum lagi, A[i][j] adalah posisi pada baris i dan kolom j. Seluruh elemen pada A bisa dinamakan seperti berikut : A[0][0]

A[0][1]

A[0][2]

A[0][3]

A[1][0]

A[1][1]

A[1][2]

A[1][3]

A[2][0]

A[2][1]

A[2][2]

A[2][3]

A[i][j]

adalah variabel bertipe int. Kita bisa mengisi nilainya atau menggunakannya

seperti variabel bertipe int biasa.

Perlu juga diketahui bahwa A.length akan memberikan jumlah baris pada A. Untuk mendapatkan jumlah kolom pada A, kita harus mencari jumlah int dalam setiap baris, yaitu yang disimpan pada A[0]. Jumlah kolom ini bisa didapatkan dengan menggunakan A[0].length,

atau A[1].length atau A[2].length. (Tidak ada aturan baku yang

menyatakan bahwa pada setiap baris suatu array harus memiliki panjang yang sama, dan sebenarnya pada beberapa aplikasi, juga digunakan array dengan panjang yang berbedabeda pada setiap barisnya. Akan tetapi apabila kita membuat array dengan perintah seperti di atas, maka kita akan selalu mendapatkan array dengan panjang array yang sama.) Array 3 dimensi juga dibuat dan diolah dengan cara yang sama. Misalnya, array 3 dimensi bertipe int bisa dibuat dengan pernyataan "int[][][] B = new int [7][5][11];". Kita juga bisa mengilustrasikannya sebagai kubus 3-dimensi. Masing-masing bloknya bertipe int yang bisa dipanggil dalam bentuk B[i][j][k]. Array dimensi lain yang lebih tinggi juga mengikuti pola yang sama, akan tetapi akan sangat sulit untuk membuat visualisasi struktur arraynya. Kita bisa mengisi array multi dimensi sekaligus pada saat dideklarasikan. Ingat sebelumnya bagaimana array 1 dimensi biasa dideklarasikan, dan bagaimana isinya diinisialisasikan, yaitu seperti daftar nilai-nilainya yang dipisahkan dengan koma, dan diletakkan di dalam tanda kurung kurawal { dan }. Inisialisasi array bisa juga digunakan untuk array multi dimensi, yang terdiri dari beberapa inisialisasi array 1 dimensi, masing-masing untuk setiap barisnya. Misalnya, array A pada gambar di atas dapat dibuat dengan perintah : int[][] A = { { {

1,

0, 12, -1 },

7, -3,

2,

5 },

{ -5, -2,

2,

9 }

};

Jika tidak ada inisialisasi yang diberikan untuk suatu array, maka nilainya akan diisi dengan nilai awal tergantung pada tipenya : nol untuk bilangan, false untuk boolean dan null

untuk objek.

Seperti halnya array 1 dimensi, array 2 dimensi juga sering diolah dengan menggunakan perulangan for. UNtuk mengolah semua elemen pada array 2 dimensi, kita bisa menggunakan pernyataan for bertingkat. Jika array A dideklarasikan seperti int[][]

A

=

new int[3][4];

maka kita bisa mengisi 0 untuk semua elemen pada A dengan menggunakan for (int baris = 0;

baris < 3;

for (int kolom = 0;

baris++) {

kolom < 4;

kolom++) {

A[baris][kolom] = 0; } }

Pertama kali perulangan for bagian luar akan memproses dengan baris = 0. Bagian dalamnya akan mengisi keempat kolom pada baris pertama, yaitu A[0][0] = 0, A[0][1] = 0, A[0][2] = 0,

dan A[0][3] = 0. Kemudian perulangan for bagian luar akan mengisi

baris kedua, dan seterusnya. Dan juga, kita bisa menjumlah semua elemen pada A dengan int jml = 0; for (int i = 0; i < 3; i++) for (int j = 0; j < 4; i++) jml = jml + A[i][j];

Untuk mengolah array 3 dimensi, tentunya kita harus menggunakan perulangan for bertingkat 3. Suatu array 2 dimensi bisa digunakan untuk menyimpan data yang secara alami memang tersusun sebagai baris dan kolom. Misalnya papan catur terdiri dari 8 baris dan 8 kolom. Jika suatu kelas dinamakan PapanCatur untuk merepresentasikan papan catur, maka kita bisa deklarasikan dengan perintah PapanCatur[][] papan = new PapanCatur[8][8];

Kadang-kadang array 2 dimensi juga digunakan untuk masalah yang tidak terlalu jelas matriksnya. Misalnya perusahaan yang memiliki 25 toko. Anggap masing-masing toko memiliki keuntungan yang didapat pada masing-masing toko tersebut setiap bulan pada tahun 2009. Jika toko-toko tersebut memiliki nomor 0 hingga 24, dan 12 bulan dari Januari 09 hingga Desember 09 dinomori 0 hingga 11, maka data keuntungan dapat disimpan dalam array untung yang dideklarasikan seperti : double[][] untung = new double[25][12]; untung[3][2]

adalah keuntungan yang dibuat oleh toko nomor 3 di bulan Maret. Atau

secara umum, untung[noToko][noBulan] adalah keuntungan toko noToko pada bulan noBulan.

Dalam contoh ini array 1 dimensi untung[noToko] memiliki arti : Data

keuntungan satu toko selama satu tahun.

Anggap array untung telah diisi dengan data. Data ini bisa diolah lebih lanjut. Misalnya, total keuntungan seluruh perusahaan -- sepanjang tahun dari seluruh toko -- dapat dihitung dengan menjumlahkan semua elemen pada array : double totalUntung;

// Total keuntungan perusahaan tahun 2009

totalUntung = 0; for (int toko = 0; toko < 25; toko++) { for (int bulan = 0; bulan < 12; bulan++) totalUntung += untung[toko][bulan]; }

Kadang-kadang kita juga perlu menghitung hanya satu baris atau satu kolom saja, bukan keseluruhan array. Misalnya, kita ingin menghitung keuntungan total perusahaan pada bulan Desember, yaitu bulan nomor 11, maka kita bisa gunakan perulangan : double untungDesember = 0.0; for (noToko = 0; noToko < 25; noToko++) untungDesember += untung[noToko][11];

Sekarang mari kita buat array 1 dimensi yang berisi total keuntungan seluruh toko setiap bulan : double[] untungBulanan;

// Keuntungan setiap bulan

untungBulanan = new double[12]; for (int bulan = 0; bulan < 12; bulan++) { // hitung total keuntungan semua toko bulan ini untungBulanan[bulan] = 0.0; for (int toko = 0; toko < 25; toko++) { untungBulanan[bulan] += profit[toko][bulan]; } }

Sebagai contoh terakhir untuk mengolah array keuntungan, misalnya kita ingin tahu toko mana yang menghasilkan keuntungan terbesar sepanjang tahun. Untuk menghitungnya, kita harus menjumlahkan keuntungan setiap toko sepanjang tahun. Dalam istilah array, ini berarti kita ingin mengetahui jumlah setiap baris pada array. Kita perlu mencatat hasil perhitungannya untuk mencari mana toko dengan keuntungan terbesar. double untungMaks; // Keuntungan terbesar suatu toko int tokoTerbaik; // Nomor toko yang memiliki keuntungan terbesar double total = 0.0;

// Total keuntungan suatu toko

// Pertama-tama hitung keuntungan dari toko nomo 0 for (int bulan = 0;

bulan < 12; bulan++)

total += untung[0][bulan]; tokoTerbaik = 0; // Mulai dengan anggapan toko nomor 0 untungMaks = total;

// adalah toko paling menguntungkan

// Sekarang kita lihat seluruh toko, dan setiap kali // kita melihat toko dengan keuntungan lebih besar dari // untungMaks, kita ganti untungMaks dan tokoTerbaik // dengan toko tersebut for (toko = 1; toko < 25; toko++) { // Hitung keuntungan toko tersebut sepanjang tahun total = 0.0; for (bulan = 0; bulan < 12; bulan++) total += untung[toko][bulan]; // Bandingkan keuntungan toko ini dengan untungMaks if (total > untungMaks) { untungMaks = total;

// keuntungan terbesar saat ini

tokoTerbaik = toko;

// datang dari toko ini

} } // akhir for // Di sini, untungMaks adalah keuntungan terbesar dari 25 toko // dan tokoTerbaik adalah toko dengan keuntung tersebut // (Mungkin juga ada toko yang menghasilkan keuntungan // yang persis sama.)

Pencarian, Pengurutan dan Rekursi Dua jenis teknik pemrosesan array yang paling umum adalah pencarian dan pengurutan. Pencarian di sini berarti mencari item di dalam array yang memenuhi kriteria tertentu. Pengurutan berarti menata ulang semua item di dalam array dalam urutan tertentu (urutan naik atau turun tergantung konteksnya). Pencarian dan pengurutan sering didiskusikan, dengan cara yang teoretis, dengan menggunakan contoh array bilangan. Dalam situasi sebenarnya, tipe data yang lebih

kompleks biasanya digunakan. Misalnya, array bisa jadi suatu mailing list, dan setiap elemen di dalam array adalah objek yang berisi nama dalam alamat email. Kita mungkin akan mencari alamat email seseorang apabila namanya diketahui. Ini adalah contoh pencarian, di mana kita ingin mencari objek di dalam array yang berisi suatu nama. Mungkin juga kita ingin mengurut array tersebut tergantung pada kriteria tertentu. Misalnya mengurutkan elemen pada array di mana nama diurutkan secara abjad. Contoh lainnya adalah mengurutkan elemen pada array berdasarkan kode pos. Contoh-contoh ini bisa dibuat lebih umum yaitu kita mempunyai array yang berisi objek, dan kita ingin melakukan pencarian atau pengurutan array berdasarkan nilai salah satu variabel instansi pada array tersebut. Kita bisa gunakan beberapa istilah yang bersumber pada "database", yang sesungguhnya adalah koleksi data yang besar dan terorganisir. Kita akan menyebut masing-masing objek di dalam array sebagai record. Variabel instansi di dalam objek disebut field dari record tersebut. Dalam contoh mailing list di atas, masing-masing record berisi nama dan alamat email. Field dari record tersebut mungkin nama depan, nama akhir, alamat email, dan seterusnya. Dalam konteks pencarian dan pengurutan, salah satu field diambil sebagai field kunci. Mencarian berarti mencari suatu record di dalam array yang memiliki nilai tertentu pada field kuncinya. Pengurutan berarti melakukan penataan elemen di dalam array sehingga field kunci record akan terurut berdasarkan urutan naik atau turun. Dalam bagian ini, contoh-contoh yang disediakan akan mengikuti tradisi menggunakan array bilangan. Kita akan contoh beberapa record dan kunci untuk mengingatkan kita pada aplikasi yang lebih praktis. Lebih jauh, kita akan melihat tentang rekursi dan aplikasinya. Suatu rubrutin disebut rekursif jika ia memanggil dirinya sendiri baik secara langung atau tak langsung. Rekursi dapat digunakan untuk menyelesaikan masalah kompleks dengan menguranginya menjadi masalah yang lebih sederhana. Pencarian Ada algoritma sederhana yang bisa digunakan untuk mencari suatu item pada array : Lihat setiap array, dan cek apakah isinya sama dengan item yang kita cari. Jika ketemu, maka pencarian selesai. Jika kita sudah melihat semua item dan tidak ada item yang sama, maka kita yakin bahwa item yang kita cari tidak ada dalam array. Subrutin untuk mengimplementasikan algoritma tersebut mudah kita tulis. Misalnya array yang kita cari bertipe int[]. Berikut ini adalah metode untuk mencari integer tertentu dalam array. Jika integer ditemukan, maka metode ini akan mengembalikan indeks dalam

array di mana item tersebut ditemukan. Jika integer tersebut tidak ada dalam array, maka metode tersebut akan mengembalikan nilai -1, yang artinya integer tersebut tidak ditemukan. static int cari(int[] A, int N) { // Mencari integer N di dalam array A // Kondisi akhir : jika N tidak ada dalam array //

maka kembalikan -1. Jika N ada dalam array

//

kembalikan i, yaitu indeks di mana A[i] == N

for (int indeks = 0; indeks < A.length; indeks++) { if ( A[indeks] == N ) return indeks;

// N ditemukan pada indeks ini.

} // Jika kita sampai di sini, berarti N belum ditemukan // Kembalikan -1. return -1; }

Metode seperti ini dimana pencarian dilakukan dengan menguji setiap item disebut pencarian linier (linear search). Jika kita tidak mengetahui apa-apa tentang isi dan urutan item pada array, maka tidak ada lagi algoritma alternatif yang lebih baik dari ini. Akan tetapi jika kita tahu bahwa elemen di dalam array diurut dalam urutan menaik atau urutan menurun, maka kita bisa menggunakan algoritma lain yang lebih cepat. Tentu saja, waktu yang dibutuhkan untuk mengurutkan array tidak sebentar, akan tetapi jika array ini akan dicari berulang kali, maka waktu pengurutan array akan terbayarkan dengan cepat. Pencarian biner (binary search) adalah metode untuk mencari suatu item dalam array yang sudah diurutkan. Meskipun implementasinya tidak mudah, akan tetapi ide dasarnya sangat mudah : Jika kita mencari suatu item dalam suatu array yang terurut, maka kita bisa menghapus setengah dari keseluruhan elemen hanya dengan melihat satu nilai. Misalnya kita ingin mencari bilangan 42 dalam array yang sudah diurutkan yang terdiri dari 1000 bilangan bulat. Anggap bahwa array tersebut diurutkan dalam urutan menaik (dari kecil ke besar). Kemudian kita cek item ke-500 dalam array, dan ternyata isinya adalah 93. Karena 42 kurang dari 93, dan karena elemen di dalam array tersebut dalam urutan menaik, kita bisa simpulkan bahwa 42 tidak mungkin ada di item ke-501 ke atas. Maka elemen tersebut pasti ada di lokasi tertentu sebelum posisi ke-500.

Cara berikutnya adalah melihat di lokasi 250. Jika misanya lokasi tersebut berisi 21, maka kita bisa menghilangkan lokasi 0 hingga 250 dan memfokuskan pencarian antara 251 dan 499. Yang berikutnya adalah kira-kira di lokasi ke-125 setelah itu, yang berikutnya adalah sekitar 62 lokasi setelah itu. Setelah kira-kira 10 langkah pengujian, hanya ada satu lokasi yang akan kita cek. Cara ini akan jauh lebih mudah dan lebih cepat daripada harus mencari semua elemen di dalam array. Jika ada satu juta elemen di dalam array, maka kita hanya perlu mencari 20 kali. (Secara matematika, jumlah langkah yang diperlukan adalah logaritmik dari jumlah item di dalam array). Untuk membuat subrutin pencarian biner pada Java yang mencari item N pada array A, kita hanya perlu mencatat rentang lokasi di mana kira-kira N bisa ditemukan. Pada setiap langkah, kita bisa mengurangi kemungkinan dan mengurangi rentang pencarian. Operasi dasarnya adalah mencari item di tengah-tengah rentang tersebut. Jika item ini lebih besar dari N, maka rentang bagian atasnya bisa dibuang. Jika kurang dari N, maka rentang bawahnya bisa dibuang. Jika nilai di tengah-tengah tersebut persisi sama denan N, maka pencarian selesai. Jika ukurang pencarian berkurang menjadi nol, maka nilai N tidak ada dalam array. Berikut ini adalah subrutin yang mengembalikan lokasi di mana N berada di dalam array terurut A. Jika N tidak ditemukan, maka nilai -1 akan dikembalikan. static int pencarianBiner(int[] A, int N) { // Mencari bilangan N pada array A // Kondisi awal : A harus diurut menaik (dari kecil ke besar) // Kondisi akhir : Jika N ada dalam array, maka kembalikan //

nilai i, di mana A[i] == N. Jika tidak kembalikan -1

int lokasiTerkecil = 0; int lokasiTerbesar = A.length - 1; while (lokasiTerbesar >= lokasiTerkecil) { int tengah = (lokasiTerkecil + lokasiTerbesar) / 2; if (A[tengah] == N) { // N ditemukan di sini return tengah; } else if (A[tengah] > N) { // buang lokasi >= tengah lokasiTerbesar = tengah - 1;

} else { // buang lokasi <= tengah lokasiTerkecil = tengah + 1; } } // Sampai titik ini, lokasiTerbesar < lokasiTerkecil // yang berarti nilai N tidak ada dalam array. // Kembalikan -1, yang artinya item tidak ditemukan return -1; }

List Asosiasi Salah satu aplikasi pencarian yang banyak digunakan adalah yang menggunakan list asosiasi (association list). Contoh umum dari suatu list asosiasi adalah kamus. Kamus menghubungan kata dengan definisi. Dengan kata tertentu, kita bisa menggunakan kamus untuk mencari definisinya. Kita bisa membayangkan kamus sebagai daftar suatu pasangan (pair) dalam bentuk (k,d) di mana k adalah kata dan d adalah definisi. Secara umum, kita menganggap bahwa tidak ada dua pasangan dalam list yang memiliki kunci yang sama. Operasi dasar dari list asosiasi adalah sebagai berikut : Dengan kunci k, cari nilai n yang berhubungan dengan k, jika ada. List asosiasi digunakan secara luas dalam ilmu komputer. Misalnya, suatu kompiler harus melacak di mana lokasi suatu variabel pada memori. Kompiler dapat menggunakan list asosiasi di mana kuncinya adalah nama variabel dan nilainya adalah alamat variabel tersebut di memori. Contoh lainnya adalah mailing list, yang menghubungkan nama dan alamat email dalam daftar tersebut. Contoh lain yang mungkin berhubungan adalah direktori telepon yang menghubungkan nama dan nomor telepon. Item di dalam list tersebut mungkin berupa objek dari kelas : class EntriTelepon { String nama; String noTelp; }

Data dalam direktori telepon adalah array yang bertipe EntriTelepon[] dan variabel integer untuk menyimpan berapa banyak item yang disimpan dalam direktori tersebut. (Contoh ini adalah contoh dari "array setengah penuh" yang dibahas pada bagian

sebelumnya. Mungkin lebih baik jika kita menggunakan array dinamis atau ArrayList untuk menyimpan daftar telepon.) Direktori telepon mungkin berupa objek di dalam kelas class DirektoriTelepon { EntriTelepon[] info = new EntriTelepon[100];

// Tempat untuk 100

entri int jmlEntri = 0;

// Jumlah entri aktual di dalam array

void tambahEntri(String nama, String noTelp) { // Tambah entri baru di akhir array info[jmlEntri] = new EntriTelepon(); info[jmlEntri].nama = nama; info[jmlEntri].noTelp = noTelp; jmlEntri++; } String getNoTelp(String nama) { // Ambil nomor telepon dari nama ini atau // kembalikan null jika tidak ada nama ini // di dalam array. for (int idks = 0; idks < jmlEntri; idks++) { if (nama.equals( info[idks].nama ))

// Nama ketemu!

return info[idks].noTelp; } return null;

// Nama tidak ketemu.

} }

Lihat bahwa metode getNoTelphanya mengambil lokasi dalam array yang telah diisi dengan EntriTelepon. Dan juga tidak seperti rutin pencarian yang disebutkan sebelumnya, rutin ini tidak mengembalikan lokasi item dalam array. Akan tetapi ia mengembalikan nilai lain yang berhubungan dengan kata kuncinya, yaitu nama. Hal ini sering dilakukan untuk list asosiasi. Kelas ini bisa diperbaliki lebih lanjut. Satu hal, mungkin lebih baik jika kita melakukan pencarian dengan menggunakan pencarian biner dan bukan pencarian linier sederhana dalam metode getNoTelp. Akan tetapi, kita hanya bisa lakukan ini apabila EntriTelepon diurut terlebih dahulu berdasarkan nama. Dan sebenarnya, tidak terlalu suit untuk membuat entri tersebut dalam urutan, yang akan kita lihat berikutnya. Pengurutan

Pengurutan Penyisipan (Insertion Sort) Ada banyak algoritma yang tersedia untuk melakukan pengurutan. Salah satu yang paling mudah dimengerti adalah pengurutan penyisipan (insertion sort). Metode ini juga bisa digunakan untuk menjaga agar list selalu dalam urutan tertentu (naik atau turun) sewaktu kita menambah item baru ke dalam list. Mari kita lihat contoh pertama : Misalnya kita memiliki list yang sudah diurutkan, dan kita ingin menambahkan sebuat item ke dalamnya. Jika kita ingin memastikan bahwa suatu list tetap dalam kondisi terurut, maka item tersebut harus diletakkan di tempat yang tepat, yaitu semua item yang lebih kecil harus ditempatkan sebelum item tersebut, dan semua item yang lebih besar ditempatkan setelahnya. Artinya kita harus menggeser semua item yang lebih besar ke satu sisi untuk memberi ruangan pada item baru yang akan ditambahkan. static void sisip(int[] A, int jmlItem, int itemBaru) { // Kondisi awal : jmlItem adalah jumlah item pada A. //

Item ini harus berada dalam kondisi terurut naik di mana

//

(A[0] <= A[1] <= ... <= A[jmlItem-1]).

//

Ukuran array harus lebih besar dari jmlItem.

// Kondisi akhir : jumlah item akan ditambah dengan satu, //

itemBaru telah ditambah pada array, dan semua item

//

masih dalam kondisi terurut.

// Catatan: untuk menyelesaikan proses penyisipan item //

dalam array, variabel yang mencatat jumlah item dalam

//

array harus ditambah satu setelah memanggil subrutin ini.

int lok = jmlItem - 1;

// Mulai dari akhir array

/* Pindahkan item yang lebih besar dari itemBaru satu posisi; Stop jika item yang lebih kecil ditemukan atau sampai ke awal array (lok == 0) */ while (lok >= 0 && A[lok] > itemBaru) { A[lok + 1] = A[lok];

// Pindahkan lokasi item dari posisi lok ke

lok = lok - 1;

// Pindah ke lokasi sebelumnya

lok+1 } A[lok + 1] = itemBaru; }

// Letakkan itemBaru di tempat kosong

Metode di atas bisa dikembangkan menjadi metode pengurutan jika kita mengeluarkan semua item dari array yang belum diurutkan, kemudian memasukkannya kembali satu demi satu, sambil menjaga agar array tetap terurut selama kita menambah item ke array baru. Setiap penyisipan bisa dilakukan dengan rutin sisip() di atas. Dalam algoritma sesungguhnya, kita tidak benar-benar mengambil semua item dari dalam array, kita hanya cukup mengingat bagian mana yang sudah diurutkan. static void urutPenyisipan(int[] A) { // Mengurutkan array A dalam urutan menaik (dari kecil ke besar) int itemTerurut; // Jumlah item yang sudah diurut for (itemTerurut = 1; itemTerurut < A.length; itemTerurut++) { // Anggap item A[0], A[1], ... A[itemTerurut-1] // telah diurutkan. Sisipkan A[itemTerurut] // ke dalam bagian yang sudah diurutkan int temp = A[itemTerurut];

// Item yang akan disisipkan

int lok = itemTerurut - 1;

// Mulai dari akhir list

while (lok >= 0 && A[lok] > temp) { A[lok + 1] = A[lok]; // Pindahkan item dari lok ke lok+1 lok = lok - 1;

// Pindah ke lokasi sebelumnya

} A[lok + 1] = temp; // Letakkan temp di tempat kosong } }

Ilustrasi berikut adalah ilustrasi di tengah-tengah pengurutan, yang menunjukkan apa yang terjadi di tengah-tengah salah satu eksekusi perulangan for dari kode di atas, ketika itemTerurut = 5.

Pengurutan Pilihan (Selection Sort) Metode pengurutan lainnya yang biasa digunakan adalah pengurutan pilihan (selection sort). Metode ini mencari item terbesar di dalam list, kemudian memindahkannya ke akhir array -- atau dengan kata lain di tempatnya, karena item terbesar akan berada di akhir array. Setelah item terbesar ditempatkan di tempat yang benar, kita gunakan cara yang sama, yaitu cari item terbesar berikutnya, kemudian letakkan di tempat kedua dari akhir, dan seterusnya. Metode ini dapat ditulis sebagai : static void urutPilihan(int[] A) { // Urut A dengan urutan menaik dengan Pengurutan Pilihan for (int tmptTerakhir = A.length-1; tmptTerakhir > 0; tmptTerakhir--) { //

Cari

nilai

terbesar

di

antara

A[0],

A[1],

A[tmptTerakhir], // dan pindahkan ke tmptTerakhir dengan cara menukarny // dengan nilai yang ada di tmptTerakhir

...,

int lokMaks = 0;

// Lokasi nilai terbesar saat ini

for (int j = 1; j <= tmptTerakhir; j++) { if (A[j] > A[lokMaks]) { //

Karena

A[j]

lebih

besar

dari

nilai

maksimum

yang

pernah // kita lihat, j adalah lokasi baru tempat di mana nilai // maksimum tersebut berada lokMaks = j; } } int temp = A[lokMaks];

// Tukar nilainya dengan A[tmptTerakhir].

A[lokMaks] = A[tmptTerakhir]; A[tmptTerakhir] = temp; }

// akhir perulangan

}

Pengurutan penyisipan dan pengurutan pilihan cocok digunakan untuk mengurut array dengan ukuran kecil (hingga beberapa ratus elemen). Ada beberapa algoritma pengurutan lain yang jauh lebih cepat dari pengurutan penyisipan dan pengurutan pilihan untuk array yang sangat besar. Kita akan diskusikan kemudian. Mengacak Nilai Kita akan sudahi bagian ini dengan masalah yang sedikit berkaitan, lebih jarang muncul, akan tetapi menarik, yaitu bagaimana caranya meletakkan elemen array dengan urutan acak. Misalnya adalah untuk mengocok kartu. Algoritma baik untuk mengocok mirip dengan pengurutan pilihan, akan tetapi kita tidak memindahkan item terbesar ke array paling belakang. Item dipilih secara acak dan dipindahkan ke akhir array. Berikut ini adalah subrutin untuk mengocok array bertipe int. static void kocok(int[] A) { // Kondisi akhir : Item pada A diatur dalam urutan yang acak for (int tmptTerakhir = A.length-1; tmptTerakhir > 0; tmptTerakhir--) { // Pilih lokasi acak di antara 0,1,...,tmptTerakhir. int lokAcak = (int)(Math.random()*(tmptTerakhir+1)); // Tukar item pada lokAcak dengan A[tmptTerakhir] int temp = A[lokAcak]; A[lokAcak] = A[tmptTerakhir];

A[tmptTerakhir] = temp; } }

Rekursi Definisi rekursi adalah definisi yang menggunakan konsep atau sebagian dari definisi tersebut menjadi definisi yang komplit. Misalnya : "keturunan" bisa berarti anak atau keturunan dari anak. "Kalimat" bisa berarti dua kalimat yang digabung dengan kata hubung "dan". "Direktori" adalah bagian pada hard disk yang berisi file dan direktori. Dalam matematika, "himpunan" adalah koleksi elemen, di mana elemen tersebut bisa berupa himpunan. "Pernyataan" pada Java misalnya pernyataan while yang didalamnya terdapat kata while, kondisi bernilai boolean dan pernyataan lainnya. Definisi rekursi bisa menjelaskan situasi yang sangat kompleks dalam beberapa kata. Definisi istilah "keturunan" tanpa menggunakan rekursi bisa jadi "anak, cucu, cicit, dan seterusnya". Akan tetapi mengatakan "dan seterusnya" bukan arti "keturunan" secara lengkap. Kita juga akan kesulitan jika kita mencoba mendefinisikan "direktori" sebagai "file yang berisi daftar file, dimana beberapa file bisa berisi daftar file, di mana beberapa file tersebut bisa berisi daftar file, dan seterusnya". Mencoba untuk menjelaskan pernyataan Java tanpa menggunakan rekursi dalam definisinya akan sulit dilakukan. Rekursi bisa digunakan dalam teknik pemrograman. Subrutin rekursif adalah subrutin yang memanggil dirinya sendiri, baik langsung maupun tak langsung. Subrutin tersebut memanggil dirinya sendiri secara tidak langsung yaitu jika ia memanggil subrutin lain yang akhirnya memanggil subrutin pertama (baik langsung maupun tak langsung). Suatu subrutin rekursi bisa menyelesaikan tugas kompleks dalam beberapa baris perintah. Kita akan lihat beberapa contohnya pada bagian ini. Mari kita mulai dengan contoh yang sudah kita lihat sebelumnya: algorithma pencarian biner pada bagian sebelumnya. Pencarian biner digunakan untuk mencari suatu nilai dalam list terurut (atau jika item nilai tersebut tidak ada di dalam list tersebut, akan memberitahu hasilnya misalnya dengan mengembalikan -1). Caranya adalah dengan mengecek elemen di tengah list tersebut. Jika elemen tersebut sama dengan nilai yang dicari, maka pencarian tersebut selesai. Jika nilai yang dicari lebih kecil daripada nilai elemen di tengah list tersebut, maka kita harus mencari di separuh awal dari

list tersebut. Jika lebih besar, kita harus mencari di separuh akhir list tersebut. Kemudian, pada separuh list yang kita pilih tersebut, kita akan mengecek kembali elemen tengahnya. Kita akan melihat kembali apakah nilainya sama dengan nilai yang kita cari, lebih besar atau lebih kecil, yang dari sini kita tahu paruh mana yang akan kita cari berikutnya. Dan begitu seterusnya, hingga besar list yang akan dicari berkurang menjadi 0. Ini adalah definisi rekursif, dan kita bisa membuat subrutin rekursif untuk mengimplementasikannya. Sebelumnya, ada dua pertimbahangan yang harus kita masukkan ke dalam perhitungan kita, yang merupakan fakta tentang subrutin rekursif. Pertama, algoritma pencarian biner dimulai dengan mengecek "elemen tengah suatu list". Apa yang terjadi jika list tersebut kosong? Jika tidak ada elemen di dalam list, maka kita tidak mungkin melihat elemen di tengahnya. Atau dengan kata lain, ini disebut "kondisi awal" untuk mengecek elemen di tengah list, yaitu memiliki list yang tidak kosong. Apa yang terjadi kita ternyata harus mencari nilai di list kosong? Jawabannya mudah : Kita bisa mengatakan bahwa nilai yang kita cari tidak ada di dalam list. List kosong adalah kasus dasar untuk algoritma pencari biner. Kasus dasar untuk algoritma rekursif adalah kasus yang akan ditangani secara langsung, bukan dilakukan secara rekursif. Algoritma pencarian biner memiliki kasus dasar lain, yaitu jika kita menemukan nilai yang kita cari di tengah suatu list, maka program tersebut selesai. Kita tidak perlu melakukan rekursi lebih lanjut. Pertimbangan kedua adalah parameter subrutin tersebut. Dalam subrutin non-rekursif dari pencarian biner yang dibahas sebelumnya, parameternya adalah suatu array. Akan tetapi dalam pendekatan rekursif, kita harus bisa menerapkan subrutin secara rekursif hanya sebagian dari list aslinya. Pada subrutin aslinya yang non-rekursif, kita melakukan pencarian di seluruh array, sedangkan subrutin rekursif harus bisa mencari di sebagian array. Parameter subrutin tersebut harus bisa memberi tahu di bagian mana array akan dicari. Berikut ini adalah algoritma pencarian biner rekursif yang mencari suatu nilai dalam bagian dari array integer: static int cariBiner(int[] A, int idksRendah, int idksTinggi, int nilai) { //

Cari

"nilai"

pada

array

"A"

dari

posisi

"idksTinggi", // Asumsinya adalah array diurut dalam urutan menaik // Jika nilai ditemukan kembalikan indeks pada array

"idksRendah"

ke

// dimana nilai tersebut berada. Jika tidak kembalikan -1 if (idksRendah > idksTinggi) { // Artinya list kosong karena seharusnya idksRendah lebih rendah // dari idksTinggi. "Nilai" tidak mungkin ada di list kosong. return -1; } else { // Cek elemen di tengah list. Jika nilai sama dengan isi elemen // tengah, maka kembalikan posisi tersebut. // Jika tidak, cari secara rekursif di awal atau akhir // dari setengah list int idksTengah = (idksRendah + idksTinggi) / 2; if (nilai == A[idksTengah]) return idksTengah; else if (nilai < A[idksTengah]) return cariBiner(A, idksRendah, idksTengah - 1, nilai); else

// nilai > A[idksTengah] return cariBiner(A, idksTengah + 1, idksTinggi, nilai);

} } // akhir cariBiner()

Dalam rutin di atas, parameter idksRendah dan idksTinggi menyatakan bagian array yang akan dicari. Untuk mencari keseluruhan array, kita hanya perlu memanggil cariBiner(A, 0, A.length - 1, nilai).

Dalam kedua kasus dasar -- yaitu tidak ada

elemen di dalam rentang indeks yang diberikan dan ketika tidak ada nilai yang ditemukan di tengah-tengah rentang tersebut -- subrutin dapat memberikan jawabannya secara langsung, tanpa rekursi. Pada kasus lain, subrutin akan memanggil dirinya sendiri secara rekursif untuk menghitung dan mengembalikan hasilnya. Banyak orang yang merasa sulit untuk memahami bagaimana rekursi bekerja. Kuncinya ada 2 hal yang harus dipenuhi agar rekursi bisa bekerja dengan benar : 

Harus ada minimum satu kasus dasar, yang bisa ditangani tanpa menggunakan rekursi.



Jika subrutin dilakukan secara rekursif, ia harus dipanggil dalam lingkup yang lebih kecil, makin kecil hingga mendekati kasus dasarnya.

Satu kesalahan umum yang terjadi ketika menulis subrutin rekursif adalah jika kita melanggar salah satu dari kedua aturan di atas. Jika aturan ini dilanggar, hasilnya bisa jadi

rekursi tak hingga, di mana subrutin tersebut akan memanggil dirinya terus menerus tanpa henti, karena tidak pernah mencapai kasus dasarnya. Rekrusi tak hingga mirip dengan perulangan yang tak pernah berhenti. Akan tetapi karena setiap panggilan rekursif menggunakan memori komputer, maka program yang tersangkut di dalam rekursi tak hingga, pada akhirnya akan kehabisan memori. Pencarian biner dapat diimplementasikan dengan perulangan while selain dengan menggunakan rekursi. Sekarang mari kita lihat suatu masalah yang lebih mudah diselesaikan dengan rekursi tapi sulit dilakukan dengan metode lain. Berikut ini adalah contoh yang biasa digunakan, yand dinamakan "Menara Hanoi". Persoalannya dapat dituliskan sebagai berikut : sebuah tumpukan piringan dengan ukuran berbeda ditumpuk dari urutan terbesar di bagian paling bawah hingga terkecil di bagian paling atas. Seluruh piringan harus dipindahkan dari satu tiang ke tiang lain, dengan dua aturan 

dalam setiap langkah hanya boleh memindahkan satu piringan, dan



piringan yang lebih besar tidak boleh diletakkan di atas piringan yang lebih kecil.

Ada tiang lain yang berfungsi sebagai tiang cadangan, dan bisa digunakan sebagai tempat sementara. Gambar berikut (atas) mengilustrasikan tumpukan 10 piringan. Gambar lainnya (bawah) adalah ilustrasi setelah beberapa langkah telah dijalankan.

Kita akan memindahkan 10 piringan dari tiang 0 ke tiang 1, dan tiang 2 bisa dijadikan cadangan. Bisakah kita mengurangi persoalan ini menjadi persoalan yang sama dengan

skala yang lebih kecil? Mungkin kita harus sedikit mengeneralisir persoalannya sehingga kita bisa melihat lebih jelas. Jika ada N piringan pada tiang 0, kita tahu bahwa pada akhirnya kita haris memindahkan piringan paling bawah dari tiang 0 ke tiang 1. Akan tetapi sebelum itu, menurut aturan di atas, piringan 0 hingga N-1 harus dipindahkan terlebih dahulu ke tiang 2. Setelah kita pindahkan piringan ke-N ke tiang 1, maka kita harus memindahkan kembali N-1 piringan dari tiang 2 ke tiang 1 untuk menyelesaikan masalahnya. Lihat bahwa memindahkan N-1 piringan adalah persoalan yang sama seperti memindahkan N piringan, akan tetapi sekarang persoalannya menjadi lebih kecil. Ini bisa dilakukan dengan mudah dengan rekursi. Suatu persoalan harus digeneralisir terlebih dahulu, di sini kita lihat bahwa persoalan yang lebih kecil adalah memindahkan piringan dari tiang 0 ke tiang 2 dan kemudian dari tiang 2 ke tiang 1, bukan dari tiang 0 ke tiang 1. Untuk subrutin rekursiif yang akan kita buat, kita harus menyatakan tiang asal, tiang tujuan, dan tiang cadangannya. Kasus dasarnya adalah jika hanya ada satu piringan yang akan dipindahkan, yang mana jawabannya mudah : pindahkan satu piringan itu dalam satu langkah. Berikut ini adalah contoh subrutin untuk menyelesaikan masalah ini : void MenaraHanoi(int piringan, int asal, int tujuan, int cadangan) { // Memecahkan persoalan untuk memindahkan sejumlah "piringan" // dari tiang "asal" ke tiang "tujuan". Tiang "cadangan" bisa // digunakan sebagai tempat sementara if (piringan == 1) { // Hanya ada satu piringan, pindahkan langsung System.out.println("Pindahkan piringan dari tiang " + asal + " ke tiang " + tujuan); } else { // Pindahkan semua piringan minus 1 ke tiang cadangan, // kemudian pindahkan piringan paling bawah ke tiang tujuan, // kemudian pindahkan sisanya dari tiang cadangan ke // tiang tujuan. MenaraHanoi(piringan-1, asal, cadangan, tujuan); System.out.println("Pindahkan piringan dari tiang " + asal + " ke tiang " + tujuan); MenaraHanoi(piringan-1, cadangan, tujuan, asal); } }

Subrutin ini mengekspresikan solusi persoalan secara alami. Rekursi bisa bekerja dengan benar karena setiap panggil rekursif selalu akan dipanggil dengan jumlah piringan yang semakin sedikit. Dan ketika sampai pada kasus dasarnya, yaitu hanya ada satu piringan, persoalannya bisa diselesaikan langsung dengan memindahkan satu piringan tersebut ke tiang tujuannya. Untuk memecahkan persoalan ini pada "level paling atas", yaitu memindahkan N piringan dari

tiang

0

ke

tiang

1,

subrutin

ini

bisa

dipanggil

dengan

perintah

MenaraHanoi(N,0,1,2).

Ceritanya, dahulu kala ada kisah yang merupakan nama dari persoalan ini. Menurut cerita ini, pada saat bumi pertama kali dicipkatan, sekumpulan biksu pada suatu menara di dekat Hanoi diberi tumpukan 64 piringan dan diberi tugas untuk memindahkan satu piringan setiap hari dengan aturan yang sama seperti di atas. Pada hari ketika tugas ini selesai, alam semesta akan kiamat. Tapi tenang saja, karena jumlah langkah yang diperlukan untuk menyelesaikan tugas ini untuk N piringan adalah 2N - 1, dan 264 - 1 hari sama dengan lebih dari 50 trilyun tahun. Pengurutan Cepat Aplikasi rekursi yang cukup populer adalah Pengurutan Cepat (Quicksort) yang digunakan untuk mengurutkan array. Di bagian sebelumnya kita telah melihat bagaimana mengurutkan array dengan menggunakan pengurutan pilihan dan pengurutan penyisipan yang relatif lebih mudah, akan tetapi akan berjalan lebih lambat untuk array yang besar. Algoritma pengurutan yang lebih cepat sudah tersedia. Salah satunya adalah pengurutan cepat (quick sort), yaitu algoritma rekursif yang ternyata paling cepat hampir pada segala kondisi. Algoritma pengurutan cepat dibuat berdasarkan ide yang sederhana namun cerdas : Dari beberapa item, pilih satu item. Item ini kita sebut pivot. Pindahkan semua item yang lebih kecil dari pivot ke awal array, dan pindahkan item yang lebih besar ke akhir array. Kemudian letakkan pivot di tengah-tengah kedua grup tersebut. Atau dengan kata lain, posisi pivot adalah posisi terakhir dan tidak perlu dipindahkan lagi.

LangkahUrutCepat bukan algoritma rekursif. Kecepatan pengurutan cepat tergantung dari kecepatan LangkahUrutCepat. Karena ini bukan diskusi utama kita, kita akan tuliskan algoritma LangkahUrutCepat tanpa diskusi lebih lanjut. static int LangkahUrutCepat(int[] A, int rendah, int tinggi) { // Jalankan LangkahUrutCepat pada array dengan indeks // antara rendah dan tinggi pada array A. Nilai yang dikembalikan // adalah posisi akhir pivot dalam array // Kita ambil sembarang pivot, yaitu pada indeks pertama int pivot = A[rendah]; // Nilai antara rendah dan tinggi adalah nilai yang belum pernah // kita uji. Kurangi tinggi dan naikkan rendah hingga keduanya // bernilai sama, pindahkan nilai yang lebih besar dari pivot // sehingga nilai tersebut berada di atas tinggi dan pindahkan // nilai yang lebih kecil dari pivot sehingga nilainya berada // di bawah rendah. Ketika kita mulai, A[rendah] adalah tempat // kosong, karena ini adalah posisi awal nilai pivot while (tinggi > rendah) { while (tinggi > rendah && A[tinggi] > pivot) { // Pindahkan tinggi hingga melewati nilai yang lebih rendah // dari pivot. Nilai ini tidak perlu dipindahkan hi--; } if (tinggi == rendah) break;

// Nilai pada A[tinggi] kurang dari pivot.

Pindahkan ke tempat

// kosong pada A[rendah], sehingga tempat di A[tinggi] // menjadi kosong A[rendah] = A[tinggi]; rendah++; while (tinggi > rendah && A[rendah] < pivot) { //

Pindahkan

rendah

hingga

melewati

nilai

yang

lebih

tinggai // pivot. Nilai ini tidak perlu dipindahkan rendah++; } if (tinggi == rendah) break; // Nilai A[rendah] lebih tinggi dari pivot. Pindahkan ke tempat // kosong pada A[tinggi], sehingga tempat di A[rendah] // menjadi kosong. A[tinggi] = A[rendah]; tinggi--; } // akhir while // Di sini, rendah sama dengan tinggi, dan ada tempat kosong // di sini. Posisi ini berada di antara nilai yang lebih tinggi dan // nilai yang lebih rendah dari pivot. Letakkan pivot di sini // dan kembalikan posisinya. A[rendah] = pivot; return rendah; }

// akhir LangkahUrutCepat

Degan subrutin ini, maka pengurutan cepat mudah dilakukan. Algoritma untuk mengurutkan deretan nilai yaitu dengan menjalankan LangkahUrutCepat pada nilai-nilai tersebut, kemudian menjalankan pengurutan cepat secara rekursif terhadap item yang ada di sebelah kiri pivot dan item yang ada di sebelah kanan pivot. Tentunya kita juga

membutuhkan kasus dasar. Yaitu jika list hanya memiliki satu item atau kosong, maka list tersebut telah diurutkan. static void urutcepat(int[] A, int rendah, int tinggi) { // Jalankan pengurutan cepat untuk mengurutkan array // antara posisi rendah dan posisi tinggi dalam urutan naik if (tinggi <= rendah) { // List memiliki panjang nol atau 1. Tidak ada yang perlu // dilakukan, jadi kita keluar dari subrutin return; } else { // Jalankan LangkahUrutCepat dan dapatkan posisi pivot // Kemudian jalankan urutcepat untuk mengurut item sebelum // pivot dan item setelah pivot int posisiPivot = LangkahUrutCepat(A, rendah, tinggi); urutcepat(A, rendah, pivotPosition - 1); urutcepat(A, pivotPosition + 1, tinggi); } }

Seperti biasa, kita telah melihat masalah dengan mengeneralisirnya. Masalah awalnya adalah untuk mengurutkan array, akan tetapi algoritma rekursif dibuat untuk mengurutkan sebagian array. Untuk mengurut keseluruhan array A, kita bisa menggunakan urutcepat()

yaitu dengan perintah urutcepat(A, 0, A.length -1).

Struktur Data Berantai Pada bagian ini kita akan melihat teknik pemrograman tingkat lanjut lainnya, yaitu struktur data berantai (linked data structure), dan applikasinya. Suatu referensi ke suatu objek bisa disimpan sebagai variabel instansi di objek lain, sehingga "terkait" satu sama lain. Struktur data kompleks bisa dibuat dengan mengaitkan satu objek dengan objek lainnya menjadi struktur data berantai. Yang menarik adalah apabila objek ini dikaitkan dengan objek lain yang memiliki kelas yang sama. Di sini kelas tersebut digunakan dalam definisi kelas yang sama. Beberapa jenis struktur data bisa dibuat dengan menggunakan model semacam ini. Mengaitkan Objek Hampir semua objek memiliki variabel instansi. Jika variabel instansi bertipe suatu kelas atau interface, maka variabel instansi itu bisa menyimpan referensi ke objek lain. Referensi disebut juga pointer, karena referensi menunjuk pada suatu objek. (Variabel yang berisi

referensi ke suatu objek juga bisa berisi null alias tidak menunjuk ke mana-mana). Jika satu objek memiliki referensi ke objek lain, objek itu disebut terkait satu sama lain. Struktur data kompleks bisa dibuat dengan mengaitkan objek satu sama lain. Jika suatu objek memiliki pointer ke objek lain dengan tipe yang sama, maka definisi kelasnya bersifat rekursif. Rekursi jenis ini banyak terjadi, misalnya kelas Pegawai yang melambangkan pegawai di suatu perusahaan. Semua orang kecuali bos tertinggi memiliki atasan, di mana atasannya ini adalah juga pegawai perusahaan tersebut. Tentunya kelas Pegawai

memiliki variabel instansi dengan tipe Pegawai yang menunjuk pada atasan

pegawai itu, sehingga : class Pegawai { // Objek untuk menyimpan data tentang seorang pegawai String nama; Pegawai atasan;

// Nama pegawai // Atasan pegawai ini

. .

// (Metode dan variabel instansi lain.)

. } // akhir kelas Pegawai

Jika pgw adalah variabel bertipe Pegawai, maka pgw.atasan adalah variabel lain yang juga bertipe Pegawai. Jika pgw menunjuk pada bos tertinggi, maka pgw.atasan berisi null

yang artinya ia tidak memiliki atasan. Kita bisa mencetak nama atasan seorang

pegawai, misalnya dengan pernyataan Java berikut : if ( pgw.atasan == null) { System.out.println( pgw.nama " adalah bos tertinggi." ); } else { System.out.print( "Atasan dari " + pgw.nama + " ialah " ); System.out.println( pgw.atasan.nama ); }

Sekarang, misalnya kita ingin tahu berapa tingkat di atas seorang pegawai hingga sampai pada bos tertinggi. Jika bisa melacak atasan dari atasannya, dan seterusnya, hingga sampai pada bos tertinggi, kemudian menghitung berapa langkah yang diperlukan hingga sampai ke bos tertinggi itu: if ( pgw.atasan == null ) { System.out.println( pgw.nama " adalah bos tertinggi." ); } else {

Pegawai pointer;

// Untuk menunjuk pada urutan bos.

pointer = pgw.supervisor; if ( pointer.atasan == null) { System.out.println( pgw.nama + " memiliki atasan langsung bos tertinggi." ); } else { int level = 0; while ( pointer.atasan != null ) { level++;

// Level atasan

pointer = pointer.atasan; } System.out.println( "Ada " + level + " atasan antara " + pgw.nama + " dan bos tertinggi." ); } }

Ketika perulangan while dieksekusi, pointer akan menunjuk pada atasan pgw, kemudian atasannya lagi, dan seterusnya. Variabel level dinaikkan 1 setiap kali pointer menunjuk pada atasan baru. Perulangan selesai ketika pointer.atasan berisi null yang artinya pointer telah sampai pada bos tertinggi. Pada saat itu, level telah mencatat berapa level yang dibutuhkan dari pgw ke bos tertinggi. Dalam contoh ini, variabel atasan terlihat natural dan berfungsi dengan baik. Sebenarnya, struktur data yang dibangun dengan mengaitkan objek satu sama lain sangat berguna, sehingga sering digunakan sebagai topik pembahasan dalam ilmu komputer. Kita akan melihat beberapa contohnya. Pada bagian ini dan berikutnya, kita akan melihat yang dinamakan list berantai (linked list).

List berantai merupakan rantai objek yang bertipe sama, yang terkait oleh pointer dari satu objek ke objek lain. Mirip dengan hirarki organisasi antara pgw hingga bos tertinggi pada contoh di atas. Kita bisa juga memiliki siatuasi yang lebih kompleks di mana satu objek berisi pointer ke beberapa objek. Kita akan lihat contohnya di bagian berikutnya. Di bagian ini, list berantai akan dibuat dari objek yang bertipe Simpul yang didefinisikan sebagai berikut : class Simpul { String item; Simpul berikut; }

Istilah simpul sering digunakan untuk menyebut salah satu objek di dalam struktur data berantai. Objek dengan tipe Simpul bisa disambung seperti pada gambar di atas. Simpul terakhir dalam list tersebut bisa ditentukan apabila variabel instansi berikut berisi null. Meskipun Simpul pada contoh ini terlihat sederhana, kita bisa menggunakannya untuk mengilustrasikan operasi umum pada list berantai. Operasi umumnya meliputi menghapus simpul dari list, menyisipkan simpul baru ke dalam list, dan mencari String pada item di dalam list. Kita akan lihat beberapa subrutin yang melakukan operasi ini. Agar list berantai bisa digunakan dalam program, program tersebut perlu variabel untuk menunjuk pada simpul pertama dari list. Variabel itu hanya perlu menunjuk pada simpul

pertama, karena simpul lainnya bisa dicari dari simpul tertama kemudian mengurutkan melalui pointer ke simpul berikutnya.

Kita bisa membuat objek baru dengan misalnya bernama "ListString" yang memiliki variabel instansi bernama "kepala". Variabel ini bertipe Simpul dan menyimpan referensi ke simpul pertama dari list berantai. Jika listnya kosong, maka kepala berisi null. public class ListString { Simpul kepala; . . . // metode dan variabel instansi lainnya }

Misalnya kita ingin tahu apakah suatu string, itemDicari ada di salah satu simpul di dalam list. Kita bisa membandingkan itemDicari dengan isi setiap simpul di dalam list. Caranya, kita akan menggunakan variabel bertipe Simpul yang bernama pointer untuk digunakan sebagai penunjuk ke simpul-simpul yang akan kita lihat. Kita hanya bisa mengakses list melalui variabel kepala, jadi kita bisa mulai dengan mengisi pointer dengan isi kepala. Simpul pointer = kepala;

// Mulai dari simpul pertama.

Kita harus membuat variabel baru ini karena kita akan mengganti isinya pada saat melakukan pencarian. Kita tidak bisa mengganti isi kepala, karena jika kita ganti, kita akan kehilangan jejak list yang kita buat. Untuk pindah dari satu simpul ke simpul berikutnya, kita cukup menggunakan perintah pointer = pointer.berikut;. Kita akan tahu bahwa kita telah sampai pada akhir list jika pointer bernilai null. Semuanya bisa kita tuangkan dalam metode instansi cari() pada kelas ListString sebagai berikut : public boolean cari(String itemDicari) { // Kembalikan true jika itemDicari ada di dalam list // false jika tidak ada dalam list.

Simpul pointer;

// Pointer untuk menelusuri list

pointer = kepala; // Mulai pencarian dari kepala list (kepala adalah variabel instansi) while ( pointer != null ) { // Lihat isi simpul satu per satu. Jika isinya sama dengan // yang kita cari, kembalikan true, jika tidak // teruskan pencarian di simpul berikutnya if ( pointer.item.equals(itemDicari) ) return true; pointer = pointer.berikut;

// Pindah ke simpul berikutnya

} // Di sini, kita telah sampai pada akhir list // akan tetapi tidak ada item yang kita cari. // Kembalikan false, yang artinya kita tidak menemukan item ini. return false; } // akhir cari()

Pola di atas akan sering digunakan nanti: Jika kepala adalah variabel yang menunjuk pada suatu list berantai, maka untuk proses semua simpul dalam list, kita bisa lakukan dengan : pointer = kepala; while ( pointer != null ) { . .

// proses simpul yang ditunjuk oleh pointer

. pointer = pointer.berikut; }

Mungkin saja listnya kosong, yaitu apabila isi kepala adalah null. Dalam contoh kode di atas, jika kepala berisi null, maka badan perulangan while tidak akan dieksekusi sama sekali, karena kondisi perulangan hanya bisa dijalankan apabila pointer bernilai null. Menyisipkan item baru ke dalam list sedikit lebih sulit. Dalam kelas ListString, item pada simpul dibuat dalam urutan menaik. Jika suatu item ditambahkan ke dalam list, item tersebut harus ditempatkan pada posisi yang tepat sesuai urutannya. Artinya, kita harus menyisipkan item baru ditengah-tengah list, di antara dua simpul yang sudah ada.

Supaya mudah, kita membutuhkan dua variabel dengan tipe Simpul, di mana masingmasing menunjuk pada 2 posisi di mana item baru akan disisipkan di antaranya. Pada ilustrasi berikut, variabel ini adalah sebelum dan pointer. Variabel lain, yaitu simpulBaru

menyimpan referensi ke simpul baru yang akan disisipkan. Untuk melakukan

penyisipan, hubungan antara sebelum dan pointer harus diputus, dan kait baru dari sebelum

ke simpulBaru dan dari simpulBaru ke pointer harus dibuat.

Perintah

"sebelum.berikut

sebelum.berikut pointer"

=

simpulBaru;"

digunakan

untuk

membuat

menunjuk pada simpul baru. Dan perintah " simpulBaru.berikut =

digunakan untuk membuat simpulBaru.berikut menunjuk pada pointer.

Akan tetapi, sebelum kita menjalankan perintah ini, kita harus menempatkan posisi sebelum

dan pointer pada tempat yang benar terlebih dahulu (seperti pada ilustrasi di

atas). Kita akan mulai dari awal list, kemudian pindah ke simpul berikutnya selama isinya lebih kecil dari item baru. Ketika kita memindahkan pointer dari satu tempat ke tempat berikutnya, hati-hati bahwa kita bisa sampai di akhir list tanpa kita sadari. Artinya kita tidak bisa meneruskan lagi apabila pointer sampai ke akhir list, yaitu ketika pointer.next

bernilai null.

Jika sisipItem adalah item item yang akan disisipkan, maka kita asumsikan bahwa item ini harus berada di dalam list. Kode berikut akan menempatkan posisi sebelum dan pointer dengan tepat:

Simpul pointer, sebelum; sebelum = kepala;

// Mulai di awal list

pointer = kepala.berikut; while ( pointer != null && pointer.item.compareTo(sisipItem) < 0 ) { sebelum

=

//

pointer;

bisa

juga

menggunakan

"sebelum

=

sebelum.berikut" pointer = pointer.berikut; }

(Kode di atas menggunakan compareTo() dari kelas String untuk menguji apakah item di dalam node bernilai kurang dari item yang akan disisipkan.) Kode di atas boleh-boleh saja, akan tetapi asumsi kita untuk menyisipkan node baru di tengah-tengah list tidak selamanya benar. Mungkin saja sisipItem lebih kecil dari item pertama. Artinya, simpul baru harus disisipkan pada kepala list. Ini bisa dilakukan dengan instruksi berikut : simpulBaru.berikut = kepala;

// Buat simpulBaru.next menunjuk kepala

lama kepala = simpulBaru;

// Buat simpulBaru sebagai kepala list yang

baru

Atau bisa saja listnya kosong. Artinya, simpulBaru menjadi simpul pertama dan satusatunya di dalam list. Ini bisa dilakukan dengan mengisi kepala = simpulBaru. Metode sisip()

berikut ini merangkum semua kemungkinan di atas :

public void sisip(String sisipItem) { // Tambah sisipItem ke dalam list. Boleh menyisipkan // kopi yang sama Simpul simpulBaru;

// Simpul baru yang berisi item baru

simpulBaru = new Simpul(); simpulBaru.item = sisipItem;

// (N.B.

isi simpulBaru.berikut masih

null) if ( kepala == null ) { // List masih kosong // Buat kepala menunjuk ke simpulBaru kepala = simpulBaru; } else if ( kepala.item.compareTo(sisipItem) >= 0 ) { // Item baru kurang dari item pertama list // Jadi item baru harus disisipkan sebelum kepala list simpulBaru.berikut = kepala;

kepala = simpulBaru; } else { // Item baru akan disisipkan di tengah-tengah list setelah // item pertama. Cari posisi yang tepat dan sisipkan di sana Simpul pointer;

// Simpul untuk menelusuri list

Simpul sebelum;

// Simpul yang menunjuk pada posisi sebelum

pointer sebelum = kepala; // Set sebelum ke kepala list dan pointer ke posisi setelahnya pointer = kepala.berikut; while (pointer != null && pointer.item.compareTo(sisipItem) < 0) { // Pindahkan sebelum dan pointer ke posisi berikutnya hingga pointer // sampai di akhir list atau sampai pada item yang isinya lebih besar //

dari

sisipItem.

Setelah

perulangan

selesai,

pointer

menunjuk // pada posisi di mana sisipItem akan disisipkan sebelum = pointer; pointer = pointer.berikut; } simpulBaru.berikut = pointer;

// Sisipkan simpulBaru setelah

"sebelum" sebelum.berikut = simpulBaru; } }

// akhir sisip()

Jika Anda memperhatikan dengan seksama diskusi di atas, mungkin Anda akan ingat bahwa ada satu kasus lagi yang tidak pernah disebutkan. Apa yang terjadi jika simpul baru harus disisipkan di akhir list? Ini terjadi jika semua item di dalam list lebih kecil daripada item baru. Sebenarnya, kasus ini sudah ditangani dengan benar oleh subrutin, yaitu di bagian akhir pernyataan if . Jika sisipItem lebih besar dari semua item di dalam list, maka perulangan while

akan berhenti ketika pointer selesai menelusuri sampai pada akhir list hingga

pointer

bernilai null. Akan tetapi, ketika ini terjadi, sebelum masih tetap menunjuk pada

item terakhir pada list. Perintah sebelum.berikut = simpulBaru menambahkan simpul baru

di

akhir

list.

Karena

isi

pointer

adalah

null,

maka

perintah

[code]simpulBaru.berikut = pointer null. null adalah

akan mengisi simpulBaru.berikut dengan

nilai yang tepat untuk menandakan akhir list.

Operasi untuk menghapus mirip dengan operasi menyisipkan item, meskupun sedikit lebih mudah. Masih ada beberapa kasus khusus yang harus dipikirkan. Ketika simpul pertama akan dihapus, maka isi kepala harus diubah ke simpul kedua. Karena kepala.berikut adalah simpul berikutnya, maka ini bisa dilakukan dengan perintah kepala kepala.berikut. kepala.berkut

=

(Sekali lagi, perhatikan bahwa perintah ini juga berlaku jika

berisi null[code], yaitu ketika hanya ada satu item di dalam

list. Ketika satu-satunya item ini dihapus, maka list bernilai [code]null

yang artinya list sudah kosong.) Jika simpul yang akan dihapus ada di tengah-tengah list, maka kita bisa membuat variabel sebelum

dan pointer di mana pointer menunjuk pada simpul yang akan dihapus, dan

sebelum

menunjuk pada simpul sebelumnya. Setelah diposisikan dengan benar, perintah

"sebelum.berikut = pointer.berikut" akan menghapus simpul tersebut. Simpul yang dihapus akan diambil oleh pemulung memori. Berikut ini adalah kode lengkap dari metode hapus() : public boolean hapus(String hapusItem) { // Jika hapusItem ada dalam list, hapus. // Kembalikan true jika string ditemukan dan dihapus. // Jika string tidak ditemukan kembalikan false. // (Jika ada beberapa item dengan isi yang sama, hanya // hapus yang pertama) if ( kepala == null ) { // Jika list kosong, sudah pasti tidak ada string hapusItem return false; } else if ( kepala.item.equals(hapusItem) ) { // Jika hapusItem ada pada simpul pertama, hapus. kepala = kepala.berikut; return true; } else { // Di sini, maka ada kemungkinan string terdapat // di tengah-tengah list. Cari itemnya di dalam list. Simpul pointer;

// Simpul untuk menelusuri list

Simpul sebelum; sebelum = kepala;

// Selalu menunjuk pada simpul sebelum pointer // Mulai dari awal list

pointer = kepala.berikut; while (pointer != null && pointer.item.compareTo(hapusItem) < 0) { // Pindahkan sebelum dan pointer di dalam list hingga // pointer sampai pada akhir list atau sampai pada item yang // lebih besar atau sama dengan hapusItem. Ketika perulangan // selesai, pointer menunjuk pada posisi di mana hapusItem // seharusnya berada (jika ada) sebelum = pointer; pointer = pointer.berikut; } if ( pointer != null && pointer.item.equals(hapusItem) ) { // Pointer menunjuk pada simpul yang akan dihapus // Hapus dengan mengubah simpul sebelumnya sebelum.berikut= pointer.berikut; return true; } else { // Item yang dicari tidak ada return false; } } } // akhir hapus()

Tumpukan List berantai adalah salah satu jenis struktur data, yang tersusun dari objek yang terkait satu sama lain oleh pointer. Pada bagian sebelumnya, kita menggunakan list berantai untuk menyimpan String terurut, dan kita juga mengimplementasikan operasi sisip, hapus dan cari

pada list tersebut.

Akan tetapi kita juga bisa menyimpan list String pada array atau ArrayList. Kita bisa juga mengimplementasikan operasi sisip, hapus, dan cari. Implementasi operasi tersebut akan berbeda, akan tetapi antar muka dan perilakunya akan tetap sama. Istilah tipe data abstrak (abstract data type, atau ADT) adalah kumpulan nilai dan operasi yang bisa dilakukan pada nilai tersebut, tanpa perlu mengetahui bagaimana nilai tersebut disimpan dan bagaimana operasi tersebut diimplementasikan.

Suatu "list terurut yang berisi string" adalah contoh tipe data abstrak. Ada banyak cara untuk mengimplementasikan tipe data abstrak yang sama, misalnya seperti disebut di atas, list terurut berisi string bisa diimplementasikan dalam bentuk list berantai atau array. Program yang menggunakan tipe data ini bisa menggunakannya tanpa mengetahui dengan detail tentang implementasinya. Lebih jauh, implementasi TDA bisa diganti tanpa mempengaruhi jalannya program secara keseluruhan. Dengan cara ini, program bisa lebih mudah untuk dipelihara dan didebug. TDA adalah alat penting dalam rekayasa perancang lunak. Pada bagian ini dan yang akan datang, kita akan lihat TDA lain, yaitu tumpukan dan antrian. Tumpukan dan antrian sering diimplementasikan dalam bentuk list berantai, akan tetapi ini bukan satu-satunya cara implementasi. Mari kita anggap bagian ini sebagai studi kasus dari TDA. Tumpukan (stack) terdiri dari kumpulan item yang disusun sedemikian rupa sehingga satu item ditumpuk di atas item lainnya, mirip seperti tumpukan boks. Hanya item paling atas yang bisa diakses pada suatu saat. Item tersebut bisa diambil dari tumpukan dengan operasi yang disebut "ambil" (atau dalam bahasa Inggris, istilah untuk mengeluarkan item dari tumpukan disebut "pop"). Item di bawah hanya bisa diambil jika semua item di atasnya telah dikeluarkan dari tumpukan. Suatu item hanya bisa ditambahkan di atas tumpukan dengan perintah "dorong" (atau "push"). Kita bisa membuat tumpukan dari berbagai macam data. Misalnya, jika itemnya bertipe int, maka operasi dorong dan keluar bisa diimplementasikan dalam metode instansi void dorong(int itemBaru) int ambil()

// Tambah itemBaru di atas tumpukan

// Mengambil int paling atas pada tumpukan

Kita tidak bisa mengambil item dari tumpukan yang kosong, jadi kita juga perlu memberi tahu apakah suatu tumpukan kosong atau tidak. Kita perlu operasi lain untuk mengujinya, yang diimplementasikan dalam metode instansi boolean isKosong()

// Kembalikan true jika tumpukan kosong

Ilustrasi berikut menggambarkan tumpukan int, sebagai tipe data abstrak. TDA ini bisa diimplementasikan dengan berbagai cara, akan tetapi gambar tumpukan di dalam imaginasi kita akan tetap sama.

Pada implementasi dengan list berantai, tumpukan atas adalah simpul kepala dari list. Kita bisa menambah dan mengurangi simpul pada kepala list berantai -- jauh lebih mudah daripada menyisipkan atau menghapus simpul dari tengah-tengah list. Berikut ini adalah kelas "tumpukan int" yang mengimplementasikan TDA menggunakan list berantai. (Kelas ini menggunakan kelas bertingkat sebagai kelas simpul dari list berantai. Lihat bagian sebelumnya tentang kelas bertingkat. Jika Anda masih belum paham atau merasa tidak nyaman menggunakan kelas bertingkat, Anda bisa juga memisahkannya sebagai kelas terpisah.) public class TumpukanInt { private static class Simpul { // Objek dengan tipe Simpul menyimpan // satu item di dalam list berantai int item; Simpul berikut; } // Referensi ke simpul paling atas dari tumpukan //

jika atas == null, maka tumpukan tidak berisi

//

apa-apa (kosong)

private Simpul atas;

public void dorong( int N ) { // Letakkan N di tumpukan paling atas Simpul atasBaru;

// Simpul baru untuk menyimpan item baru

atasBaru = new Simpul(); // Simpan N di simpul baru

atasBaru.item = N;

atasBaru.berikut = atas; atas = atasBaru;

// Simpul baru menunjuk pada atas lama // Simpul baru sekarang menjadi atas

} public int ambil() { // Ambil item paling atas dari dalam tumpukan // dan kembalikan nilainya. Catatan bahwa rutin ini akan // melempar NullPointerException jika kita mencoba untuk // mengambil item dari tumpukan kosong int itemAtas = atas.item;

// Item yang akan diambil

atas = atas.berikut;

// Item yang dulunya di posisi kedua

sekarang di atas return itemAtas; } public boolean isKosong() { // Kembalikan true jika tumpukan kosong. //

Kembalikan

false

jika

ada

satu

atau

lebih

item

di

dalam

tumpukan return (atas == null); } } // akhir kelas TumpukanInt

Anda perlu memahami bagaimana operasi dorong dan ambil dilaksanakan. Mungkin sedikit oret-oretan akan membantu. Lihat bahwa list berantai merupakan bagian private dari kelas TumpukanInt. Program yang menggunakan kelas ini tidak perlu tahu bahwa list berantai digunakan dalam implementasinya. Sekarang, kita bisa juga mengimplementasikan tumpukan dalam bentuk array, bukan hanya list berantai. Karena banyaknya item di dalam tumpukan bervariasi dan tidak bisa ditentukan, maka kita perlu memiliki variabel lain yang melacak berapa banyak tempat dalam array yang sudah digunakan. Jika variabel ini kita namakan atas, maka item akan disimpan dalam tumpukan pada posisi 0, 1, ..., atas - 1. Item pada posisi 0 adalah item paling bawah dalam tumpukan, sedangkan item atas - 1 adalah item paling atas.

Untuk mendorong item baru ke dalam tumpukan, kita bisa meletakkan item di posisi atas kemudian nilai atas ditambahkan 1. Jika kita tidak ingin memberi limit banyaknya item di dalam tumpukan, kita bisa menggunakan array dinamis yang telah dibahas sebelumnya. Berikut ini adalah implementasi kelas TumpukanInt dengan menggunakan array dinamis: public class TumpukanInt { private int[] item = new int[10]; private int atas = 0;

// Menyimpan item dalam tumpukan

// Banyaknya item dalam tumpukan

public void dorong( int N ) { // Tambahkan N ke dalam tumpukan if (atas == item.length) { // Array sudah penuh, jadi buat array yang lebih besar dan // kopi isi tumpukan sekarang ke dalam array baru int[] arrayBary = new int[ 2*item.length ]; System.arraycopy(item, 0, arrayBary, 0, item.length); item = arrayBaru; } // Letakkan N di tempat kosong berikutnya

item[atas] = N; atas++;

// Jumlah item bertambah 1

} public int ambil() { // Mengambil item teratas dari tumpukan dan mengembalikannya // Ingat bahwa rutin ini akan melempar pengecualian // ArrayIndexOutOfBoundsException jika mencoba mengambil // item dari tumpukan kosong int itemAtas = item[top - 1] atas--;

// Item teratas di dalam tumpukan

// Jumlah item dalam tumpukan berkurang 1

return itemAtas; } public boolean isKosong() { // Kembalikan true jika tumpukan kosong //

Kembalikan

false

tumpukan return (atas == 0); }

jika

ada

satu

atau

lebih

item

di

dalam

} // akhir kelas TumpukanInt

Sekali lagi, implementasi tumpukan (dalam bentuk array) bersifat private. Kedua versi kelas TumpukanInt bisa digunakan dalam suatu program. Jika suatu program menggunakan versi pertama, maka kita bisa menggantinya dengan versi kedua tanpa mengubah isi program lain. Akan tetapi, ada satu kasus di mana kedua kelas akan berbeda, yaitu jika mencoba mengambil item dari tumpukan kosong, maka versi pertama akan melemparkan NullPointerException sedangkan versi kedua akan melemparkan ArrayIndexOutOfBoundsException.

Mungkin akan lebih baik untuk mendefinisikan jenis pengecualian baru, misalnya EmptyStackException

di kedua versi. Dan sebetulnya TDA harusnya memberikan

spesifikasi apa yang harus dilakukan jika program mencoba mengambil item dari tumpukan kosong. Ini yang sering dilupakan ketika seseorang membuat spesifikasi untuk interface, yang akhirnya masalah lain akan muncul di kemudian hari. Apa contoh kegunaan tumpukan dalam keadaan sehari-hari? Misalnya, lihat apa yang terjadi jika suatu rutin memanggil subrutin. Rutin pertama akan dihentikan sementara ketika subrutin yang dipanggil dieksekusi, dan akan diteruskan apabila subrutin yang dipanggil selesai dijalankan. Sekarang, misalnya subrutin tersebut memanggil subrutin kedua, dan subrutin kedua memanggil subrutin ketiga, dan seterusnya. Setiap subrutin akan berhenti untuk sementara ketika subrutin berikutnya dipanggil. Komputer harus bisa melacak subrutin yang dihentikan. Bagaimana caranya? Yaitu dengan menggunakan tumpukan. Ketika subrutin dipanggil, catatan aktivasi (activation record) dibuat untuk subrutin tersebut. Catatan aktivasi ini berisi informasi yang relevan tentang eksekusi dari subruti tersebut, misalnya parameter dan variabel lokalnya. Catatan aktivasi ini ditempatkan dalam tunpukan. Catatan ini akan dibuang ketika subrutin selesai dipanggil. Jika subrutin ini memanggil subrutin lain, maka catatan aktivasi dari subrutin kedua akan didorong ke dalam tumpukan, di atas catatan aktivasi subrutin pertama. Tumpukan akan semakin besar jika semakin banyak subrutin yang dipanggil, dan semakin kecil jika subrutin-subrutin itu selesai dijalankan. Contoh lainnya, tumpukan digunakan untuk mengevaluasi ekspresi postfix (postfix expresssion). Ekspresi matematika biasa seperti 2+(15-12)*17 disebut ekspresi infix. Dalam ekspresi infix, operator berada di tengah nilai yang akan dihitung, misalnya "2 + 2".

Dalam ekspresi postfix, operator ada di akhir nilai, misalnya "2 2 +".

Ekspresi 2+(15-12)*17" dapat ditulis dalam bentuk postfix menjadi "2 15 12 - 17 * +".

Di sini operator "-" dilakukan pada dua nilai sebelumnya, yaitu "15" dan "12". Tanda *

dilakukan pada dua nilai sebelumnya, yaitu "15 12 -" dan "17". Dan operator "+" dilakukan pada 2 dan "15 12 - 17 *". Hasilnya akan persis sama dengan ekspresi infix awalnya. Meskipun lebih mudah bagi manusia untuk melakukan perhitungan dengan ekspresi infix, ekspresi postfix memiliki beberapa keuntungan. Satu hal, ekspresi postfix tidak memerlukan tanda kurung atau aturan perhitungan (tanda kali harus dilakukan lebih dulu sebelum tambah misalnya). Aturan penghitungan hanya ditentukan berdasarkan urutannya saja. Sehingga algoritma yang menghitung ekspresi postfix dapat menjalankannya dengan lebih cepat dan tepat. Sekarang misalnya kita akan menghitung ekspresi "2 15 12 - 17 * +" dari kiri ke kanan. Nilai yang kita temui pertama adalah 2, tapi apa yang bisa kita lakukan dengan 2? Di sini kita belum tahu operatornya, dan selain itu kita juga belum tahu nilai lainnya. Kita akan ingat nilai 2 ini untuk sementara, yaitu dengan mendorongnya ke dalam tumpukan. Berikutnya, kita akan melihat nilai 15, yang kita juga masukkan ke dalam tumpukan di atas nilai 2. Kemudian nilai 12 juga dimasukkan ke dalam tumpukan di atas 15. Sekarang kita sampai pada operator "-". Operasi ini dilakukan pada dua nilai sebelumnya. Kita telah menyimpan 2 nilai sebelumnya ke dalam tumpukan, yaitu 15 dan 12. Sekarang kita ambil 2 nilai tersebut dari dalam tumpukan, dan kita lakukan perhitungan 15 - 12 yaitu 3. Nilai 3 ini kita simpan lagi ke dalam tumpukan. Ingat bahwa 15 dan 12 sudah diambil dari dalam tumpukan, sehingga hanya nilai 2 yang ada di dalam tumpukan. Setelah nilai 3 dimasukkan ke dalam tumpukan, maka 3 ada di atas 2 di dalam tumpukan. Item berikutnya adalah 17, yang juga dimasukkan ke dalam tumpukan di atas nilai 3. Untuk menghitung item berikutnya "*", kita ambil 2 nilai dari dalam tumpukan, yaitu 3 dan 17. Hasil dari 3 * 17, yaitu 51 dimasukkan kembali ke dalam tumpukan (di atas 2 yang masih ada di dalam tumpukan). Item berikutnya adalah "+", yang akan mengambil 51 dan 2 dari dalam tumpukan, menghitung hasilnya, yaitu 53, kemudian menyimpannya lagi ke dalam tumpukan. Sekarang kita sampai pada akhir ekspresi. Nilai pada tumpukan itu adalah hasil perhitungan keseluruhan ekspresi. Kita cukup mengambil nilainya dan melaporkan hasilnya, yaitu 53. Algoritma untuk melakukan perhitungan ekspresi postfix adalah sebagai berikut : Mulai dengan tumpukan kosong

untuk setiap item di dalam ekspresi: jika item berupa bilangan: Dorong item ke dalam tumpukan jika item berupa operator Ambil dua nilai dari tumpukan // bisa terjadi kesalahan Lakukan perhitungan dua nilai dengan operator tersebut Dorong hasil perhitungan ke dalam tumpukan else Ada kesalahan dalam ekspresi Ambil nilai dari tumpukan Jika tumpukan tidak kosong: Ada kesalahan dalam ekspresi else: Nilai terakhir adalah hasil perhitungan

Kesalahan ekspresi dapat dideteksi dengan mudah. Misalnya, dalam ekspresi "2 3 + *", tidak cukup nilai untuk menghitung operasi "*". Ini akan dideteksi oleh algoritma ketika mencoba mengambil nilai kedua dari dalam tumpukan, karena pada saat itu tumpukan sudah kosong. Kesalahan lain bisa juga muncul ketika menghitung ekspresi " 2 3 4 +", di mana tidak cukup operator untuk menghitung semua nilai. Ini akan dideteksi ketika 2 masih ada di dalam tumpukan di akhir algoritma. Ekspresi postfix sering digunakan secara internal oleh komputer. Dan sebenarnya, mesin virtual Java adalah "mesin tumpukan", yang menggunakan tumpukan untuk melakukan perhitungan yang telah kita diskusikan. Algoritma ini bisa diperluas untuk menangani variabel dan konstanta. Ketika variabel ditemukan di dalam ekspresi, isi variabel ini didorong ke dalam tumpukan. Algoritma ini juga bisa dikembangkan untuk operator yang membutuhkan kurang atau lebih dari dua operator. Banyaknya nilai yang diambil dari dalam tumpukan bisa disesuaikan dengan berapa banyak nilai yang dibutuhkan. Misalnya, operator "-" sebagai operator negasi, misalnya "-x" hanya membutuhkan satu nilai. Antrian Antrian (queue) adalah struktur data mirip dengan tumpukan, yaitu terdiri dari item dalam urutan tertentu. Antrian memiliki dua ujung, yang disebut ujung depan dan ujung belakang. Item selalu dimasukkan dari belakang antrian, dan selalu dikeluarkan dari depan antrian. Operasi memasukkan dan mengeluarkan item dari dalam antrian disebut "masuk" dan "keluar" (dalam bahasa Inggris disebut enqueue dan dequeue).

Suatu item yang ditambahkan di belakang antrian tidak bisa dihapus sebelum item di depannya dihapus. Mirip seperti antrian pada kasir atau pada customer service di bank misalnya. Customer akan dilayani dalam urutan ketika mereka datang.

Antrian bisa menampung item dengan jenis apa saja. Untuk antrian int, operasi masuk dan keluar dapat diimplementasikan sebagai metode instansi dalam kelas "AntrianInt". Kita juga membutuhkan metode instansi untuk menguji apakah antrian kosong atau tidak: void masul(int N) int keluar()

// Tambah N di belakang antrian

// Keluarkan antrian dari depan dan kembalikan isinya

boolean isKosong()

// Kembalikan true jika antrian kosong

Antrian bisa diimplementasikan dalam bentuk list berantai atau array. Akan tetapi implementasi yang efisien dalam bentuk array sedikit lebih sulit, sehingga akan kita abaikan dalam diskusi kita. Dalam implementas dalam bentuk list berantai, item bertama adalah item di depan antrian. Untuk mengeluarkan item dari depan antrian, kita dapat lakukan seperti mengambil item dari atas tumpukan.

Belakang antrian adalah akhir dari list. Unutk memasukkan item ke dalam antrian, kita harus mengeset pointer di akhir simpul untuk menunjuk ke simpul baru yang berisi item yang akan kita tambahkan. Kita bisa menggunakan perintah seperti "buntut.berikut = simpulBaru;",

di mana buntut adalah pointer ke simpul terakhir dari list.

Jika kepala adalah pointer ke simpul pertama, maka kita bisa mendapat pointer ke simpul terakhir dengan menggunakan : Simpul buntut;

// Pointer ini akan menunjuk ke simpul terakhir

buntut = kepala;

// Mulai dari simpul pertama

while (buntut.berikut != null) { buntut = buntut.berikut; } // Di sini, buntut.berikut berisi null, artinya buntut adalah // simpul terakhir di dalam list

Akan tetapi, tentunya akan sangat tidak efisien jika kita harus melakukan perulangan terus menerus setiap kali kita memasukkan item baru ke dalam antrian. Dengan alasan efisiensi, kita akan menyimpan pointer ke akhir simpul sebagai variabel instansi. Kita harus selalu ingat untuk terus mengupdate isi variabel ini setiap kali simpul baru ditambahkan ke akhir list. Dengan pengetahuan di atas, kita bisa membuat kelas "AntrianInt" dengan mudah sebagai berikut : public class AntrianInt { private static class Simpul { // Objek bertipe Simpul berisi item dalam bentuk // list berantai int item; Simpul berikut; } // Menunjuk ke simpul pertama pada antrian // Jika antrian kosong, maka kepala berisi null private Simpul kepala = null; private Simpul buntut = null;

// Menunjuk ke simpul akhir pada

antrian void masuk( int N ) { // Menambahkan N ke akhir antrian

Simpul buntutBaru = new Simpul();

// Simpul baru untuk menampung

item baru buntutBaru.item = N; if (kepala == null) { // Antrian kosong, sehingga simpulBaru menjadi // satu-satunya simpul di dalam list. Sehingga // kepala dan buntut sama-sama menunjuk ke simpulBaru kepala = buntutBaru; buntut = buntutBaru; } else { // Simpul baru menjadi buntut antrian // (kepala tidak berpengaruh apa-apa) buntut.berikut = buntutBaru; buntut = buntutBaru; } } int keluar() { // Keluarkan item dari kepala antrian // Bisa melempar NullPointerException. int itemPertama = kepala.item; kepala = kepala.berikut;

// Sekarang item kedua menjadi kepala

if (kepala == null) { // Sekarang antrian kosong. Simpul yang telah dihapus adalah // kepala sekaligus buntut, karena simpul ini adalah satusatunya // yang ada di dalam antrian. Isi buntut dengan null. buntut = null; } return itemPertama; } boolean isKosong() { // Kembalikan true jika antrian kosong return (kepala == null); } } // akhir kelas AntrianInt

Antrian digunakan dalam komputer (dan juga dalam kehidupan nyata) ketika hanya satu item yang bisa diproses pada suatu saat, akan tetapi banyak item bisa menunggu untuk diproses, misalnya : 

Dalam Java program yang memiliki banyak threads, thread yang ingin diolah dalam CPU disimpan di dalam antrian. Ketika thread baru dimulai, thread ini ditambahkan ke dalam antrian. Thread akan dihapus dari depan antrian, diolah oleh CPU, dan kemudian -- jika belum selesai -- diletakkan kembali di belakang antrian untuk menunggu giliran berikutnya.



Event seperti ketikan tombol dan klik mouse disimpan dalam antrian yang disebut "antrian event". Program akan menghapus item dari antrian item dan mengolahnya satu per satu. Mungkin saja terjadi beberapa event diterima ketika satu event sedang diproses, akan tetapi event akan diolah berdasarkan urutan kedatangannya



ServerSocket,

memiliki antrian di dalamnya yang berisi permintaan sambungan

yang diterima akan tetapi belum dilayani. Metode accept() pada kelas ServerSocket

menerima permintaan sambungan berikutnya dari depan antrian ini.

Antrian disebut mengikuti kebijakan FIFO (First In First Out, atau Pertama Masuk Pertama Keluar). Atau dalam bahasa awam, pertama datang dan pertama dilayani. Di lain pihak, tumpukan mengikuti prinsip LIFO (Last In First Out, Terakhir Masuk Pertama Keluar). Item yang bisa keluar dari tumpukan adalah item terkakhir yang dimasukkan. Seperti antrian, tumpukan juga bisa digunakan untuk menampung item yang sedang menunggu untuk diproses (walaupun dalam aplikasi di mana antrian biasa digunakan, tumpukan adalah antrian yang tidak adil). Pohon Biner Kita telah melihat di beberapa bagian sebelumnya bagaimana objek bisa dikaitkan satu sama lain menjadi list berantai. Ketika suatu objek memiliki 2 pointer ke objek dengan tipe yang sama, kita bisa membuat struktur data yang lebih kompleks dari list berantai. Dalam bagian ini kita akan melihat salah satu struktur dasar dan paling berguna: pohon biner (binary tree). Setiap objek dalam pohon biner memiliki dua pointer, yang biasa disebut kiri dan kanan. Selain itu, tentunya simpul pada pohon memiliki data yang bisa bertipe apa saja. Misalnya, pohon biner integer bisa dibuat dalam bentuk : class SimpulPohon { int item;

// Data pada simpul ini

SimpulPohon kiri;

// Pointer ke cabang sebelah kiri

SimpulPohon kanan;

// Pointer ke cabang sebelah kanan

}

Pointer kiri dan kanan dalam SimpulPohon bisa beriis null atau menunjuk pada objek lain dengan tipe SimpulPohon. Simpul yang menunjuk pada simul lain disebut induk (parent), sedangkan yang ditunjuk disebut anak (child). Dalam gambar di atas, simpul 3 adalah induk dari simpul 6, dan simpul 4 dan 5 adalah anak dari simpul 2. Tidak semua struktur yang terdiri dari simpul pohon merupakan pohon biner. Pohon biner harus memiliki sifat : 

Harus ada satu simpul di dalam pohon yang tidak memiliki induk. Simpul ini disebut simpul akar (root).



Simpul lain harus memiliki hanya satu induk



Tidak boleh ada perulangan dalam pohon biner, artinya tidak boleh ada rantai pointer yang dimulai dari satu simpul dan berakhir di simpul yang sama.

Simpul yang tidak memiliki anak disebut simpul daun (leaf). Simpul daun dapat dikenali karena kedua pointer kiri dan kanannya berisi null. Dalam ilustrasi suatu pohon biner, biasanya simpul akar terletak di atas dan simpul daun terletak di bawah -- tidak sama seperti pohon sungguhan. Akan tetapi, kita bisa melihat cabang-cabang, seperti pohon, yang merupakan cikal bakal nama pohon biner ini.

Misalnya, mari kita lihat suatu simpul pada pohon biner. Lihat simpul tersebut beserta seluruh simpul turunannya (yaitu anak, anak dari anaknya, dan seterusnya). Simpul-simpul ini juga membentuk pohon biner, yang disebut pohon cabang (subtree) dari pohon awalnya. Misalnya, pada gambar di atas, simpul 2, 4, dan 5 membentuk pohon cabang. Pohon cabang ini disebut pohon cabang sebelah kiri dari simpul akarnya. Hal yang sama, simpul 3 dan 6 adalah pohon cabang sebelah kanan dari simpul akarnya. Salah satu atau kedua pohon cabang bisa kosong. Ini adalah definisi rekursif. Jadi tidak heran apabila kita menerapkan subrutin rekursif untuk mengolah struktur data pohon. Mari kita lihat bagaimana caranya menghitung banyaknya simpul di dalam pohon biner. Sebagai latihan, kita mungkin bisa membuat algoritma untuk menghitung simpul. Inti permasalahannya adalah, bagaimana melacak simpul mana yang belum dihitung. Ini bukan hal sepele. Dan mungkin kita tidak mungkin menyelesaikannya tanpa menggunakan tumpukan atau antrian. Dengan rekursi, algoritmanya akan jauh lebih mudah. Suatu pohon bisa kosong, atau bisa terdiri dari akar dan dua pohon cabang. Jika pohon kosong, maka banyaknya simpul adalah nol. (Ini merupakan kasus dasar dari rekursi). Kemudian kita bisa menggunakan rekursi untuk menghitung jumlah simpul pada masing-masing pohon cabang. Jumlahkan hasil dari kedua cabang, kemudian tambah satu simpul akarnya. Ini adalah jumlah simpul di dalam pohon. Dalam Java bisa kita tuliskan sebagai : static int hitungSimpul( SimpulPohon akar ) { // Hitung berapa simpul yang dimiliki suatu pohon // biner, termasuk akarnya if ( akar == null ) return 0;

// Pohon kosong, tidak ada simpul di dalamnya

else { int jumlah = 1;

// Mulai dengan menghitung akarnya

// Tambahkan dengan simpul dari pohon cabang sebelah kiri jumlah += hitungSimpul(akar.kiri); // Tambahkan dengan simpul dari pohon cabang sebelah kanan jumlah += hitungSimpul(akar.kanan); return hitung; } } // akhir hitungSimpul()

// Kembalikan jumlahnya

Juga, mari kita lihat bagaimana mencetak isi item di dalam pohon biner. Jika pohon kosong, kita tidak melakukan apa-apa. Jika pohon tidak kosong, maka mungkin ia berisi akar dan dua pohon cabangnya. Cetak item pada akarnya, dan gunakan rekursi untuk mencetak item di dalam pohon cabangnya. Berikut ini adalah subrutin untuk mencetak semua item dalam satu baris cetakan. static void preorderCetak( SimpulPohon akar ) { // Cetak semua item di dalam pohon yang ditunjuk oleh akar. // Item pada akar dicetak dahulu, kemudian item di sebelah kiri // dan baru item di pohon cabang sebelah kanan if ( akar != null ) {

// (Jika null, kita tidak melakukan apa-apa.)

System.out.print( akar.item + " " ); preorderCetak( akar.kiri ); preorderCetak( akar.kanan );

// Print item akar

// Print item di pohon cabang kiri // Print items di pohon cabang

kanan } } // akhir preorderCetak()

Rutin ini disebut "preorderCetak" karena ia menelusuri pohon secara preorder. Dalam penelusuran preorder, simpul akan diproses terlebih dahulu, kemudian pohon cabang sebelah kiri ditelusuri, dan kemudian cabang sebelah kanan. Dalam penelusuran postorder, cabang kiri ditelusuri, kemudian cabang kanan, baru kemudian simpul akar. Dan dalam penelusuran inorder, cabang kiri dikunjungi dahulu, kemudian akar, dan kemudian cabang kanan. Subrutin yang mencetak postorder dan inorder berbeda dengan preorder dalam urutan pencetakannya di layar : static void postorderCetak( SimpulPohon akar ) { // Cetak semua item di dalam pohon yang ditunjuk oleh akar. // Cabang pohon sebelah kiri dicetak dahulu, kemudian kanan, // dan baru simpul akarnya if ( akar != null ) {

// (Jika null, kita tidak melakukan apa-apa.)

postorderCetak( akar.kiri ); postorderCetak( akar.kanan );

// Print item di pohon cabang kiri // Print items di pohon cabang

kanan System.out.print( akar.item + " " );

// Print item akar

} } // akhir postorderCetak() static void inorderCetak( SimpulPohon akar ) { // Cetak semua item di dalam pohon yang ditunjuk oleh akar.

// Cabang pohon cabang sebelah kiri dicetak dahulu, // kemudian simpul akarnya, baru pohon cabang sebelah kanan if ( akar != null ) {

// (Jika null, kita tidak melakukan apa-apa.)

inorderCetak( akar.kiri );

// Print item di pohon cabang kiri

System.out.print( akar.item + " " ); inorderCetak( akar.kanan );

// Print item akar

// Print items di pohon cabang kanan

} } // akhir inorderCetak()

Subrutin ini bisa dijalankan pada pohon biner yang diilustrasikan di awal bagian ini. Urutan item ketika dicetak akan berbeda, di mana : preorderCetak mencetak:

1

2

4

5

3

6

postorderCetak mencetak:

4

5

2

6

3

1

inorderCetak mencetak:

4

2

5

1

3

6

Dalam preorderCetak misalnya, itam pada akar pohon, yaitu 1, dicetak paling awal. Akan tetapi urutan preorder juga dilakukan untuk setiap pohon cabangnya. Simpul akar pada pohon cabang sebelah kiri, yaitu 2, dicetak terlebih dahulu sebelum pohon cabangnya 4 dan 5. Sedangkan untuk cabang sebelah kanan, akarnya 3 akan dicetak sebelum 6. Penelusuran preorder dilakukan pada semua cabang pohon. Urutan penelusuran yang lainnya bisa dianalisis dengan cara yang sama. Pohon Pengurutan Biner Pada bagian sebelumnya kita membahas tentang list berantai dari string, di mana string dijaga agar tetap dalam urutan menaik. Akan tetapi list berantai seperti ini bisa bekerja untuk jumlah yang tidak terlalu banyak. Untuk jumlah item yang sangat banyak, list berantai kurang efisien. Ketika kita menambahkan item ke dalam list, kita harus mencari dahulu posisi yang tepat di mana item akan disisipkan. Untuk melakukan pencarian, kita harus melihat paling tidak separuh dari seluruh list. Jika string list diimplentasikan dalam bentuk array terurut, maka pencariannya bisa dilakukan lebih cepat, karena pencarian biner bisa digunakan. Akan tetapi untuk menyisipkan item ke dalam array terurut juga tidak efisien, karena kita harus memindahkan paling tidak setengah isi array untuk memberi tempat untuk item baru yang akan disisipkan. Pohon biner bisa digunakan untuk menyimpan string list terurut (atau item jenis lain), sehingga pencarian dan penyisipan bisa dilakukan dengan mudah. Pohon biner ini disebut pohon pencarian biner.

Pohon pencarian biner adalah pohon biner yang memiliki sifat : 

Untuk setiap simpul pada pohon, item pada simpul tersebut lebih besar dari semua item di cabang kiri pohon



Dan simpul tersebut, lebih besar atau sama dengan semua item di cabang kanan pohon

Berikut ini adalah contoh pohon pengurutan biner yang memiliki item bertipe String. (Dalam gambar ini pointer berisi null tidak digambarkan, sedangkan pointer yang tidak null dilambangkan dengan tanda panah)

Pohon pencarian biner memiliki sifat penting berikut : Penelusuran inorder akan mengolah item dalam urutan menaik. Misalnya, penelusuran inorder digunakan untuk mencetak isi pohon di atas dalam urutan alfabet. Penelusuran inorder menjamin bahwa semua item di cabang kiri pohon dari elemen "judy" akan dicetak sebelum "judy", dan semua item di cabang kanan pohon akan dicetak setelah "judy". Karena sifat pohon biner yang mengharuskan item di cabang kiri lebih kecil dari item pada simpul, maka keluarannya akan sama dengan mengurutkan isi pohon secara alfabet dalam urutan menaik. Misalnya kita ingin mencari item di dalam pohon pencari biner. Pertama, bandingkan item dengan isi simpul akarnya. Jika isinya sama, maka kita selesai. Jika item yang kita cari kurang dari item pada simpul akar, kita harus mencari ke sebelah kiri pohon -- pohon sebelah kanan bisa diabaikan karena isinya hanya item yang lebih besar dari simpul akarnya. Demikian juga jika item yang kita cari lebih besar dari item pada simpul akar, maka kita akan mencari di sebelah kanan pohon. Untuk semua kasus, kita bisa menggunakan prosedur yang sama di setiap cabang pohon.

Bagaimana dengan memasukkan item baru ke dalam pohon. Mula-mula cari di posisi mana item tersebut akan dimasukkan. Jika posisinya ditemukan, buat simpul baru dan tempelkan simpul baru di tempat tersebut. Pencarian dan penyisipan item adalah operasi yang efisien pada pohon pencarian biner, asalkan pohon tersebut berada dalam kondisi seimbang (balanced). Suatu pohon biner berada dalam kondisi seimbang jika jumlah simpul pada cabang kanan sama dengan jumlah simpul pada cabang kiri. Tidak semua pohon biner akan menjadi pohon seimbang, akan tetapi jika pohon ini dibuat secara acak, besar kemungkinan pohon tersebut akan menjadi seimbang. Dalam pencarian dalam pohon pencarian biner, setiap pengujian yang kita lakukan akan membuang sebagian cabang pohon. Jika pohon tersebut dalam keadaan seimbang, maka akan semakin banyak elemen yang kita buang, dan dengan demikian pencarian akan dilakukan dengan lebih cepat. Ini mirip sekali dengan algoritma pencarian biner pada bagian sebelumnya. Mari kita lihat bagaimana mengimplementasikan pohon pencarian biner. Simpul pada pohon biner diekspresikan dalam kelas SimpulPohon berikut ini, beserta konstruktor untuk membuat simpul baru lebih mudah. class SimpulPohon { // Objek SimpulPohon adalah satu simpul pada // pohon biner string String item;

// Data pada simpul ini

SimpulPohon kiri;

// Pointer ke cabang kiri

SimpulPohon kanan;

// Pointer ke cabang kanan

SimpulPohon(String str) { // Konstruktor. Membuat simpul berisi str item = str; } }

// akhir kelas SimpulPohon

Variabel statik dengan tipe SimpulPohon menunjuk pada pohon pencarian biner: // Pointer ke simpul akar pohon // Ketika pohon kosong, akar berisi null static SimpulPohon akar;

Subrutin rekursif bernama pohonBerisi digunakan untuk mencari item di dalam pohon. Subruin berikut melakukan pencarian pada pohon biner seperti didiskusikan di atas. static boolean pohonBerisi( SimpulPohon simpul, String item ) {

// Kembalikan true jika item ditemukan dalam pohon if ( simpul == null ) { // Pohon kosong, jadi sudah pasti tidak ada item ini // di dalamnya return false; } else if ( item.equals(simpul.item) ) { // Item ini ditemukan di simpul akar return true; } else if ( item.compareTo(simpul.item) < 0 ) { // Jika item lebih kecil dari simpul, maka mungkin ada di // cabang kiri pohon. Kembalikan hasil pencarian di // cabang kiri pohon return pohonBerisi( simpul.kiri, item ); } else { // Jika item sama atau lebih besar dari simpul, maka // mungkin ada di cabang kanan pohon. Kembalikan hasil // pencarian di cabang kanan pohon return pohonBerisi( simpul.kanan, item ); } }

// akhir pohonBerisi()

Ketika subrutin ini dipanggil, parameter pertama adalah variabel anggota statik akar yang menunjuk pada akar seluruh pohonh pencarian biner. Perlu dicatat bahwa rekursi bukan sesuatu yang penting dalam mengimplementasikan subrutin ini. Algoritma pohon pencarian biner yang tidak rekursif mengikuti aturan berikut : Turun ke bawah hingga kita menemukan item atau hingga mencapai null. Kita bisa menggunakan perulangan while, sehingga implementasinya menjadi : static boolean pohonBerisiNR( SimpulPohon akar, String item ) { // Kembalikan true jika item ada di dalam pohon biner. SimpulPohon pointer; pointer = akar;

// Pointer untuk menelusuri pohon

// Mulai di akar simpul

while (true) { if (pointer == null) { // Kita sudah sampai pada akhir pohon, dan item belum // ditemukan return false; } else if ( item.equals(pointer.item) ) {

// Kita sudah menemukan item return true; } else if ( item.compareTo(pointer.item) < 0 ) { // Jika item lebih kecil, kemungkinan ada di cabang kiri // Teruskan penelusuran di cabang kiri pohon pointer = pointer.kiri; } else { // Jika item lebih besar, kemungkinan ada di cabang kanan // Teruskan penelusuran di cabang kanan pohon pointer = pointer.kanan; } }

// akhir while

} // akhir pohonBerisiNR();

Subrutin untuk menyisipkan item baru ke dalam pohon mirip dengan rutin pencari nonrekursif di atas. Selain itu rutin penyisipan harus bisa menguji apakah pohon kosong atau tidak. Jika pohon kosong, maka akar menunjuk pada simpul baru. akar = new simpulPohon( itemBaru );

Akan tetapi, berarti akar tidak bisa diberikan sebagai parameter subrutin, karena kita tidak bisa mengubah nilai yang disimpan dalam parameter aktual. (Ini bisa dilakukan dalam bahasa pemrograman lain). Ada cari lainnya, akan tetapi cara lebih mudah adalah menggunakan rutin penyisipan non-rekursif yang mengakses variabel anggota akar secara langsung. Perbedaan antara mencari dan menyisipkan item adalah kita harus berhati-hati untuk tidak jatuh dari pohon. ARtinya, kita harus selesai melakukan pencarian sebelum pointer bernilai null karena mencapai akhir pohon. Jika kita sampai pada tempat kosong, di situlah kita menempatkan simpul baru kita. static void sisipPohon(String itemBaru) { // Tambahkan item ke dalam pohon pencarian biner, di mana // variabel "akar" berisi. (Catatan kita tidak bisa menggunakan // akar sebagai parameter, karena kita harus mengubah isi // variabel ini.) if ( akar == null ) { // Jika pohon kosong, set akar ke simpul baru // yang berisi itemBaru akar = new SimpulPohon( itemBaru ); return;

} SimpulPohon pointer; // Untuk menelusuri pohon pointer = akar;

// Mulai dari akar

while (true) { if ( newItem.compareTo(pointer.item) < 0 ) { // Karena itemBaru kurang dari item dalam pohon // maka ia harus berada di cabang kiri pohon. // Jika ada ruang kosong di pointer.kiri maka simpul baru // bisa ditambah di sini. Jika tidak turun satu tingkat lagi ke kiri if ( pointer.kiri == null ) { pointer.kiri = new SimpulPohon( itemBaru ); return;

// itemBaru sudah ditambahkan ke dalam pohon

} else pointer = pointer.kiri; } else { // Karena itemBaru lebih besar dari item dalam pohon // maka ia harus berada di cabang kanan pohon. // Jika ada ruang kosong di pointer.kanan maka simpul baru // bisa ditambah di sini. Jika tidak turun satu tingkat lagi ke kanan if ( pointer.kanan == null ) { pointer.kanan = new SimpulPohon( itemBaru ); return;

// itemBaru sudah ditambahkan ke dalam pohon

} else pointer = pointer.kanan; } } // akhir while }

// akhir sisipPohon()

Bab IX - Pemrograman Generik dan Kelas Koleksi Bagaimana caranya menghindari "reinventing the wheel", atau membuat kembali sesuatu yang sudah ditemukan? Banyak struktur data dan algoritma, seperti yang sudah dibahas pada bab sebelumnya telah dipelajari, diprogram, dan diprogram ulang oleh mahasiswa ilmu komputer dalam beberapa generasi. Ini adalah kesempatan belajar yang sangat baik.

Sayangnya, algoritma dan data stuktur ini juga diprogram dan diprogram ulang oleh profesional komputer. Mereka menghabiskan waktu yang tidak perlu untuk memrogram ulang sesuatu yang sudah ada, bukannya membuat sesuatu yang lebih inovatif dan kreatif. Programmer yang perlu menggunakan list atau pohon biner, seharusnya tidak perlu lagi membuat data struktur ini dari awal. Struktur data ini sudah banyak dimengerti dan diprogram ribuan kali sebelumnya. Masalahnya adalah bagaimana agar struktur data yang tangguh tersedia dan siap digunakan oleh programmer. Di bagian ini kita akan melihat bagaimana Java menyelesaikan masalah ini Pemrograman generik adalah penulisan kode yang bisa digunakan oleh berbagai macam tipe data. Kita telah menemukan istilahnya pada bagian sebelumnya tentang array dinamis integer. Kode yang ditulis di sana untuk array dinamis integer hanya bisa bekerja untuk tipe data int. Akan tetapi kode array dinamis untuk double, String, atau tipe data lainnya hampir sama. Akan sangat tidak nyaman apabila kita harus mengkopi kodenya berulangulang untuk tipe data yang berbeda-beda. Seperti disebutkan sebelumnya, Java mencoba menyelesaikan masalah ini dengan membuat kelas ArrayList. Kelas ini pada dasarnya merupakan array dinamis dengan tipe Object.

Karena semua kelas merupakan kelas turunan dari Object, maka objek yang

bertipe kelas apapun bisa disimpan dalam ArrayList. Ini adalah contoh pemrograman generik : kode untuk kelas ArrayList cukup ditulis satu kali, tetapi bisa digunakan untuk objek dengan tipe data yang berbeda-beda (akan tetapi, tidak bisa digunakan untuk tipe data primitif, seperti int atau double.) Kelas ArrayList hanyalah satu dari beberapa kelas dan interface yang merupakan pemrograman generik pada Java. Kita akan lihat beberapa kelas lain dan bagaimana kelaskelas ini digunakan. Semua kelas yang didiskusikan pada bagian ini merupakan bagian dari paket java.util dan kita perlu menambahkan pernyataan import di awal program untuk bisa menggunakannya. (Sebelum kita menggunakan perintah import java.util.*; di semua program, kita harus tahu bahwa beberapa kelas di dalam java.util memiliki nama yang sama pada pake lain. Misalnya, java.util.List dan java.awt.List adalah kelas yang bernama sama dengan paket yang berbeda). Adalah sesuatu hal yang tidak mudah untuk mendesain pustaka untuk pemrograman generik. Solusi yang disediakan Java memiliki banyak fitur bagus, akan tetapi bukan berarti cara ini adalah cara satu-satunya. Sudah pasti bukan yang terbaik, akan tetapi dalam konteks desain Java secara keseluruhan, mungkin lebih cocok disebut optimal. Untuk dapat

memberikan gambaran seperti apa pemrograman generik secara umum, mungkin akan lebih baik untuk melihat sekilas pemrograman generik di bahasa pemrograman lain. Pemrograman Generik pada Bahasa Pemrograman Lain Pemrograman Generik pada Smalltalk Smalltalk adalah salah satu bahasa pemrograman berorientasi objek pertama. Bahasa ini masih digunakan hingga kini. Meskipun tidak menjadi sepopuler Java atau C++, bahasa ini adalah sumber ide yang diadopsi banyak bahasa pemrograman. Pada Smalltalk, pada dasarnya semua pemorgraman adalah generik, karena dua sifat bahasa ini. Pertama, variabel pada Smalltalk tidak memiliki tipe. Suatu nilai memiliki tipe, seperti integer atau string, tetapi variabel tidak memiliki nilai. Suatu variabel bisa menampung jenis data apa saja. Parameter juga tidak memiliki tipe, sehingga subrutin bisa digunakan pada parameter apa saja. Demikian juga dengan struktur data bisa menampung data apa saja. Misalnya, sekali kita mendefinisikan struktur data pohon biner pada Smalltalk, kita bisa menggunakannya untuk integer, string, tanggal, atau data apa saja. Kita tidak perlu menulis kode baru untuk masing-masing tipe data. Kedua, semua nilai adalah objek, dan semua operasi pada objek dilakukan dengan metode dalam kelas. Hal ini juga berlaku bahkan untuk tipe data primitif seperti integer. Ketika operator "+" digunakan untuk menjumlah integer, operasi ini dilakukan dengan memanggil metode pada kelas integer. Ketika kita membuat kelas baru, kita bisa membuat operator "+" sendiri kemudian kita bisa menjumlahkan dua objek dengan tipe kelas tersebut dengan menggunakan "a + b" seperti kita menjumlahkan angka seperti biasa. Sekarang misalnya kita membuat subrutin baru yang menggunakan operator "+" untuk menjumlahkan masing-masing item di dalam list. Subtuin ini bisa digunakan untuk list integer, tapi juga bisa digunakan ke tipe data apapun yang mendefinisikan "+". Demikian juga dengan subrutin yang menggunakan operator "<" untuk mengurutkan list juga bisa digunakan untuk list yang mengandung tipe data apapun yang memiliki definisi "<". Kita tidak perlu menulis subrutin pengurutan untuk masing-masing tipe data. Jika kedua fitur ini kita gabungkan, kita bisa memiliki bahasa di mana struktur data dan algoritmanya akan bekerja untuk jenis tipe data apapun (yang masuk akal), yaitu jika operasi yang sesuai telah didefinisikan. Inilah yang merupakan pemrograman generik yang sesungguhnya. Mungkin ini terdengar sangat baik, dan Anda mungkin bertanya-tanya kenapa tidak semua bahasa pemrograman bekerja seperti ini. Kebebasan pemrograman seperti ini akan

memudahkan kita membuat program, akan tetapi akan lebih sulit untuk membuat program yang benar dan tangguh. Sekali kita membuat struktur data yang bisa menampung tipe data apa saja, akan sulit untuk menjamin ia bisa menampung tipe data yang kita inginkan. Jika kita ingin suatu subrutin mengurutkan tipe data apapun, maka akan sangat sulit untuk menjamin bahwa subrutin ini hanya digunakan untuk data di mana operator "<" telah didefinisikan. Lebih khusus, kompiler tidak bisa memastikannya. Masalah ini akan muncul di saat program dijalankan ketika kita mencoba untuk menjalankan operasi tertentu pada suatu tipe data yang belum ada, kemudian program akan crash. Pemrograman Generik pada C++ Tidak seperti Smalltalk, C++ adalah bahasa pemrograman dengan tipe kuat, bahkan lebih kuat dari Java. Setiap variabel memiliki tipe, dan hanya bisa menampung tipe data itu saja. Artinya pemrograman generik seperti pada Smalltalk tidak mungkin diterapkan. Lebih Jauh, C++ tidak memiliki sesuatu yang mirip dengan kelas Object pada Java. Artinya, tidak ada kelas yang merupakan kelas super dari semua kelas. Artinya C++ tidak bisa menggunakan pemrograman generik seperti Java. Akan tetapi, C++ memiliki sistem pemrograman geneik yang canggih dan fleksibel, yaitu yang disebut template. Dalam C++, kita tidak membuat subrutin pengurutan yang berbeda untuk setiap tipe data. Akan tetapi kita bisa mmebuat template subrutin. Template ini bukan subrutin; akan tetapi mirip seperti pabrik pembuat subrutin. Kita lihat contoh berikutnya, karena sintaks C++ mirip dengan Java : template void urut( TipeItem A[], int banyak ) { // Urut banyak item dalam array A, ke dalam urutan menaik // Algoritma yang digunakan adalah pengurutan pilihan for (int i = banyak-1; i > 0; i--) { int posisi_maks = 0; for (int j = 1; j <= banyak; j++) if ( A[j] > A[posisi_maks] ) posisi_maks = j; TipeItem temp = A[banyak]; A[banyak] = A[posisi_maks]; A[posisi_maks] = temp; } }

Dalam kode di atas, kita mendefinisikan template subrutin. Jika kita menghapus baris pertama, yaitu template", dan mengganti kata "TipeItem" dengan "int", pada semua isi template, maka kita bisa mendapatkan subrutin untuk mengurut array int. (Meskipun kita tulis seperti "class TipeItem", kita bisa menggantinya dengan tipe apapun, termasuk tipe primitif). Jika kita mengganti "TipeItem" dengan string, maka kita bisa mendapatkan subrutin untuk mengurut array string. Ini yang sebenarnya dilakukan oleh compiler. Jika program kita menyebut "urut(list,10)" di mana list adalah array int, maka kompiler menggunakan template ini untuk membuat subrutin untuk mengurut array int. Jika kita sebut "urut(kartu,10)" di mana kartu adalah array objek bertipe Kartu, maka kompiler akan membuat subrutin untuk mengurutkan array Kartu. Template di atas menggunakan operator ">" untuk membandingkan nilai. Jika operator ini didefinisikan untuk nilai bertipe Kartu, maka kompiler akan menggunakan template dengan sukses. Jika ">" tidak didefinisikan untuk kelas Kartu, maka kompiler akan gagal, akan tetapi ini akan terjadi pada saat program dikompilasi bukan seperi Smalltalk di mana program akan crash pada saat dijalankan. C++ juga memiliki template untuk membuat kelas. Jika kita menulis template untuk pohon biner, kita bisa menggunakan template itu untuk membuat kelas pohon biner int, pohon biner string, pohon biner tanggal, dan seterusnya -- semua dari satu template. Versi paling baru C++ memiliki template bawaan yang cukup komplit yang disebut dengan Pustaka Template Standar (Standard Template Library atau STL). STL sendiri cukup kompleks, dan bahkan beberapa orang mengatakan sangat amat kompleks. Akan tetapi ini juga fitur paling menarik dari C++ Pemrograman Generik pada Java Seperti pada C++, Java adalah bahasa bertipe kuat. Akan tetapi, pemrograman generik pada Java lebih dekat dengan Smalltalk daripada C++. Seperti telah dijelaskan sebelumnya, pemrograman generik pada Java berdasarkan pada kelas Object yang merupakan kelas super dari semua kelas. Hingga tingkat tertentu, ini membuat Java mirip dengan Smalltalk : Struktur data yang didesain untuk menampung Object bisa digunakan untuk menyimpan data kelas apapun. Kita tidak perlu membuat template atau fitur pada bahasa pemrograman lain untuk mendukung pemrograman generik. Tentunya, tipe primitif, seperti integer, bukan objek pada Java, dan karenanya tidak bisa disimpan dalam tipe data generik. Dan sebenarnya, tidak ada cara untuk melakukan

pemrograman generik dengan tipe data primitif pada Java. Pendekatan Smalltalk tidak bisa diterapkan pada Java kecuali untuk objek, dan pendekatan C++ tidak tersedia pada Java. Lebih jauh, subrutin generik lebih bermasalah pada Java daripada Smalltalk atau C++. Pada Smalltak, subrutin dapat dipanggil dengan parameter bertipe apapun, dan akan bekerja asalkan operator yang digunakan pada subrutin didefinisikan pada parameternya. Pada Java, parameter suatu subrutin harus bertipe tertentu. Dan subrutin hanya bisa menggunakan operasi untuk tipe itu saja. Subrutin dengan parameter Object bisa digunakan untuk objek tipe apa saja, akan tetapi subrutin hanya bisa menggunakan operasi pada kelas Object saja, dan sebenarnya hanya sedikit operasi pada kelas Object! Misalnya tidak ada operasi pembanding pada kelas Object, jadi kita tidak bisa membuat algoritma pengurutan generik. Kita akan lihat bagaimana Java menyelesaikan masalah ini. Karena masalah seperti ini, beberapa orang menyatakan bahwa Java tidak mendukung pemrograman generik secara keseluruhan. Beberapa orang lain tidak setuju. Akan tetapi, tetap saja ini tidak menghambat Java untuk digunakan secara luas. Koleksi dan Map Struktur data generik pada Java dapat dibagi menjadi dua kategori : koleksi dan map. Koleksi kurang lebih mirip seperti kumpulan objek-objek. Map menghubungkan objek di satu kumpulan dan objek di kumpulan lain seperti kamus yang menghubungkan definisi dengan kata atau buku telepon menghubungkan nama dan nomor telepon. Map mirip dengan apa yang kita sebut "list asosiasi" pada bagian sebelumnya. Ada dua jenis koleksi : list dan himpunan (set). List adalah kumpulan objek di mana itemitemnya diatur secara berurutan. List memiliki item pertama, item kedua, dan seterusnya. Untuk item di dalam list, kecuali item terakhir, akan ada item yang ada di belakangnya. Himpunan (set) adalah kumpulan objek di mana hanya ada satu objek yang bisa ada di dalam suatu himpunan. Lihat bahwa istilah "koleksi", "list", "himpunan", dan "map" tidak menyatakan bagaimana data disimpan. List bisa diimplementasikan dalam bentuk array, list berantai, atau map yang menghubungkan elemen list dengan angka 0, 1, 2, .... Sebetulnya istilah-istilah ini dibuat pada Java bukan dalam bentuk kelas tapi dalam bentuk interface. Interface Collection, List, Set dan Map mendefinisikan operasi dasar dari struktur data tersebut, tapi tidak menjelaskan bagaimana struktur data dan operasinya diimplementasikan. Struktur data dan operasinya akan ditulis pada kelas yang mengimplementasikan interface tersebut. Bahkan ketika kita menggunakan kelas tersebut, kita mungkin tidak tahu

bagaimana kelas tersebut diimplementasikan, kecuali kita melihat langsung pada kode sumbernya. Struktur data generik pada Java adalah tipe data abstrak (abstract data type). Mereka memiliki definisi operasi yang bisa dilakukan, dan bukan bagaimana data diatur dalam memori komputer. Kita akan lihat kelas list, set dan map pada bagian berikut. Tapi sebelum kita sampai pada bagian itu, kita akan melihat dahulu beberapa konsep tentang operasi umum yang tersedia pada semua koleksi. Algoritma Generik Interface Collection memiliki metode untuk melakukan beberapa operasi dasar pada koleksi. Karena "koleksi" adalah konsep yang sangat umum, maka operasi yang bisa dilakukan oleh semua koleksi juga sesuatu yang sangat umum. Misalnyakol adalah objek yang mengimplementasi interface Collection. Berikut ini adalah operasi yang bisa dilakukan. 

kol.size() -- mengembalikan int yang berisi banyaknya objek dalam suatu koleksi



kol.isEmpty() -- mengembalikan boolean true jika koleksi kosong, atau ukurannya sama dengan 0



kol.clear() -- menghapus semua objek dalam koleksi



kol.contains(objek) -- mengembalikan nilai boolean jika objek ada dalam koleksi



kol.add(objek) -- menambah objek ke dalam koleksi. Parameternya bisa berupa Object

apa saja. Beberapa koleksi bisa berisi nilai null, sementara yang lain tidak.

Misalnya menambahkan objek ke dalam Set tidak berpengaruh apa-apa jika objek tersebut sudah ada di dalamnya. 

kol.remove(objek) -- membuang objek dari dalam koleksi, jika ada, dan mengembalikan nilai boolean yang menyatakan apakah objek tersebut ada atau tidak di dalam koleksi



kol.containsAll(kol2) -- mengembalikan nilai boolean jika semua objek dalam kol2 ada di dalam koleksi kol. Parameternya bisa berupa Collection apa saja.



kol.addAll(col2) -- menambahkan semua objek yang ada dalam koleksi kol2 ke dalam kol



kol.removeAll(kol2) -- menghapus semua objek di kol yang ada pada kol2



kol.retainAll(kol2) -- menghapus semua objek pada kol yang tidak ada pada kol2. Hanya akan mempertahankan objek yang ada pada kol2



kol.toArray() -- mengembalikan array bertipe Object[] yang isinya semua item di dalam koleksi. Nilai yang dikembalikan bisa di-tipe cast ke dalam tipe array lain, jika perlu. Misalnya, jika kita tahu bahwa semua item di dalam kol bertipe String, maka (String[])kol.toArray() akan mengembalikan array String yang berisi semua string di dalam koleksi.

Karena semua metode adalah turunan dari interface Collection, maka metode ini harus didefinisikan pada semua objek yang mengimplementasikan interface ini. Akan tetapi ada masalah yang timbul. Misalnya ukuran suatu Collection tidak bisa diganti setelah dibuat. Metode yang menambah atau membuang objek tidak bisa digunakan untuk koleksi jenis ini. Meskipun mungkin legal untuk memanggil metode ini, pengecualian akan dilemparkan ketika

program

dijalankan.

Jenis

pengecualiannya

bernama

UnsupportedOperationException.

Ada juga masalah efisiensi. Meskipun suatu operasi didefinisikan untuk beberapa jenis koleksi, tentunya unjuk kerjanya tidak sama untuk semua kelas. Bahkan untuk metode sesederhana size() bisa sangat berbeda dari satu jenis koleksi ke jenis koleksi lainnya. Untuk beberapa jenis koleksi, waktu pengolahan sebanding dengan jumlah item di dalam koleksi. Koleksi lain mungkin memiliki variabel instansi yang melacak jumlah item di dalam koleksi, sehingga menjalankan size() sama dengan mengambil nilai variabel instansi ini. Artinya operasinya hanya dilakukan satu langkah saja, tidak peduli berapa banyak item yang ada di dalam koleksi. Ketika kita menggunakan koleksi, alangkah lebih baiknya untuk mengetahui seberapa efisien suatu operasi dilakukan untuk jenis koleksi tertentu. Kita harus bisa memilih koleksi yang cocok untuk masalah yang kita hadapi. Kita akan lihat lebih detail di bagian berikutnya. Iterator Interface Collection mendefinisikan beberapa algoritma generik, akan tetapi mungkin kita ingin membuat algoritma generik kita sendiri. Misalnya kita ingin membuat suatu subrutin yang mencetak setiap item di dalam koleksi. Untuk bisa melakukan ini secara generik, kita harus mencari akal bagaimana caranya untuk mengakses setiap item satu per satu. Kita telah lihat sebelumnya bagaimana caranya untuk data struktur tertentu : Misalnya untuk array, kita bisa menggunakan perulangan for dari item pertama hingga terakhir. Untuk list berantai, kita bisa menggunakan perulangan while dari item pertama hingga

kita menemukan null. Untuk pohon biner kita bisa menggunakan subrutin rekursif dengan penelusuran infix. Koleksi bisa dibuat dalam berbagai bentuk. Dengan keragaman bentuk ini dan bermacammacam cara untuk menelusurinya, bagaimana kita bisa membuat metode generik yang berlaku untuk semua kenis koleksi? Masalah ini bisa diselesaikan dengan iterator. Iterator adalah objek yang digunakan untuk menelusuri koleksi. Koleksi dengan jenis yang berbeda memiliki jenis iterator yang berbeda pula, akan tetapi semua iterator digunakan dengan cara yang sama. Algoritma yang menggunakan iterator untuk menelusuri koleksi bisa dibuat generik, karena teknik yang sama bisa digunakan untuk beragam jenis koleksi. Konsep iterator mungkin agak aneh untuk seseorang yang baru menemui konsep pemrgoraman generik, akan tetapi Anda harus mengerti bahwa konsep ini bisa digunakan untuk menyelesaikan masalah sulit dengan cara yang anggun. Interface Collection memiliki metode yang bisa digunakan untuk mengambil iterator dalam koleksi apapun. Jika kol adalah suatu koleksi, maka kol.iterator() mengembalikan iterator yang bisa digunakan untuk menelusuri koleksi tersebut. Bayangkan iterator seperti pointer generik yang dimulai dari awal koleksi dan bisa berpindah dari satu item ke item lain. Iterator didefinisikan oleh interface yang bernama Iterator.

Interface ini hanya memiliki 3 metode. Jika iter merupakan variabel bertipe

Iterator,

maka :



iter.next()

-- mengembalikan item berikutnya, dan memindahkan iterator ke

item berikutnya. Nilai keluarannya bertipe Object. Ingat bahwa kita tidak bisa melihat suatu item tanpa memindahkan iterator ke item berikutnya. Jika metode ini dipanggil apabila tidak ada item lagi yang tersisa, ia akan melempar NoSuchElementException. 

iter.hasNext()

-- mengembalikan nilai boolean yang memberi tahu apakah ada

item berikutnya yang bisa diproses. Kita harus mengetesnya sebelum memanggil iter.next() 

iter.remove()

-- jika kita gunakan perintah ini setelah memanggil iter.next(),

maka ia akan menghapus item yang baru saja kita lihat. Akan melempar pengecualian

UnsupportedOperationException

jika

koleksi

tidak

bisa

menghapus item. Dengan menggunakan iterator, kita bisa menulis kode untuk mencetak semua item dalam koleksi apapun. Misalnya kol bertipe Collection. Maka kita bisa menggunakan : Iterator iter = kol.iterator();

while ( iter.hasNext() ) { Object item = iter.next(); System.out.println(item); }

Bentuk yang sama bisa digunakan untuk pemrosesan jenis apapun. Misalnya, subrutin berikut ini akan menghapus semua nilai null dari koleksi apapun (selama koleksi itu mengizinkan penghapusan elemen) : void removeNullValues( Collection coll ) { Iterator iter = kol.iterator(): while ( iter.hasNext() ) { Object item = iter.next(); if (item == null) iter.remove(); } }

Koleksi bisa menampung objek tipe apa saja, sehingga nilai keluaran iter.next() bertipe Object.

Sekarang, tidak ada yang bisa kita lakukan dengan variabel bertipe Object.

Dalam situasi praktis, koleksi digunakan untuk menyimpan objek yang bertipe kelas tertentu, kemudian objek dari koleksi itu di-tipe cast ke kelas tersebut sebelum digunakan. Misalnya, kita menggunakan kelas BentukGeometri. Misalnya kelas ini memiliki metode gambar()

untuk menggambar suatu gambar. Maka kita bisa membuat metode generik

untuk menggambar semua gambar dalam koleksi BentukGeometri seperti : void gambarSemuaGambar( Collection koleksiGambar ) { // Kondisi Awal: Semua item dalam koleksiGambar tidak berisi null //

dan bertipe kelas BentukGeometri

Iterator iter = koleksiGambar.iterator(); while ( iter.hasNext() ) { BentukGeometri gbr = (BentukGeometri)iter.next(); gbr.gambar(); } }

Kondisi awal dari metode tersebut menyatakan bahwa metode tersebut akan gagal apabila item di dalam koleksi tidak bertipe BentukGeometri. Jika item ini ditemukan, maka tipecast

"(BentukGeometri)iter.next()"

ClassCastException.

akan

melempar

pengecualian

Meskipun dalam Java kita tidak bisa memiliki "Koleksi Bentuk Geometri", dan hanya bisa memiliki "Koleksi Object", dalam prakteknya ini bukan masalah besar. Jika hanya perlu ingat objek jenis apa yang kita simpan dalam koleksi kita. Kesamaan dan Perbandingan Diskusi kita tentang metode pada interface Collection sebelumnya mengasumsikan bahwa dua objek dianggap "sama". Misalnya metode kol.contains(objek) dan kol.remove(objek)

mencari item dalam koleksi yang sama dengan objek. Akan tetapi,

kesamaan bukan sesuatu yang mudah. Teknik yang paling umum untuk menguji kesamaan (yaitu menggunakan operator ==) sering kali tidak bisa digunakan untuk objek. Operator == yang digunakan pada objek hanya membandingkan apakah objek tersebut memiliki alamat memori yang sama. Biasanya, kita ingin supaya kesamaan berarti isi objeknya sama (bukan alamat memorinya). Dua nilai String dianggap sama jika keduanya memiliki urutan karakter yang sama. Persoalan di mana karakter tersebut disimpan di dalam memori tentunya tidak relevan. Dua nilai bertipe Date dianggap sama jika isinya adalah waktu yang sama. Kelas Object memiliki metode bernilai boolean yaitu equals(Object) untuk menguji apakah satu objek berisi sama dengan objek lain. Di dalam koleksi, dua objek obj1 dan obj2 dianggap sama jika keduanya bernilai null atau jika keduanya bernilai tidak nul dan obj1.equals(obj2) bernilai true. Dalam kelas Object, obj1.equals(obj2) didefinisikan sebagai obj1 == obj2. Akan tetapi pada hampir semua kelas turunan Object, definisi ini tidak masuk akal, dan biasanya dibebanlebihkan (overload). Kelas String misalnya, membebanlebihkan equals() sehingga untuk str.equals(obj) bernilai sama jika urutan karakter obj sama dengan urutan karakter str. Jika kita menulis kelas sendiri, kita mungkin ingin mendefinisikan metode equals() sendiri pada kelas tersebut, sehingga metode kesamaan bisa berjalan sesuai dengan yang kita inginkan. Misalnya kelas Kartu akan bekerja dengan benar jika digunakan dalam koleksi bisa dibuat seperti : public class Kartu { int lambang;

// Kelas untuk kartu mainan

// Nomor 0 hingga 3 untuk lambangnya : // wajik, diamon, keriting atau hati.

int angka; // Angka 1 hingga 13

public boolean equals(Object obj) { if (obj == null || ! (obj instanceof

Kartu) ) {

// obj tidak sama dengan Kartu ini jika obj // tidak bertipe Kartu, atau isinya null return false; } else { Kartu lain = (Kartu)obj;

// Type-cast obj ke Kartu

if (lambang == lain.lambang && angka == lain.angka) { // Kartu lain berlambang dan berangka sama dengan // kartu ini, artinya kedua kartu sama return true; } else return false; } } ... // metode dan konstruktor lain }

Tanpa metode equals() dalam kelas ini, metode contains() dan remove() dalam interface Collection tidak akan bekerja dengan baik untuk kelas Kartu. Masalah yang sama akan muncul ketika item dalam koleksi akan diurutkan. Pengurutan artinya mengatur urutan item dalam aturan tertentu. Masalahnya, tidak ada aturan "menaik" dalam objek. Sebelum objek bisa diurutkan, metode tertentu harus dibuat untuk membandingkan objek. Objek yang akan dibandingkan harus mengimplementasikan interface java.lang.Comparable. Interface ini mendefinisikan satu metode, yaitu : public int compareTo(Object obj)

Nilai yang dikembalikan obj1.compareTo(obj2) bernilai nol jika kedua objek berisi sama (atau jika obj1.equals(obj2) bernilai benar). Keluarannya bernilai negatif jika obj1 lebih kecil dari obj2, atau jika diurutkan dalam urutan menaik obj1 akan muncul sebelum obj2.

Keluarannya bernilai positif jika obj1 lebih besar dari obj2 atau jika diurutkan

dalam urutan menaik obj1 muncul setelah obj2. Kelas String mengimplementasikan interface Comparable dan memiliki metode compareTo

dengan cara seperti di atas. Jika kita ingin membuat kelas sendiri dan ingin

mengurut objek pada kelas itu, kita juga harus mengimplementasikan objek itu dengan cara yang sama. Misalnya : class NamaLengkap implements Comparable {

// Melambangkan nama lengkap yang terdiri dari // nama depan dan nama belakang String namaDepan, namaBelakang; public boolean equals(Object obj) { if (obj == null || ! (obj instanceof NamaLengkap)) { return false; } else { NamaLengkap lain = (NamaLengkap)obj; return namaDepan.equals(lain.namaDepan) && namaBelakang.equals(lain.namaBelakang); } } public void compareTo(Object obj) { NamaLengkap lain = (NamaLengkap)obj; // Menyebabkan error jika obj tidak bertipe NamaLengkap if ( namaBelakang.compareTo(lain.namaBelakang) < 0 ) { // Jika namaBelakang lebih kecil dari namaBelakang objek lain // maka NamaLengkap ini muncul sebelum yang lain // Kembalikan nilai negatif return -1; } if ( namaBelakang.compareTo(lain.namaBelakang) > 0 ) { // Jika namaBelakang lebih besar dari namaBelakang objek lain // maka NamaLengkap ini muncul setelah yang lain // Kembalikan nilai positif return 1; } else { // Nama belakangnya sama, sekarang bandingkan // nama depannya return namaDepan.compareTo(lain.namaDepan); } } ... // metode dan konstruktor lain }

Ada cara lain untuk membandingkan objek pada Java, yaitu dengan membuat objek lain untuk

melakukan

perbandingan.

java.util.Comparator

Objek

tersebut

harus

mengimplementasikan

yang memiliki metode :

public int compare(Object obj1, Object obj2)

Metode ini membandingkan dua objek dan mengembalikan nilai negatif, nol, atau positif, tergantung apakah obj1 muncul lebih dulu, sama, atau setelah obj2. Komparator ini berfungsi untuk membandingkan objek yang tidak memiliki interface Comparable atau untuk melakukan metode pembanding yang berbeda untuk objek yang bertipe sama. Kita akan lihat bagaimana Comparable dan Comparator digunakan dalam koleksi dan map Kelas Pembungkus Seperti disebutkan sebelumnya, pemrograman generik pada Java tidak berlaku untuk tipe primitif. Kita akan bahas masalah ini sebelum kita beranjak pada bagian berikutnya. Kita tidak bisa menyimpan integer pada struktur data generik yang didesain untuk menyimpan Object. Di lain pihak, tidak ada yang menghentikan kita untuk membuat objek yang hanya berisi integer dan menggunakan objek itu untuk ditempatkan pada struktur data. Dalam kasus sederhana, kita akan membuat kelas yang tidak berisi apa-apa kecuali sebuah integer : public class KontainerInt { public int nilai; }

Sebenarnya, Java telah memiliki kelas seperti ini. Objek yang bertipe java.lang.Integer berisi sebuah int saja. Kelas ini disebut kelas pembungkus (wrapper) untuk int. Nilai int bisa dimasukkan dalam konstruktor, misalnya Integer bil = new Integer(17);

membuat objek Integer yang membungkus angka 17. Objek Integer bisa digunakan untuk struktur data generik dan dalam situasi lain jika objek dibutuhkan. Nilai int tersebut disimpan dalam variabel instansi private final dari objek Integer. Jika bil variabel yang menunjuk pada objek bertipe Integer, maka kita akan tahu berapa bilangan yang disimpan dalam objek ini dengan memanggil metode instansi bil.intValue().

Kita tidak bisa mengganti angka tersebut. Kita sebut objek Integer

sebagai objek <span style="color: #ff0000;">immutable (objek yang tak mungkin berubah, yaitu lawan kata dari mutable atau dapat bermutasi). Artinya, setelah

dibuat, kita tidak bisa mengubahnya. (Sama seperti objek bertipe String adalah objek immutable). Ada kelas pembungkus untuk semua tipe primitif. Semua objek dari tipe ini adalah objek immutable. Kelas pembungkus untuk tipe double adalah java.lang.Double. Nilai di dalam objek bertipe Double bisa diambil dengan metode instansi doubleValue(). Kelas pembungkus memiliki beberapa metode yang berguna. Beberapa digunakan untuk mendukung pemrograman generik. Misalnya, kelas pembungkus mendefinisikan metode equals(Object)

dan compareTo(Object) dengan benar.

Metode lain dalam kelas pembungkus adalah fungsi bantu untuk bekerja dengan tipe primitif. Misalnya, kita temukan sebelumnya metode Integer.parseInt(String) dan Double.parseDouble(String).

Fungsi ini digunakan untuk mengubah string seperti "42"

atau "2.3421213" ke dalam angka yang sesuai. List Ada dua cara paling umum untuk membuat list : sebagai array dinamis dan sebagai list berantai. Kita telah membahas keduanya sebelumnya (di sini dan di sini). Keduanya tersedia

dalam

bentuk

generik

dalam

kelas

java.util.ArrayList

dan

java.util.LinkedList. ArrayList

adalah urutan objek yang disimpan dalam bentuk array yang ukurannya bisa

membesar jika item baru ditambahkan. Sedangkan LinkedList adalah urutan objek yang disimpan dalam simpul yang terhubung dengan pointer seperti rantai. Kedua kelas ini mengimplementasikan interface java.util.List, yang memiliki operasi yang sama untuk semua jenis list. Kedua list tersebut mendukung operasi list dasar. Tipe data abstrak didefinisikan dalam bentuk operasi yang bisa dilakukannya, bukan bagaimana data disusun. Lalu kenapa kita memiliki 2 kelas? Mengapa bukan satu kelas List saja dengan satu jenis struktur data? Masalahnya, tidak ada satupun struktur data list yang bisa melakukan semua operasi list secara efisien. Untuk operasi tertentu, list berantai lebih efisien daripada array. Untuk operasi lainnya, array lebih efisien. Tergantung daripada bagaimana list tersebut digunakan. Kita harus bisa memilih bentuk mana yang paling cocok dengan melihat operasi apa yang sering digunakan. Secara garis besar, kelas LinkedList lebih efisien untuk aplikasi di mana item-itemnya lebih sering ditambah atau dibuang dari dalam list, terutama dari depan atau dari tengah list. Dalam array, operasi tersebut memerlukan waktu yang cukup besar, karena untuk

setiap penyisipan atau pengurangan item, item harus digeser untuk membuat tempat kosong baru ditengah list. Pada list berantai, simpul bisa diputus di tengah-tengah untuk menambahkan item baru, yaitu dengan mengubah pointernya saja. Kelas ArrayList lebih efisien digunakan jika akses random (random access) dibutuhkan oleh aplikasi. Akses random maksudnya mengakses item ke-n di tengah-tengah list dan pindah dari satu item ke item lain yang letaknya mungkin berjauhan. Operasi yang bisa dilakukan dengan efisien oleh kedua kelas tersebut adalah mengurutkan dan menambah item di akhir list. Semua list mengimplementasikan metode dalam Collection, termasuk size(), isEmpty, add(Object), remove(Object),

dan clear().

Metode add(Object) digunakan untuk menambah objek di akhir list. Metode remove(Object)

dilakukan dengan mencari itemnya dahulu, yang tidak efisien dilakukan

pada list berantai karena pada list berantai item dibandingkan satu per satu dari awal list hingga item ditemukan. Interface List menambah beberapa metode untuk mengakses item pada list tergantung dari urutannya dalam list. Untuk objek list bertipe List, metode-metode yang tersedia adalah : 

list.get(indeks)

-- mengembalikan Object di posisi indeks dalam list, di mana

indeks dimulai dari 0, 1, 2, .... hingga list.size() - 1. Parameter indeks harus ada dalam rentang ini, jika tidak maka pengecualian IndexOutOfBoundsException akan dilemparkan. 

list.set(indeks, obj)

-- menyimpan obj di dalam list pada posisi indeks, dan

mengganti isi objek yang sudah ada di posisi tersebut. Metode ini tidak mengubah jumlah elemen di dalam list atau memindahkan elemen lain. 

list.add(indeks, obj) indeks. indeks

-- menyisipkan objek obj di dalam list pada posisi

Jumlah item di dalam list akan bertambah satu, dan item setelah posisi akan digeser ke belakang. Nilai indeks harus berada pada rentang 0 hingga

list.size(). 

list.remove(indeks)

-- menghapus objek pada posisi indeks. Item setelah posisi

ini akan digeser maju untuk mengisi kekosongan objek pada posisi tersebut setelah item dihapus. 

list.indexOf(obj)

-- mencari objek obj di dalam list dan mengembalikan

indeksnya pada list, jika ada. Jika objek yang dicari tidak ada maka nilai -1 akan

dikembalikan. Jika obj ada lebih dari satu dalam list, hanya indeks pertama yang dikembalikan. Metode-metode ini didefinisikan pada kelas ArrayList dan LinkedList, meskipun metode-metode ini hanya efisien pada ArrayList. Kelas LinkedList memiliki beberapa metode tambahan yang tidak ada pada ArrayList. Jika linkedlist adalah objek bertipe LinkedList, 

maka

linkedlist.getFirst()

-- mengembalikan Object pada posisi pertama di dalam

list. List tidak diubah sama sekali. 

linkedlist.getLast()

-- mengembalikan Object pada posisi terakhir di dalam

list. List tidak diubah sama sekali. 

linkedlist.removeFirst()

-- menghapus Objek pada posisi pertama di dalam

list. Object yang dihapus akan dikembalikan sebagai nilai keluaran. 

linkedlist.removeLast() Object

-- menghapus Objek pada posisi terakhir di dalam list.

yang dihapus akan dikembalikan sebagai nilai keluaran.



linkedlist.addFirst(obj)



linkedlist.addLast(obj)

-- menambah obj pada posisi pertama di dalam list.

-- menambah obj pada posisi terakhir di dalam list.

(Sama persis dengan linkedlist.add(obj)) Metode-metode di atas sepertinya dibuat sehingga LinkedList mudah digunakan sebagai tumpukan atau antrian (lihat bagian sebelumnya dan bagian ini). Misalnya kita bisa menggunakan LinkedList sebagai antrian dengan menambah item di akhir list (menggunakan metode addLast()) dan menghapus item dari awal list (menggunakan metode removeFirst()). Jika list adalah objek bertipe List maka metode list.iterator() yang didefinisikan pada interface Collection, akan mengembalikan Iterator yang bisa digunakan untuk menelusuri list tersebut dari awal hingga akhir. Akan tetapi, untuk List ada tipe Iterator khusus yang bernama ListIterator yang memiliki kemampuan tambahan. Metode list.listIterator() mengembalikan objek bertipe ListIterator dari list. ListIterator

memiliki metode Iterator biasa, seperti hasNext() dan next(), tetapi

juga hasPrevious() dan previous sehingga kita bisa melakukan penelusuran mundur. Untuk mengerti lebih dalam, mungkin ada baiknya jika iterator diibaratkan sebagai iterator yang menunjuk pada posisi di antara dua elemen, atau di akhir atau di depan list. Dalam

diagram berikut, item dalam list digambarkan sebagai kotak, dan panah menunjukkan posisi dari iterator :

Jika iter adalah suatu ListIterator, maka 

iter.next()

memindahkan iterator satu tempat ke kanan dan mengembalikan item

yang baru dilewatinya. 

Metode iter.previous() memindahkan iterator ke kiri dan mengambalikan item yang dilewatinya.



Metode iter.remove() menghapus item dari dalam list. Item yang dihapus adalah item yang baru saja dilewati oleh iter.next() atau iter.previous().



iter.add(Object)

akan menambah Object ke dalam list pada posisi iterator

sekarang. Artinya bisa berada di tengah-tengah dua item, di awal list atau di akhir list. (Untuk pengetahuan, list yang digunakan oleh kelas LinkedList adalah list berantai ganda (doubly linked list). Artinya, setiap simpul pada list memiliki dua pointer, yaitu satu yang menunjuk pada simpul setelahnya dan satu lagi menunjuk pada simpul sebelumnya. Sehingga metode next() dan previous() bisa diimplementasikan dengan efisien. Dan juga, metode addLast() dan getLast() menjadi efisien karena kelas LinkedList juga memiliki variabel instansi yang menunjuk pada simpul terakhir di dalam list.) Sebagai contoh untuk menggunakan ListIterator, misalnya kita ingin menjaga agar suatu list selalu terurut dalam urutan menaik. Ketika kita menambah item di dalam list, kita bisa menggunakan ListIterator untuk menemukan posisi yang tepat di dalam list untuk meletakkan item baru itu. Idenya adalah memulai dari awal list, kemudian memindahkan iterator melalui semua item yang lebih kecil dari item yang ingin sisipkan. Pada posisi tersebut, metode add() dari iterator itu bisa digunakan untuk menyisipkan item pada posisi yang tepat. Untuk menentukan bahwa item baru tersebut lebih besar dari item di dalam list, maka kita asumsikan bahwa item dalam list sudah mengimplementasikan interface Comparable dan memiliki metode compareTo(). (Interface ini didiskusikan pada bagian sebelumnya). Berikut ini adalah metode untuk melakukannya. static void sisipTerurut(List list, Comparable itemBaru) {

// Kondisi awal : Item dalam ist diurut dalam urutan menaik //

menurut metode compareTo.

//

itemBaru.compareTo(item) harus didefinisikan untuk

//

setiap item di dalam list.

// // Kondisi akhir : itemBaru yang sudah ditambahkan //

ada pada posisi yang benar, sehingga list

//

masih dalam keadaan terurut menaik

ListIterator iter = list.listIterator(); // Pindahkan iterator sehingga menunjuk pada posisi yang tepat // Jika itemBaru lebih besar dari semua item di dalam list, maka // perulangan while akan berhenti ketika iter.hasNext() bernilai // false, yaitu ketika iterator sampai pada akhir list. while (iter.hasNext()) { Object item = iter.next(); if (itemBaru.compareTo(item) <= 0) { // itemBaru harus ada SEBELUM item pada iter // Pindahkan iterator satu tempat sehingga // menunjuk pada posisi penyisipan yang benar, // dan pada akhir perulangan. iter.previous(); break; } } iter.add(itemBaru); } // akhir sisipTerurut()

Karena parameter pada metode ini bertipe List, maka metode ini bisa digunakan pada ArrayList

maupun LinkedList, dan kira-kira akan berjalan dengan tingkat efisiensi yang

sama untuk kedua jenis list. Mungkin akan lebih mudah untuk menulis metode di atas dengan menggunakan indeks seperti pada array, dan dengan menggunakan metode get(indeks)

dan add(indeks,obj). Akan tetapi metode ini akan berjalan sangat lambat

untuk LinkedList karena get(indeks) pada LinkedList berjalan tidak efisien.

Pengurutan List Mengurutkan list adalah operasi yang cukup umum dilakukan, dan seharusnya ada metode untuk mengurut list di dalam interface List. Kenyataannya tidak ada. Akan tetapi metode untuk mengurut List tersedia sebagai metode statik dalam kelas java.util.Collections.

Kelas ini memiliki berbagai metode statik yang digunakan

untuk membantu kelas-kelas koleksi : 

Collections.sort(list)

digunakan untuk mengurut list dalam urutan menaik.

Item di dalam list harus mengimplementasikan interface Comparable, misalnya pada String. 

Collections.sort(list,komparator),

digunakan

untuk

mengurut

list

menggunakan komparator (pembanding) sendiri yang diberikan di dalam metode. Komparator adalah objek yang memiliki metode compare() yang digunakan untuk membandingkan dua objek. Kita akan lihat contohnya nanti. 

Collections.shuffle(list)

digunakan untuk mengacak list.



Collections.reverse(list)

digunakan untuk membalik urutan elemen di dalam

list, sehingga elemen terakhir menjadi elemen pertama dan sebaliknya. Karena metode pengurutan yang cukup efisien sudah diberikan untuk List, kita tidak perlu membuat metode pengurutan sendiri. Tentunya kita akan bertanya apakah ada metode pengurutan untuk array biasa. Jawabannya adalah ya. Pengurutan array juga tersedia dalam metode statik dalam kelas java.util.Arrays. 

Arrays.sort(A) digunakan untuk mengurut array A, asalkan tipe dasar A adalah tipe dasar primitif (kecuali boolean) atau jika A adalah array Object yang mengimplementasikan interface Comparable.



Arrays.sort(A, indeksAwal, indeksAkhir) digunakan untuk mengurut sebagian array saja. Ini penting karena array kadang hanya terisi sebagian. Perintah ini mengurut array dari elemen A[indeksAwal], A[indeksAwal + 1], ... hingga A[indeksAkhir

-

1]

dalam urutan menaik. Array.sort(A, 0, N) bisa

digunakan untuk mengurut N elemen pertama di array A. Java

tidak

mendukung

pemrograman

generik

untuk

tipe

primitif.

Untuk

mengimplementasikan perintah Arrays.sort(A), kelas Arrays memiliki 8 metode : satu metode untuk array Object dan masing-masing satu metode untuk tipe primitif byte, short, int, long, float, double,

dan char.

Set (Himpunan) Himpunan (set) adalah kumpulan Object yang mana tidak boleh ada dua dari objek yang sama di dalam satu himpunan. Objek obj1 dan obj2 adalah objek yang sama jika obj1.equals(obj2)

menghasilkan nilai true (lihat bagian sebelumnya untuk penjelasan

tentang ini). Set mengimplementasikan metode umum pada Collection dengan sedikit modifikasi sehingga tidak memiliki objek yang sama di dalamnya. Misalnya, jika set adalah objek bertipe Set maka set.add(obj) tidak melakukan apa-apa jika obj sudah ada di dalam set.

Java

memiliki

dua

java.util.TreeSet

kelas

yang

mengimplementasikan

interface

Set,

yaitu

dan java.util.HashSet.

Selain sebagai Set, objek bertipe TreeSet memiliki sifat di mana elemen-elemennya terurut dalam urutan menaik. Iterator dari suatu TreeSet akan mengunjungi elemen dalam set tersebut dalam urutan menaik. TreeSet

tidak bisa menyimpan semua objek, karena objek yang disimpan harus bisa

diurutkan. Atau dengan kata iain, objek yang disimpan dalam TreeSet harus mengimplementasikan interface Comparable dan obj1.compareTo(obj2) harus bisa membandingkan 2 objek obj1 dan obj2 dengan baik. Atau cara lainnya adalah dengan menggunakan Comparator yang bisa dimasukkan sebagai parameter dalam konstruktor ketika TreeSet dibuat. Di sini Comparator digunakan untuk membandingkan objek yang akan dimasukkan di dalam set. Pada implementasi TreeSet, elemen di dalamnya disimpan dalam bentuk yang mirip dengan pohon pengurutan biner (lihat bagian sebelumnya). Pohon yang digunakan bersifat seimbang (balanced) yang artinya semua simpul daunnya berjarak sama dari akar pohonnya. Dengan menggunakan pohon seimbang, kita bisa memastikan bahwa kita bisa mencapai semua simpul daunnya dengan secepat mungkin. Menambah dan mengurangi simpulnya juga bisa dilakukan dengan cepat. Karena TreeSet mengurutkan elemen-elemennya dan menjamin tidak ada duplikasi objek, TreeSet

sangat berguna untuk beberapa aplikasi. Misalnya, kita akan membuat program

untuk menghitung semua kata dalam suatu artikel dan menampilkan semua kata yang ditemukan. List kata-kata dalam artikel itu harus diurutkan, kemudian kata-kata yang sama dihapus. Dengan menggunakan TreeSet, program tersebut dapat dibuat dengan sangat mudah, menjadi :

TreeSet kata = new TreeSet(); while masih ada data dari input : kt = kata berikutnya dari input kata.add(kt); Iterator iter = kata.iterator(); while (iter.hasNext()): Tampikan iter.next() ke layar.

Contoh

lainnya, misalnya kol adalah

mengimplementasikan

compareTo()).

koleksi String

Kita

bisa

(atau

menggunakan

tipe lain yang TreeSet

untuk

mengurutkan item dari kol dan menghapus duplikasi dengan : TreeSet set = new TreeSet(); set.addAll(kol);

Perintah baris kedua di atas menambah semua elemen dari kol ke dalam set. Karena berbentuk Set, maka duplikasi akan dihapus. Karena berbentuk TreeSet maka semua elemennya akan terurut. Jika kita ingin data tersebut disimpan dalam struktur data lain, kita bisa mengubahnya dengan mudah. Misalnya, untuk membuat ArrayList dari TreeSet, bisa kita tulis dengan : TreeSet set = new TreeSet(); set.addAll(kol); ArrayList list = new ArrayList(); list.addAll(set);

Sebetulnya, kelas koleksi Java memiliki konstruktor yang bisa mengambil parameter berbentuk Collection. Semua item dalam Collection ditambahkan ke dalam koleksi baru ketika dibuat. Jadi new TreeSet(kol) membuat TreeSet yang memiliki elemen yang sama seperti koleksi kol. Atau kita bisa menyingkat keempat baris kode di atas dalam satu baris kode : ArrayList list = new ArrayList( new TreeSet(kol) );

Hasilnya adalah list terurut dengan elemen dari kol tanpa duplikasi. Ini adalah contoh dari keampuhan pemrograman generik. (Sepertinya tidak ada struktur data list dengan duplikasi pada Java, atau TreeSet yang membolehkan duplikasi. Pada bahasa pemrograman C++ struktur data ini disebut multiset. Pada bahasa Smalltalk, struktur data seperti ini disebut bag (kantong). Pada Java, untuk saat ini, tidak ada struktur data seperti ini.)

HashSet

mengimplementasikan tabel hash yang akan kita bahas di bagian berikutnya.

Operasi penambahan, pencarian, dan penghapusan dilakukan dengan sangat efisien pada tabel hash, bahkan lebih cepat lagi dari TreeSet. Elemen pada HashSet tidak disimpan dalam urutan tertentu. Iterator

dari HashSet akan mengunjungi elemen-elemen pada HashSet dalam urutan

yang sepertinya acak dan mungkin berubah jika elemen baru ditambahkan. Karena elemen pada HashSet tidak diurutkan, maka semua objek (termasuk yang tidak mengimplementasikan interface Comparable) bisa dimasukkan dalam HashSet. Kita bisa menggunakan HashSet jika elemen yang kita akan masukkan tidak bisa dibandingkan, atau urutannya tidak penting, atau jika kecepatan lebih dipentingkan. Kelas Map Suatu array yang berisi N elemen bisa juga dilihat sebagai asosiasi (pemetaan) antara elemennya dengan bilangan 0, 1, ..., N-1 yang merupakan indeksnya. Jika i adalah salah satu bilangan ini, maka kita bisa mengambil elemen yang dipetakan oleh bilangan i, dan juga kita bisa meletakkan elemen baru pada posisi ke-i. Suatu peta (map) adalah generalisasi dari array. Seperti array, map juga memiliki operasi untuk mengambil dan meletakkan elemen. Akan tetapi pada map, operasi ini tidak dilakukan pada bilangan 0, 1, ... N-1, akan tetapi pada sembarang Object. Beberapa bahasa pemrograman menggunakan istilah array asosiatif (associative array) karena kesamaan perintah dengan array biasa. Pada bahasa pemrograman tersebut, kita bisa menuliskan A["joko"] yang digunakan untuk memetakan "joko" pada suatu elemen di dalam array. Java tidak menggunakan perintah yang sama pada map, akan tetapi idenya serupa : Map adalah seperti array yang indeksnya adalah objek sembarang, bukan integer. Pada map, objek yang digunakan sebagai "indeks" disebut kunci (key). Objek yang ditunjuk oleh indeks tersebut disebut nilai (value). Satu kunci hanya boleh menunjuk pada satu nilai, akan tetapi satu nilai bisa ditunjuk oleh beberapa kunci. Dalam Java, map didefinisikan dalam interface java.util.Map, yang memiliki beberapa metode untuk bekerja dengan map. Jika map adalah variabel dengan tipe Map, maka berikut ini adalah beberapa metodenya : 

map.get(kunci)

-- mengembalikan Object yang ditunjuk oleh kunci. Jika map

tidak memiliki nilai yang ditunjuk oleh kunci, maka nilai null akan dikembalikan.

Tapi ingat juga bahwa mungkin saja kuncinya ada akan tetapi memang menunjuk pada nilai null. Menggunakan "map.get(kunci)" sama dengan perintah "A[kunci]" pada array A. (Akan tetapi pada map tidak ada pengecualian IndexOutOfBoundsException) 

map.put(kunci, nilai)

-- Mengisi map dengan pasangan kunci dan nilai.

Kedua-dua kunci dan nilai bisa berupa objek apa saja. Jika map tersebut telah memiliki kunci maka nilai yang ditunjuk akan diganti dengan yang baru diberikan. Perintah ini mirip dengan "A[kunci] = nilai" pada array. 

map.putAll(map2)

-- jika map2 adalah map lain, maka perintah ini akan mengkopi

semua isi pada map2 ke dalam map. 

map.remove(kunci)

-- Jika map memiliki kunci yang menunjuk pada suatu nilai,

perintah ini akan menghapus kunci beserta nilai yang ditunjuknya, atau dengan kata lain menghapus pasangan kunci dan nilai pada map sekaligus. 

map.containsKey(kunci) kunci



-- mengembalikan nilai boolean true jika map memiliki

yang merujuk pada suatu nilai

map.containsValue(nilai)

-- mengembalikan nilai boolean true jika map

memiliki nilai yang ditunjuk oleh kunci apapun. 

map.size()

-- mengembalikan int yang berisi jumlah pasangan asosiasi pada

map. 

map.isEmpty()

-- mengembalikan boolean true jika map tidak berisi pasangan

asosiasi apa-apa. 

map.clear()

-- menghapus semua pasangan asosiasi dalam map.

Metode put dan get jelas merupakan metode yang paling sering digunakan dalam map. Dalam banyak aplikasi, metode ini mungkin hanya metode ini yang kita butuhkan. Artinya, menggunakan map sama mudahnya dengan menggunakan array biasa. Java memiliki dua kelas yang mengimplementasikan interface Map, yaitu : TreeMap dan HashMap.

Dalam TreeMap, pasangan kunci/nilai disimpan secara berurutan dalam pohon terurut, yaitu diurut berdasarkan kuncinya. Supaya bisa bekerja dengan benar, maka hanya objek yang bisa dibandingkan saja yang bisa digunakan sebagai kunci. Artinya kelas kunci harus berupa kelas yang mengimplementasikan interface Comparable, atau Comparator harus diberikan pada konstruktornya pada saat TreeMap dibuat.

HashMap

tidak menyimpan pasangan kunci/nilai dalam urutan tertentu, sehingga tidak ada

batasan objek apa yang bisa disimpan di dalamnya. Hampir semua operasi dapat berjalan lebih cepat pada HashMap dibandingkan dengan TreeMap. Secara umum, lebih baik menggunakan HashMap kecuali kita butuh struktur data dalam urutan tertentu yang hanya bisa dilakukan dengan TreeMap. Atau dengan kata lain, jika kita hanya menggunakan perintah put dan get, gunakan HashMap. Misalnya progrma direktori telefon, yaitu pada kelas BukuTelepon yang memiliki pasangan nama/nomor telepon. Kelas ini memiliki operasi tambahEntri(nama, nomor) dan ambilNomor(nama), di mana nama dan nomor bertipe String. Dalam aplikasi pemrograman sebenarnya, kita tidak perlu lagi membuat kelas baru untuk mengimplementasikan BukuTelepon tersebut, artinya kita bisa langsung menggunakan Map.

Akan tetapi menggunakan Map mungkin memiliki sedikit kerugian, karena kita

dipaksa harus menggunakan Object bukan String. Jika ini masalahnya, maka kita bisa membuat kelas baru yang menggunakan Map dalam implementasinya, seperti berikut : import java.util.HashMap; public class BukuTelepon { // Menyimpan data telepon private HashMap info = new HashMap(); public void tambahEntri(String nama, String nomor) { // Menyimpan nomor telepon pada nama yang sesuai info.put(nama,nomor); } public String ambilNomor(String nama) { // Mengambil nomor telepon dari nama // Kembalikan null jika tidak ada nomor telepon untuk nama tsb return (String)info.get(nama); } } // akhir kelas BukuTelepon

Dalam metode ambilNomor di atas, nilai kembalian dari info.get(nama) di-type-cast ke dalam String. Karena kembalian dari metode get() bertipe Object maka type cast menjadi penting sebelum nilainya bisa digunakan.

Dengan "membungkus" Map di dalam kelas BukuTelepon, kita menyembunyikan type-cast dalam implementasinya sehingga interaksi kelas ini dengan kelas lain yang menggunakannya menjadi lebih natural. Tampilan, subset, dan submap Map

sebenarnya bukan merupakan Collection, artinya map tidak mengimplementasikan

semua operasi yang didefinisikan pada interface Collection, karena map tidak memiliki iterator. Akan tetapi, Java memiliki cara lain untuk melakukan penelusuran item pada map. Jika map adalah variabel bertipe Map, maka metode map.keySet()

akan mengembalikan semua objek kunci pada map. Karena di dalam map tidak ada kunci yang sama, maka hasilnya akan dikembalikan dalam bentuk Set. Hasil yang dikembalikan oleh map.keySet() disebut tampilan (view) dari objek-objek yang disimpan di dalam map. "Tampilan" yang dikembalikan metode ini berhubungan langsung dengan map aslinya, artinya jika kita menghapus elemen dari dalam tampilan ini, maka kunci beserta nilai yang ditunjuk di dalam map akan juga dihapus. Tampilan tidak bisa digunakan untuk menambah data, karena fungsinya hanya sebagai tampilan. Karena map.keySet() tidak membuat set baru, maka perintah ini akan cukup efisien untuk digunakan pada map yang sangat besar sekalipun. Kita bisa menggunakan iterator untuk melakukan penelusuran isi Set. Kita bisa juga menggunakan iterator untuk kunci dari map, kemudian menelusurinya, misalnya : Set kunci = map.keySet();

// Set kunci dari map

Iterator kunciIter = kunci.iterator(); System.out.println("Map ini memiliki asosiasi sebagai berikut:"); while (kunciIter.hasNext()) { Object knc = kunciIter.next(); Object nilai = map.get(knc); System.out.println( "

// Ambil kunci berikut // Ambil nilai yang ditunjuk oleh kunci

(" + knc + "," + nilai + ")" );

}

Jika map adalah suatu TreeMap, maka set kuncinya adalah set yang terurut, dan iteratornya akan mengunjungi kunci-kuncinya dalam urutan menaik. Interface Map memiliki 2 jenis tampilan lain. Jika map adalah variabel bertipe Map, maka metode : map.values()

mengembalikan Collection yang berisi semua nilai yang disimpan dalam map. Nilai kembaliannya bukan Set karena suatu map bisa berisi nilai yang sama. Metode

map.entrySet()

mengembalikan Set yang berisi asosiasi (kunci dan nilainya) di dalam map. Informasi dalam kelas ini sama dengan informasi dalam map itu sendiri, akan tetapi Set yang dikembalikan menampilkan jenis informasi yang berbeda. Setiap elemen dalam set ini adalah objek bertipe Map.Entry (Kelas ini adalah kelas statik bertingkat, sehingga namanya memiliki tanda titik. Akan tetapi tetap bisa digunakan sebagaimana kelas-kelas lainnya). Objek Map.Entry berisi hanya satu pasangan kunci dan nilai, dan memiliki metode getKey()

dan getValue() untuk mengambil kunci dan nilainya. Ada juga metode

setValue(nilai)

untuk mengisi nilainya. Kita bisa menggunakan set ini untuk mencetak

semua pasangan kunci dan nilainya, yang lebih efisien daripada menggunakan kunci kemudian mengambil kembali isinya dari dalam map seperti contoh di atas. Sehingga kita bisa membuat fungsi yang sama dengan di atas dengan lebih efisien, yaitu Set entri = map.entrySet(); Iterator entriIter = entri.iterator(); System.out.println("Map ini berisi asosiasi sebagai berikut:"); while (entriIter.hasNext()) { Map.Entry pasangan = (Map.Entry)entriIter.next(); Object kunci = pasangan .getKey(); Object nilai = pasangan .getValue(); System.out.println( "

// Ambil kunci dari pasangan // Ambil nilainya

(" + kunci + "," + nilai + ")" );

}

Map bukan satu-satunya tempat di mana tampilan bisa diambil. Misalnya, interface List memiliki sublist yang untuk melihat sebagian isi list. Metode List subList(int indeksAwal, int indeksAkhir)

mengembalikan sebagian list yang terdiri dari elemen pada posisi antara indeksAwal hingga indeksAkhir (termasuk indeksAwal tapi tidak termasuk indeksAkhir.) Tampilan ini memungkinkan kita untuk melakukan operasi apapun seperti pada list biasa, akan tetapi sublist bukan list terpisah. Perubahan yang dilakukan pada sublist akan juga mempengaruhi list aslinya. Begitu juga dengan set, kita bisa membuat tampilan yang merupakan subset dari suatu set. Jika set adalah suatu TreeSet, maka set.subSet(dariElemen, hinggaElemen) mengembalikan [code]Set hinggaElemen

yang berisi elemen-elemen set antara dariElemen hingga

(termasuk dariElemen tapi tidak termasuk hinggaElemen).

Misalnya, jika kata adalah suatu TreeSet di mana semua elemennya adalah String berisi huruf kecil, maka kata.subSet("m", "n") akan berisi semua elemen pada kata yang dimulai dari huruf m. Subset ini adalah tampilan yang merupakan bagian dari set aslinya. Artinya membuat subset tidak mengkopi elemen, dan perubahan pada subset (misalnya penambahan dan pengurangan elemen) juga mempengaruhi set aslinya. Tampilan set.headSet(hinggaElemen) berisi semua elemen dari set yang kurang dari [code]hinggaElemen,

dan set.tailSet(dariElemen) adalah tampilan

yang berisi semua elemen yang lebih besar atau sama dengan dariElemen. Kelas TreeMap memiliki tiga tampilan submap. Submap mirip dengan subset. Submat adalah Map yang berisi subset dari kunci dan nilai pada Map aslinya. Jika map suatu variabel bertipe TreeMap, maka map.subMap(dariKunci,

hinggaKunci)

mengembalikan

tampilan yang berisi semua pasangan kunci/nilai dari map yang kuncinya ada di antara dariKunci

dan hinggaKunci (termasuk dariKunci tapi tidak termasuk hinggaKunci).

Ada juga tampilan map.headMap(hinggaKunci) dan map.tailMap(dariKunci) seperti aturan pada subset. Misalnya, bukuHitam adalah suatu TreeMap di mana kuncinya adalah nama dan nilainya adalah nomor telepon. Kita bisa mencetak semua entri pada bukuHitam yang namanya dimulai dengan "M" seperti berikut : Map ems = bukuHitam.subMap("M","N"); // Submap ini berisi semua elemen di mana kuncinya lebih // besar dari "M" dan kurang dari (tapi tidak termasuk) "N" if (ems.isEmpty()) System.out.println("Tidak ada elemen yang dimulai dengan M."); else { Iterator iter = ems.entrySet().iterator(); // Iterator ini akan menelusuri entri pada submap ems while (iter.hasNext()) { // Get the next entry and print its key and value. Map.Entry entri = iter.next(); System.out.println( entri.getKey() + ": " + entri.getValue() ); } }

Subset dan submap mungkin menjadi cara terbaik untuk melakukan pencarian, sehingga kita bisa mencari elemen pada rentang nilai tertentu, bukan hanya pencarian satu nilai saja. Misalnya pada database disimpan jadwal yang disimpan dalam bentuk TreeMap di mana

kuncinya adalah waktu, dan misalnya kita ingin mencari semua item yang terjadwal 1 Maret 2009. Kita hanya perlu membuat submap yang berisi semua kunci antara 00:00 1 Maret 2009 hingga 00:00 2 Maret 2009 kemudian mencetak isi submap tersebut. Tipe pencarian seperti ini disebut pencarian rentang (subrange query). Tabel Hash HashSet

dan HashMap diimplementasikan dengan struktur data yang disebut tabel hash.

Kita tidak perlu mengerti tabel hash untuk menggunakan HashSet atau HashMap, akan tetapi programmer harus kenal dengan tabel hash dan cara kerjanya. Tabel hash merupakan solusi elegan untuk menyelesaikan masalah pencarian. Tabel hash, seperti HashMap, menyimpan pasangan kunci/nilai. Jika kita mengetahui kuncinya, maka kita bisa mencari nilainya di dalam tabel. Jika tabel hash digunakan untuk mengimplementasikan set, maka semua nilainya berisi null. Kita masih harus mencari kuncinya di dalam tabel. Dalam semua algoritma pencarian, untuk mencari suatu item, kita harus mencari item yang tidak kita inginkan. Untuk mencari suatu item di dalam list tidak terurut, maka kita harus mengecek isinya satu per satu hingga item yang kita cari ditemukan. Dalam pohon pencarian biner, kita harus mulai dari akar dan turun ke bawah hingga item yang dicari ditemukan. Jika kita mencari pasangan kunci/nilai dalam tabel hash, kita bisa langsung ke tempat di mana item tersebut berada. Kita tidak perlu mencari item lainnya (Sebenarnya tidak sepenuhnya benar, tapi kira-kira seperti ini). Lokasi di mana pasangan kunci/nilai ini berada dihitung dari kuncinya: Kita hanya melihat kuncinya, dan kita bisa pergi ke lokasi di mana nilai tersebut disimpan secara langsung. Bagaimana caranya? Jika kuncinya adalah integer antara 0 hingga 99, kita bisa menyimpan pasangan kunci/nilai dalam array A yang berisi 100 elemen. Pasangan kunci/nilai dengan kunci N bisa disimpan dalam A[N]. Kunci ini akan membawa kita langsung ke pasangan kunci/nilai. Masalahnya, ada banyak kemungkinan untuk suatu jenis kunci. Misalnya, jika kuncinya bertipe int, maka kita perlu 4 milyar lokasi untuk menyimpan semua kuncinya dalam array -- tentunya pemborosan memori yang sia-sia jika kita hanya ingin menyimpan katakan ribuan item saja. Jika kuncinya berupa string dengan panjang yang tidak tentu, maka jumlah kemungkinan kuncinya tidak terbatas, sehingga kita tidak mungkin menggunakan array untuk menyimpan semua kemungkinan kuncinya.

Walau bagaimanapun, tabel hash menyimpan datanya dalam array. Indeks tidak sama dengan kunci, akan tetapi indeks dihitung dari kunci. Indeks array dari hasil perhitungan kunci disebut kode hash untuk kunci tersebut. Fungsi tertentu akan menghitung kode hash, yang disebut fungsi hash. Untuk mencari kunci di dalam tabel hash, kita hanya pelu menghitung kode hash kunci tersebut, kemudian langsung pergi ke lokasi array di ditunjuk oleh kode hash tersebut. Jika kode hashnya 17, lihat langsung pada array nomor 17. Sekarang, karena hanya ada lebih sedikit lokasi array dibandingkan kemungkinan kuncinya, maka sangat mungkin kita memiliki situasi di mana satu lokasi array digunakan dua atau lebih kunci. Hal ini disebut tabrakan (collision). Tabrakan bukan kesalahan. Kita tidak bisa menolak suatu kunci karena memiliki kode hash yang sama dengan kunci lain. Tabel hash harus bisa menangani tabrakan dengan cara yang baik. Dalam tabel hash yang digunakan pada Java, setiap lokasi array sebetulnya adalah suatu list berantai yang berisi pasangan kunci/nilai (atau mungkin juga list kosong). Jika dua item memiliki kode hash yang sama, maka kedua item tersebut akan ada pada list yang sama. Strukturnya bisa digambarkan sebagai berikut.

Pada gambar di atas, hanya ada satu item dengan kode hash 0, tidak ada item dengan kode hash 1, dua item dengan kode hash 2, dan seterusnya. Pada tabel hash yang dirancang dengan benar, hampir semua list berantai berisi nol atau satu elemen saja, dengan rata-rata panjang list kurang dari 1. Meskipun kode hash dari suatu kunci mungkin tidak membawa kita langsung pada kunci yang kita mau, akan tetapi tidak akan lebih dari satu atau dua item yang harus kita cari sebelum kita sampai pada item yang kita inginkan.

Agar bekerja dengan benar, jumlah item dalam tabel hash harus kurang dari besarnya array. Pada Java, katika jumlah item melebihi 75% ukuran array, maka array tersebut akan diganti dengan array yang lebih besar dan semua item pada array yang lama dipindahkan ke array baru. Kelas Object memiliki metode bernama hashCode() yang mengembalikan nilai bertipe int. Ketika objek obj disimpan dalam tabel yang berukuran N, maka kode hash antara 0 hingga

N-1

diperlukan.

Kode

Math.abs(obj.hashCode()) obj.hashCode()

%

hash N,

ini

bisa

dihitung

dengan

yaitu

sisa

pembagian

dari

menggunakan nilai

mutlak

dengan N. (Nilai mutlak diperlukan karena obj.hashCode() bisa

bernilai negatif, dan kita tidak ingin nilai negatif sebagai indeks array kita). Supaya hash bisa bekerja dengan benar, dua objek yang sama menurut metode equals() seharusnya memiliki kode hash yang sama. Dalam kelas Object metode equals() dan hashCode()

dihitung berdasarkan lokasi memori di mana objek tersebut disimpan. Akan

tetapi seperti disebutkan sebelumnya, banyak kelas yang memiliki metode equals() sendiri. Jika suatu kelas memiliki metode equals() sendiri, dan jika objek tersebut akan digunakan sebagai kunci pada tabel hash, maka kelas tersebut juga harus mendefinisikan metode hashCode(). Misalnya dalam kelas String, metode equals() didefinisi ulang sehingga dua objek String

dianggap sama jika urutan karakter dalam String tersebut sama. Metode

hashCOde()

pada kelas String itu juga didefinisi ulang sehingga kode hash dari string

dihitung berdasarkan karakter di dalam String, bukan lokasi memorinya. Untuk kelas standar Java, kita bisa berharap bahwa metode equals() dan hashCode sudah dibuat dengan benar, akan tetapi untuk kelas yang kita buat sendiri kita mungkin harus membuat fungsi hash sendiri. Bab X - Pengenalan Input/Output (I/O) Program komputer bisa berguna jika ia bisa berinteraksi dengan dunia lain. Interaksi di sini maksudnya input/output atau I/O. Pada bab ini, kita akan melihat input output pada file dan koneksi jaringan (network). Pada Java, input/output pada file dan jaringan dilakukan berdasarkan aliran (stream), di mana semua objek dapat melakukan perintah I/O yang sama. Standar output (System.out) dan standar input (System.in) adalah contoh aliran. Untuk bekerja dengan file dan jaringan, kita membutuhkan pengetahuan tentang pengecualian, yang telah dibahas sebelumnya. Banyak subrutin yang digunakan untuk

bekerja dengan I/O melemparkan pengecualian yang wajib ditangani. Artinya subrutin tersebut harus dipanggil di dalam pernyataan try ... catch sehingga pengecualian yang terjadi bisa ditangani dengan baik. Stream, Reader, dan Writer Tanpa bisa berinteraksi dengan dunia lain, suatu program tidak ada gunanya. Interaksi suatu program dengan dunia lain sering disebut input/output atau I/O. Sejak dulu, salah satu tantangan terbesar untuk mendesain bahasa pemrograman baru adalah mempersiapkan fasilitas untuk melakukan input dan output. Komputer bisa terhubung dengan beragam jenis input dan output dari berbagai perangkat. Jika bahasa pemrograman harus dibuat secara khusus untuk setiap jenis perangkat, maka kompleksitasnya akan tak lagi bisa ditangani. Salah satu kemajuan terbesar dalam sejarah pemrograman adalah adanya konsep (atau abstraksi) untuk memodelkan perangkat I/O. Dalam Java, abstraksi ini disebut dengan aliran (stream). Bagian ini akan memperkenalkan tentang aliran, akan tetapi tidak menjelaskan dengan komplit. Untuk lebih lengkapnya, silakan lihat dokumen resmi Java. Ketika berhubungan dengan input/output, kita harus ingat bahwa ada dua kategori data secara umum : data yang dibuat oleh mesin, dan data yang bisa dibaca manusia. Data yang dibuat mesin ditulis dengan model yang sama dengan bagaimana data tersebut disimpan di dalam komputer, yaitu rangkaian nol dan satu. Data yang bisa dibaca manusia adalah data dalam bentuk rangkaian huruf. Ketika kita membaca suatu bilangan 3.13159, kita membacanya sebagai rangkaian huruf yang kita terjemahkan sebagai angka. Angka ini akan ditulis dalam komputer sebagai rangkaian bit yang kita tidak mengerti. Untuk menghadapi kedua jenis data ini, Java memiliki dua kategori besar untuk aliran : aliran byte untuk data mesin (byte stream), dan aliran karakter (character stream) untuk data yang bisa dibaca manusia. Ada banyak kelas yang diturunkan dari kedua kategori ini. Setiap objek yang mengeluarkan data ke aliran byte masuk sebagai kelas turunan dari kelas abstrak OutputStream. Objek yang membaca data dari aliran byte diturunkan dari kelas abstrak InputStream. Jika kita menulis angka ke suatu OutputStream, kita tidak akan bisa membaca data tersebut karena ditulis dalam bahasa mesin. Akan tetapi data tersebut bisa dibaca kembali oleh InputStream. Proses baca tulis data akan menjadi sangat efisien, karena tidak ada penerjemahan yang harus dilakukan : bit yang digunakan untuk menyimpan data di dalam memori komputer hanya dikopi dari dan ke aliran tersebut. Untuk membaca dan menulis data karakter yang bisa dimengerti manusia, kelas utamanya adalah Reader dan Writer. Semua kelas aliran karakter merupakan kelas turunan dari

salah satu dari kelas abstrak ini. Jika suatu angka akan ditulis dalam aliran Writer, komputer harus bisa menerjemahkannya ke dalam rangkaian karakter yang bisa dibaca maunsia. Membaca angka dari aliran Reader menjadi variabel numerik juga harus diterjemahkan, dari deretan karakter menjadi rangkaian bit yang dimengerti komputer. (Meskipun untuk data yang terdiri dari karakter, seperti dari editor teks, masih akan ada beberapa terjemahan yang dilakukan. Karakter disimpan dalam komputer dalam nilai Unicode 16-bit. Bagi orang yang menggunakan alfabet biasa, data karakter biasanya disimpan dalam file dalam kode ASCII, yang hanya menggunakan 8-bit. Kelas Reader dan Writer akan menangani perubahan dari 16-bit ke 8-bit dan sebaliknya, dan juga menangani alfabet lain yang digunakan negara lain.) Adalah hal yang mudah untuk menentukan apakah kita harus menggunakan aliran byte atau aliran karakter. Jika kita ingin data yang kita baca/tulis untuk bisa dibaca manusia, maka kita gunakan aliran karakter. Jika tidak, gunakan aliran byte. System.in dan System.out

sebenarnya adalah aliran byte dan bukan aliran karakter, karenanya bisa

menangani input selain alfabet, misalnya tombol enter, tanda panah, escape, dsb. Kelas aliran standar yang akan dibahas berikutnya didefinisikan dalam paket java.io beserta beberapa kelas bantu lainnya. Kita harus mengimpor kelas-kelas tersebut dari paket ini jika kita ingin menggunakannya dalam program kita. Artinya dengan menggunakan "import java.io.*" di awal kode sumber kita. Aliran tidak digunakan dalam GUI, karena GUI memiliki aliran I/O tersendiri. Akan tetapi kelas-kelas ini digunakan juga untuk file atau komunikasi dalam jaringan. Atau bisa juga digunakan untuk komunikasi antar thread yang sedang bekerja secara bersamaan. Dan juga ada kelas aliran yang digunakan untuk membaca dan menulis data dari dan ke memori komputer. Operasi pada Aliran (Stream) Kelas dasar I/O Reader, Writer, InputStream dan OutputStream hanya menyediakan operasi I/O sangat dasar. Misalnya, kelas InputStream memiliki metode instansi public int read() throws IOException

untuk membaca satu byte data dari aliran input. Jika sampai pada akhir dari aliran input , metode read() akan mengembalikan nilai -1. Jika ada kesalahan yang terjadi pada saat pengambilan input, maka pengecualian IOException akan dilemparkan. Karena IOException

adalah kelas pengecualian yang harus ditangani, artinya kita harus

menggunakan metode read() di dalam penyataan try atau mengeset subrutin untuk

throws

IOException.

(Lihat kembali pembahasan tentang pengecualian di bab

sebelumnya) Kelas InputStream juga memiliki metode untuk membaca beberapa byte data dalam satu langkah ke dalam array byte. Akan tetapi InputStream tidak memiliki metode untuk membaca jenis data lain, seperti int atau double dari aliran. Ini bukan masalah karena dalam prakteknya kita tidak akan menggunakan objek bertipe InputStream secara langsung. Yang akan kita gunakan adalah kelas turunan dari InputStream yang memiliki beberapa metode input yang lebih beragam daripada InputStream itu sendiri. Begitu juga dengan kelas OutputStream memiliki metode output primitif untuk menulis satu byte data ke aliran output, yaitu metode public void write(int b) throws IOException

Tapi, kita hampir pasti akan menggunakan kelas turunannya yang mampu menangani operasi yang lebih kompleks. Kelas Reader dan Writer memiliki operasi dasar yang hampir sama, yaitu read dan write,

akan tetapi kelas ini berorientasi karakter (karena digunakan untuk membaca dan

menulis data yang bisa dibaca manusia). Artinya operasi baca tulis akan mengambil dan menulis nilai char bukan byte. Dalam prakteknya kita akan menggunakan kelas turunan dari kelas-kelas dasar ini. Salah satu hal menarik dari paket I/O pada Java adalah kemungkinan untuk menambah kompleksitas suatu aliran dengan membungkus aliran tersebut dalam objek aliran lain. Objek pembungkus ini juga berupa aliran, sehingga kita juga bisa melakukan baca tulis dari objek yang sama dengan tambahan kemampuan dalam objek pembungkusnya. Misalnya, PrintWriter adalah kelas turunan dari Writer yang memiliki metode tambahan untuk menulis tipe data Java dalam karakter yang bisa dibaca manusial. Jika kita memiliki objek bertipe Writer atau turunannya, dan kita ingin menggunakan metode pada PrintWriter

untuk menulis data, maka kita bisa membungkus objek Writer dalam objek

PrintWriter.

Contoh jika baskomKarakter bertipe Writer, maka kita bisa membuat PrintWriter printableBaskomKarakter = new PrintWriter(baskomKarakter);

Ketika kita menulis data ke printableBaskomKarakter dengan menggunakan metode pada PrintWriter yang lebih canggih, maka data tersebut akan ditempatkan di tempat yang sama dengan apabila kita menulis langsung pada baskomKarakter. Artinya kita hanya perlu membuat antar muka yang lebih baik untuk aliran output yang sama. Atau

dengan kata lain misalnya kita bisa menggunakan PrintWriter untuk menulis file atau mengirim data pada jaringan. Untuk lengkapnya, metode pada kelas PrintWriter memiliki metode sebagai berikut : // Metode untuk menulis data dalam // bentuk yang bisa dibaca manusia public void print(String s) public void print(char c) public void print(int i) public void print(long l) public void print(float f) public void print(double d) public void print(boolean b) // Menulis baris baru ke aliran public void println() // Metode ini sama dengan di atas // akan tetapi keluarannya selalu // ditambah dengan baris baru public void println(String s) public void println(char c) public void println(int i) public void println(long l) public void println(float f) public void println(double d public void println(boolean b)

Catatan bahwa metode-metode di atas tidak pernah melempar pengecualian IOException. Akan tetapi, kelas PrintWriter memiliki metode public boolean checkError()

yang akan mengembalikan true jika ada kesalahan yang terjadi ketika menulis ke dalam aliran. Kelas PrintWriter menangkap pengecualian IOException secara internal, dan mengeset nilai tertentu di dalam kelas ini jika kesalahan telah terjadi. Sehingga kita bisa menggunakan metode pada PrintWriter tanpa khawatir harus menangkap pengecualian yang mungkin terjadi. Akan tetapi, jika kita ingin membuat progam yang tangguh tentunya kita harus selalu memanggil checkError() untuk melihat apakah kesalahan telah terjadi ketika kita menggunakan salah satu metode pada PrintWriter.

Ketika kita menggunakan metode PrintWriter untuk menulis data ke aliran, data tersebut diubah menjadi rangkaian karakter yang bisa dibaca oleh manusia. Bagaimana caranya jika kita ingin membuat data dalam bentuk bahasa mesin? Paket java.io memiliki kelas aliran byte, yaitu DataOutputStream yang bisa digunakan untuk menulis suatu data ke dalam aliran dalam format biner. DataOutputStream berhubungan erat dengan OutputStream seperti hubungan antara PrintWriter dan Writer.

Artinya, OutputStream hanya berisi metode dasar untuk menulis byte, sedangkan memiliki metode writeDouble(double x) untuk menulis nilai

DataOutputStream

double, writeInt(int x) untuk menulis nilai int, dan seterusnya. Dan juga kita bisa membungkus

objek

DataOutputStream

bertipe

OutputStream

atau

turunannya

ke

dalam

aliran

sehingga kita bisa menggunakan metode yang lebih kompleks.

Misalnya, jika baskomByte adalah variabel bertipe OutputStream, maka DataOutputStream baskomData = new DataOutputStream(baskomByte);

untuk membungkus baskomByte dalam baskomData. Untuk mengambil data dari aliran, java.io memiliki kelas DataInputStream. Kita bisa membungkus objek bertipe InputStream atau turunannya ke dalam objek bertipe DataInputStream.

Metode di dalam DataInputStream untuk membaca data biner bisa

menggunakan readDouble(), readInt() dan seterusnya. Data yang ditulis oleh DataOutputStream

dijamin untuk bisa dibaca kembali oleh DataInputStream, meskipun

data kita tulis pada satu komputer dan data dibaca pada komputer jenis lain dengan sistem operasi berbeda. Kompatibilitas data biner pada Java adalah salah satu keunggulan Java untuk bisa dijalakan pada beragam platform. Salah satu fakta yang menyedihkan tentang Java adalah ternyata Java tidak memiliki kelas untuk membaca data dalam bentuk yang bisa dibaca oleh manusia. Dalam hal ini Java tidak memiliki kelas kebalikan dari PrintWriter sebagaimana DataOutputStream dan DataInputStream.

Akan tetapi kita tetap bisa membuat kelas ini sendiri dan

menggunakannya dengan cara yang persis sama dengan kelas-kelas di atas. Kelas PrintWriter, DataInputStream, dan DataOutputStream memungkinkan kita untuk melakukan input dan output semua tipe data primitif pada Java. Pertanyaannya bagaimana kita melakukan baca tulis suatu objek?

Mungkin secara tradisional kita akan membuat fungsi sendiri untuk memformat objek kita menjadi bentuk tertentu, misalnya urutan tipe primitif dalam bentuk biner atau karakter kemudian disimpan dalam file atau dikirim melalui jaringan. Proses ini disebut serialisasi (serializing) objek. Pada inputnya, kita harus bisa membaca data yang diserialisasi ini sesuai dengan format yang digunakan pada saat objek ini diserialisasi. Untuk objek kecil, pekerjaan semacam ini mungkin bukan masalah besar. Akan tetapi untuk ukuran objek yang besar, hal ini tidak mudah. Akan tetapi Java memiliki cara untuk melakukan input dan output isi objek secara otomatis, yaitu dengan menggunakan ObjectInputStream dan ObjectOutputStream. Kelas-kelas ini adalah kelas turunan dari InputStream dan OutputStream yang bisa digunakan untuk membaca dan menulis objek yang sudah diserialisasi. ObjectInputStream

dan ObjectOutputStream adalah kelas yang bisa dibungkus oleh

kelas InputStream dan OutputStream lain. Artinya kita bisa melakukan input dan output objek pada aliran byte apa saja. Metde untuk objek I/O adalah readObject() yang tersedia pada ObjectInputStream dan writeObject(Object obj)

yang tersedia dalam ObjectOutputStream. Keduanya bisa

melemparkan IOException. Ingat bahwa readObject() mengembalikan nilai bertipe Object

yang artinya harus di-type cast ke tipe sesungguhnya.

ObjectInputStream

dan ObjectOutputStream hanya bekerja untuk objek yang

mengimplementasikan interface yang bernama Serializable. Lbih jauh semua variabel instansi pada objek harus bisa diserialisasi, karena interface Serializable tidak mempunyai metode apa-apa. Interface ini ada hanya sebagai penanda untuk kompiler supaya kompiler tahu bahwa objek ini digunakan untuk baca tulis ke suatu media. Yang perlu kita lakukan adalah menambahkan "implements Serializable" pada definisi kelas. Banyak kelas standar Java yang telah dideklarasikan untuk bisa diserialisasi, termasuk semua komponen kelas Swing dan AWT. Artinya komponen GUI pun bisa disimpan dan dibaca dari dalam perangkat I/O menggunakan ObjectInputStream dan ObjectOutputStream.

Berbagai Jenis InputStream dan OutputStream InputStream Beberapa kelas turunan dari InputStream dapat dirangkum dalam tabel di bawah ini : Kelas

Kegunaan

Argumen yang dibutuhkan

untuk membuat objek ByteArrayInputStream

StringBufferInputStream

Menggunakan

pada Buffer yang akan digunakan

memori sebagai aliran input Mengubah

string

menjadi

InputStream

Untuk

FileInputStream

buffer

Suatu String (di dalamnya sebenarnya

menggunakan

StringBuffer)

membaca

informasi

dari dalam file

String

data

ditulis

yang berupa nama

suatu file, atau objek bertipe File

Menghasilkan

atau FileDescriptor

yang oleh

PipedOutputStream.

PipedInputStream

sebagai aliran input

Mengimplementasi "piping".

Bisa

konsep

Objek PipedOutputStream

digunakan

untuk multi-threading Dua atau lebih objek bertipe Menggabungkan SequenceInputStream

dua

atau InputStream atau kontainer

lebih InputStream menjadi bertipe Enumeration yang satu InputStream

berisi

InputStream

yang

akan digabungkan Kelas abstrak yang merupakan FilterInputStream

interface dari beberapa kelas bantu

untuk

InputStream FilterInputStream

menggunakan lain

adalah lapisan di atas InputStream yang berguna untuk memberi

landasan pada kelas-kelas dekorator di atas. Kenapa dekorator? Karena kelas-kelas ini hanya memberikan fungsionalitas tambahan, akan tetapi tidak mengubah bagaimana I/O itu sendiri bekerja. Seperti disebutkan sebelumnya, bahwa kelas dasar InputStream dan OutputStream

hanya memiliki metode-metode paling sederhana. Kelas-kelas ini

memperbanyak metode baca/tulis untuk kemudahan pemrograman. Kelas FilterInputStream sendiri terdiri dari beberapa jenis, yang bisa dirangkum dalam tabel berikut ini :

Argumen Kelas

yang

dibutuhkan untuk

Kegunaan

membuat objek Digunakan

bersama-sama

DataOutputStream DataInputStream

dengan

sehingga kita bisa

menulis tipe data primitif, kemudian InputStream membacanya

kembali

tanpa

harus

diformat sendiri

Digunakan

untuk

menghindari InputStream

pembacaan langsung dari media secara dengan BufferedInputStream

fisik

setiap

diberikan.

kali

Atau

perintah dengan

read()

kata

lain menentukan

LineNumberInputStream

nomor

InputStream.

perintah

baris

dalam

Kita bisa menggunakan

getLineNumber()

besar

buffer sendiri

"gunakan buffer" untuk baca tulis Mencatat

kemungkinan

dan

InputStream

setLineNumber(int)

Memiliki satu byte buffer sehingga kita PushBackInputStream

bisa meletakkan kembali karakter yang InputStream sudah diambil (dibaca)

OutputStream Beberapa kelas turunan dari OutputStream dapat dirangkum dalam tabel di bawah ini : Argumen Kelas

Kegunaan

yang

dibutuhkan

untuk

membuat objek Membuat buffer dalam memori. Opsional ByteArrayOutputStream

Semua data yang kita kirim akan memberikan besar buffer disimpan di memori ini.

FileOutputStream

untuk

yang akan disiapkan

Untuk menulis informasi ke dalam String yang berupa nama file

suatu

file,

atau

objek

bertipe

File

atau

FileDescriptor

Informasi yang kita kirim di aliran output ini akan berakhir pada objek PipedOutputStream

bertipe

PipedInputStream.

Objek

Mengimplementasi konsep "piping". PipedInputStream Bisa

digunakan

untuk

multi-

threading Kelas FilterOutputStream

abstrak

yang

merupakan

interface dari beberapa kelas bantu untuk menggunakan OutputStream lain.

Kelas FilterOutputStream sendiri terdiri dari beberapa jenis, yang bisa dirangkum dalam tabel berikut ini : Argumen Kelas

dibutuhkan

Kegunaan

yang untuk

membuat objek Digunakan

bersama-sama

DataInputStream DataOutputStream

dengan

sehingga kita bisa

menulis tipe data primitif, kemudian OutputStream membacanya

kembali

tanpa

harus

diformat sendiri Untuk mengeluarkan output yang sudah OutputStream dengan diformat.

DataOutputStream

hanya tambahan opsi boolean

menangani bagaimana data disimpan untuk PrintStream

sehingga

bisa

PrintStream

diambil

memerintahkan

kembali. buffer

lebih berkonsentrasi pada dikosongkan

akan (flush)

"tampilan", sehingga data yang ditulis setiap kali baris baru bisa dibaca dengan baik. Digunakan BufferedOutputStream

untuk

ditulis. menghindari OutputStream dengan

penulisan langsung dari media secara kemungkinan fisik setiap kali perintah write() menentukan

besar

diberikan.

Atau

dengan

kata

lain buffer sendiri

"gunakan buffer" untuk baca tulis. Kita bisa menggunakan perintah flush() untuk

mengosongkan

buffer

dan

mengirimkan hasilnya ke media fisik. File Data dan program pada memori komputer hanya bisa bertahan selama komputer itu nyala. Untuk tempat penyimpanan yang lebih lama, komputer menggunakan file, yaitu kumpulan data yang disimpan dalam hard disk, disket atau CD-ROM, USB stick, dan lain-lain. File disusun dalam direktori (atau sering juga disebut folder). Direktori bisa terdiri dari direktori lain atau file lain. Nama direktori dan file digunakan untuk mencari suatu file dalam komputer. Program dapat membaca data dari file yang sudah ada. Program juga bisa membuat file baru atau menulis data ke dalam file yang sudah ada. Dalam Java, input dan output seperti ini bisa menggunakan aliran (stream). Data karakter yang bisa dibaca manusial dapat dibaca dari file dengan menggunakan objek dari kelas FileReader yang merupakan kelas turunan Reader. Data bisa ditulis dalam bentuk yang bisa dibaca manusia dengan menggunakan FileWriter yang merupakan kelas turunan dari Writer. Untuk membaca atau menyimpan suatu file dalam format mesin, kelas I/O-nya adalah FileInputStream

dan FileOutputStream. Semua kelas ini didefinisikan dalam paket

java.io.

Perlu dicatat bahwa applet yang didownload dari suatu jaringan pada umumnya tidak bisa mengakses file karena pertimbangan keamanan. Kita bisa mendownload dan menjalankan applet, yaitu dengan mengunjungi halaman web pada browser kita. Jika applet tersebut bisa digunakan untuk mengakses file pada komputer kita, maka orang bisa membuat applet untuk menghapus semua file dalam komputer yang mendownloadnya. Untuk mencegah hal seperti itu, ada beberapa hal di mana applet yang didownload tidak bisa lakukan. Mengakses file adalah salah satu hal yang dilarang. Akan tetapi program desktop bisa memiliki akses ke file kita seperti program-program lainnya. Program desktop bisa melakukan akses file yang dijelaskan pada bagian ini. Kelas FileReader memiliki konstruktor yang mengambil nama file sebagai parameternya, kemudian membuat aliran input yang bisa digunakan untuk membaca file tersebut.

Konstruktor ini akan melemparkan pengecualian bertipe FileNotFoundException jika file tersebut tidak ditemukan. Jenis pengecualian seperti ini membutuhkan penanganan wajib, sehingga kita harus memanggil konstruktor di dalam pernyataan try atau menambahkan pernyataan throw di kepala subrutin yang menjalankan konstruktor tersebut. Milsanya, anggap kita memiliki file bernama "data.txt", dan kita ingin membuat program untuk membaca data pada file tersebut. Kita bisa menggunakan pernyataan berikut untuk membaca aliran input dari file tersebut : // (Mendeklarasikan variabel sebelum pernyataan try // jika tidak, maka variabel tersebut hanya bisa // dilihat di dalam blok try, dan kita tidak bisa // menggunakannya lagi di bagian program lain FileReader data; try { // buat aliran input data = new FileReader("data.txt"); } catch (FileNotFoundException e) { ... // lakukan sesuatu untuk menangani kesalahan }

Kelas FileNotFoundException merupakan kelas turunan dari IOException, sehingga kita bisa menangkap IOException pada pernyataan try...catch di atas. Secara umum, hampir semua kesalahan yang terjadi pada saat operasi input/output dapat ditangkap dengan pernyataan catch yang menangani IOException. Begitu kita berhasil membuat FileReader, kita bisa mulai membacanya. Tapi karena FileReader

hanya memiliki metode input primitif dari standar kelas Reader, kita mungkin

akan perlu membungkusnya dalam objek lain, misalnya BufferedReader atau kelas pembungkus lain. Untuk membuat BufferedReader untuk membaca file bernama "data.dat", kita bisa gunakan : TextReader data; try { data = new BufferedReader(new FileReader("data.dat")); } catch (FileNotFoundException e) { ... // tangani pengecualian }

BufferedReader readline().

memiliki metode bantu untuk mengambil data per baris dengan perintah

Sehingga apabila satu data ditulis dalam urutan per baris, kita bisa gunakan

perintah Double.parseDouble(string) atau Integer.parseInt(string) untuk mengubahnya menjadi double atau int. Untuk menyimpan data tidaklah lebih sulit dari ini. Kita bisa membuat objek bertipe FileWriter.

Dan kemudian kita mungkin ingin membungkus aliran output ini dalam

objek PrintWriter. Misalnya, kita ingin menyimpan data ke file yang bernama "hasil.dat", kita bisa menggunakan : PrintWriter result; try { keluaran = new PrintWriter(new FileWriter("hasil.dat")); } catch (IOException e) { ... // tangani pengecualian }

Jika tidak ada file bernama "hasil.dat", maka file baru akan dibuat. Jika file sudah ada, maka isinya akan dihapus dan diganti dengan data yang ditulis oleh program kita. Pengecualian IOException bisa terjadi jika, misalnya, file tersebut sedang dibaca oleh program lain, sehingga sistem operasi menolak program kita untuk menulisnya pada saat yang sama. Setelah kita selesai menggunakan file, sebaiknya anda menutup file tersebut, atau mengatakan kepada sistem operasi bahwa kita telah selesai menggunakan file itu (Jika kita lupa, sistem operasi akan menutup file secara otomatis setelah program selesai dijalankan atau objek aliran file diambil oleh pemulung memori, akan tetapi akan sangat baik jika kita menutup file secara manual untuk menghindari kemungkinan lainnya). Kita bisa menutup file dengan menggunakan metode close() pada aliran tersebut. Setelah file telah ditutup, maka kita tidak mungkin lagi membaca atau menulis data dari atau ke file tersebut. Kita harus membukanya kembali. (Perlu dicatat bahwa penutupan file juga bisa melemparkan pengecualian IOException yang wajib ditangani, akan tetapi PrintWriter

menangani pengecualian tersebut secara otomatis sehingga kita tidak perlu

menanganinya lagi). Sebagai contoh komplit, berikut ini adalah program yang akan membaca angka dari file bernama "data.dat", dan kemudian menuliskannya kembali dalam urutan terbalik ke dalam file yang bernama "hasil.dat". Dalam file tersebut hanya akan ada satu angka untuk setiap

barisnya dan diasumsikan tidak ada lebih dari 1000 angka sekaligus. Penanganan pengecualian digunakan untuk mengecek apakah ada masalah di tengah operasi. Meskipun mungkin tidak begitu berguna untuk aplikasi sungguhan, akan tetapi program ini mendemonstrasikan bagaimana menggunakan operasi baca tulis sederhana pada file. package balikfile; import java.io.*; public class BalikFile { /** * @param args */ public static void main(String[] args) { // Aliran input karakter untuk membaca data

BufferedReader data; PrintWriter hasil;

// Aliran output karakter untuk menulis data

// Array untuk menampung semua angka dari dalam file double[] angka = new double[1000]; int banyakAngka; try {

// Banyaknya angka yg disimpan dlm array

// Buat aliran input

data = new BufferedReader(new FileReader("data.dat")); } catch (FileNotFoundException e) { System.out.println("Tidak bisa menemukan data.dat!"); return;

// akhiri program

} try {

// Membuat aliran output

hasil = new PrintWriter(new FileWriter("hasil.dat")); } catch (IOException e) { System.out.println("Tidak bisa membuka hasil.dat!"); System.out.println(e.toString()); try { data.close();

// Tutup file input

} catch (IOException f) {

System.out.println("Tidak bisa menutup data.dat"); } return;

// End the program.

} String baris = null; // variabel untuk menyimpan satu baris teks try { // Baca data dari file input banyakAngka = 0; while ((baris = data.readLine()) != null) {

// baca hingga

habis angka[banyakAngka] = Double.parseDouble(baris); banyakAngka++; } // Tulis hasilnya dalam urutan terbalik for (int i = banyakAngka-1; i >= 0; i--) hasil.println(angka[i]); System.out.println("Selesai!"); } catch (IOException e) { // Ada masalah dengan pembacaan/penulisan file System.out.println("Kesalahan baca/tulis"); } catch (NumberFormatException e) { // Ada masalah dengan format angka dalam file System.out.println("Kesalahan format: " + e.getMessage()); } catch (IndexOutOfBoundsException e) { // Tidak boleh meletakkan 1000 angka dalam file System.out.println("Terlalu banyak angka."); System.out.println("Penulisan dihentikan."); } finally { // Akhiri dengan menutup semua file apapun yang terjadi try { data.close(); }

// Tutup file input

catch (IOException e) { System.out.println("Tidak bisa menutup data.dat"); } hasil.close();

// Tutup file output

} } }

Berikut ini adalah program lengkapnya yang bisa diimport ke dalam Eclipse beserta contoh file data.dat. Setelah selesai dijalankan file baru akan dibuat hasil.dat yang bisa Anda double-click untuk melihat hasilnya

Nama File, Direktori, dan Kelas File Topik tentang nama file sebenarnya lebih kompleks daripada yang telah kita bahas. Untuk menunjuk pada sebuah file, kita harus memberikan bukan hanya nama file, tapi juga nama direktori di mana file tersebut disimpan. Nama file sederhana seperti "data.dat" atau "hasil.dat" diambil dengan mengacu pada direktori sekarang (current directory, atau juga disebut direktori kerja). Pada program di bagian sebelumnya, hasil.dat disimpan pada direktori yang sama dengan direktori utama pada proyek balikfile. File yang tidak diletakkan pada direktori kerja harus diberikan nama "path", atau nama lengkap termasuk nama direktorinya. Untuk memperjelas lagi, ada dua jenis nama path, yaitu nama path absolut dan nama path relatif. Nama path absolut memiliki informasi lengkap dari akar direktorinya, misalnya "C:\workspace\balikfile\data.dat". Sedangkan nama path relatif adalah nama file yang dihitung mulai dari direktori aktifnya. Sayangnya, sintaks untuk nama path dan file bervariasi dari satu sistem ke sistem lain. Misalnya " 

data.dat -- pada komputer apapun, yaitu file data.dat pada direktori aktif.



/home/lyracc/java/contoh/data.dat -- Nama path absolut pada sistem operasi LINUX atau UNIX. Mengacu pada file bernama data.dat di direktori yang ditunjuk.



C:\lyracc\java\contoh\data.dat -- Nama path absolut pada DOS atau Windows



Hard Drive:java:contoh:data.dat -- Misalnya "Hard Drive" adalah nama dari drivenya, maka ini adalah nama path absolut pada Macintosh OS 9



contoh/data.dat -- nama path relatif pada LINUX atau UNIX. "contoh" adalah nama direktori yang terdapat pada direktori aktif, dan data.dat adalah file dalam direktori tersebut. Pada Windows, nama path relatifnya menjadi contoh\data.dat dan pada Macintosh menjadi contoh:data.dat.

Untuk mencegah berbagai masalah yang mungkin muncul karena beragam sistem ini, Java memiliki kelas bernama java.io.File. Objek bertipe kelas ini melambangkan suatu file. Lebih tepatnya, objek bertipe File melambangkan nama file, bukan file itu sendiri. Nama yang ditunjuk belum tentu ada. Direktori juga dianggap Java sebagai File, sehingga File juga melambangkan nama direktori sekaligus nama file. Objek File memiliki konstruktor new File(String) yang akan membuat objek File dari namanya. Nama tersebut bisa nama sederhana, nama path relatif, atau nama path absolut. Misalnya new File("data.dat") membuat objek File dari file bernama data.dat di direktori aktif. Konstruktor lain memiliki konstruktor new File(File,String), di mana parameter pertama adalah direktori di mana file tersebut berada, dan parameter kedua adalah nama filenya. Objek File memiliki beberapa metode instansi. Misalnya file adalah variabel bertipe File, 

berikut ini adalah beberapa metodenya : file.exists()

-- mengembalikan nilai boolean, yang jika true maka file tersebut

ada. Kita bisa menggunakan perintah ini misalnya untuk mencegah menulis file yang sama ketika kita membuka objek FileWriter baru. 

file.isDirectory()

-- mengembalikan nilai boolean yang mengembalikan true

jika objek File adalah suatu direktori, dan false jika File adalah file biasa, atau tidak ada file dengan nama tersebut. 

file.delete()



file.list()

-- menghapus file jika ada

-- jika objek File adalah suatu direktori, maka fungsi ini

mengembalikan array bertipe String[] yang berisi nama-nama file pada direktori tersebut. Jika tidak, maka kembaliannya adalah null.

Berikut ini adalah contoh program yang menulis isi file di dalam direktori yang diinput dari user : package daftardirektori; import java.io.*; public class DaftarDirektori { /* Program ini mengembalikan isi suatu direktori * User memasukkan direktori yang ingin dilihat * Jika direktori tidak ada, maka pesan kesalahan * akan ditulis dan program akan berhenti */ public static void main(String[] args) { String namaDirektori = null;

// Nama direktori dari user

File direktori;

// objek File yang mengacu pada direktori

String[] isiFile;

// Array berisi file pada direktori

// buat objek baru untuk mengambil input BufferedReader

br

=

new

BufferedReader(new

InputStreamReader(System.in)); System.out.print("Masukkan nama direktori : "); try { namaDirektori = br.readLine(); } catch(IOException ioe) { System.out.println("Kesalahan IO terjadi"); System.exit(1); } direktori = new File(namaDirektori); if (direktori.isDirectory() == false) { if (direktori.exists() == false) System.out.println("Tidak ada direktori ini!"); else System.out.println("Ini bukan direktori."); } else {

isiFile = direktori.list(); System.out.println("Files dalam direktori \"" + direktori + "\":"); for (int i = 0; i < isiFile.length; i++) System.out.println("

" + isiFile[i]);

} } }

Berikut ini adalah program lengkapnya yang bisa diimport ke dalam Eclipse. Ini adalah hasil keluarannya :

Semua kelas yang digunakan untuk memaca dan menulis data dari dan ke dalam file memiliki konstruktor yang bisa mengambil objek File sebagai parameternya. Misalnya, jika file adalah variabel bertipe File, dan kita ingin mengambil karakter dari file tersebut, maka kita bisa membuat FileReader untuk melakukannya dengan menggunakan new FileReader(file).

Mengkopi File Mengkopi suatu file adalah operasi biasa, dan sistem operasi manapun memiliki perintah atau cara untuk melakukannya. Akan tetapi kita juga bisa membuat program Java untuk melakukannya. Karena program harus bisa mengkopi file jenis apapun, kita tidak bisa menganggap data di dalam file adalah data yang bisa dibaca manusia. File lagu atau video misalnya berisi deretan byte yang merupakan representasi digital dari lagu atau video tersebut.

Oleh karena itu kita harus menggunakan InputStream dan OutputStream untuk melakukan operasi baca tulis yang bisa menangani data biner, bukan Reader dan Writer yang hanya bisa menangani data yang bisa dibaca manusia. Program yang kita buat akan mengkopi beberapa byte sekaligus dari InputStream ke OutputStream,

akan tetapi kita membutuhkan tempat sementara di mana data tersebut

akan ditempatkan sebelum data tersebut ditulis kembali pada OutputStream. Tempat sementara tersebut disebut buffer yang merupakan array berukuran tertentu, misalnya 4096 byte (atau 4 kilo byte). Jika

sumber

adalah

sumber.read(buffer)

variabel

bertipe

InputStream,

maka

byteTerbaca

=

akan mengisi penuh buffer. Metode ini mengembalikan int yang

merupakan berapa byte yang efektif diambil oleh sumber, kemudian diletakkan dalam variabel byteTerbaca. Jika hasilnya -1, berarti tidak ada lagi data yang bisa diambil dari dalam sumber. Begitu

juga

jika

kopi

adalah

keluaran

kopi.write(buffer, 0, byteTerbaca)

yang

bertipe

OutputStream

maka

menulis deretan byte dari buffer dari posisi 0

hingga byteTerbaca ke aliran keluaran kopi. Sehingga secara umum perintah-perintah di atas dapat dirangkum menjadi : byte[] buffer = new byte[4096]; int byteTerbaca; while((byteTerbaca = sumber.read(buffer)) != -1) kopi.write(buffer, 0, byteTerbaca);

Perintah kopi-file pada sistem operasi baik DOS/Windows atau LINUX/UNIX menggunakan perintah pada konsol yang menambahkan file sumber dan file tujuannya. Misalnya, pada konsol Windows, kita bisa menggunakan "copy awal.dat akhir.dat" untuk mengkopi file awal.dat ke file bernama akhir.dat. Tambahan parameter pada konsol ini disebut argumen baris perintah. Argumen baris perintah ini bisa juga digunakan dalam program Java. Dalam Java argumen baris perintah ini diisi dalam array String[] bernama args, yang kemudian dimasukkan sebagai parameter dalam subrutin main(). Ingat bagaimana "biasanya" subrutin main() dideklarasikan sebagai public static void main(String[] args). Pada program Java yang sudah dikompilasi, kita bisa memanggilnya dengan "java KopiFile awal.dat akhir.dat"

jika KopiFile adalah nama kelas yang akan kita buat

untuk mengkopi file. args[0] akan berisi awal.dat sedangkan args[1] akan berisi akhir.dat.

Program yang akan kita buat menerima input dari baris perintah. Kemudian program akan mengecek apakah kedua parameter tersebut berisi nama file dengan benar. Jika salah satu parameternya kosong, maka program akan menampilkan pesan kesalahan. Program juga akan mengecek apakah akhir.dat merupakan file yang sudah ada sebelumnya, kemudian memberi pertanyaan kepada user apakah isi file ini ingin ditindih dengan isi file awal.dat. Jika ya, maka operasi akan diteruskan, jika tidak maka program akan dihentikan. Berikut ini adalah listing lengkap program KopiFile, yang bisa diunduh di sini dan diimport ke dalam Eclipse. import java.io.*; public class KopiFile { /** * @param args */ public static void main(String[] args) { // Mengecek apakah argumen program cukup untuk meneruskan program // Dibutuhkan dua argumen, yaitu sumberFile dan tujuanFile if (args.length < 2) { System.out.println("Cara menjalankan program : " + "java KopiFile sumberFile tujuanFile"); return; } String sumberNamaFile = args[0]; String tujuanNamaFile = args[1]; File sumberFile = new File(sumberNamaFile); File kopiFile = new File(tujuanNamaFile); // Jika kopi file sudah ada, kita akan tanyakan

apakah file

tujuan // akan ditimpa if (kopiFile.exists()) { // buat objek baru untuk mengambil input BufferedReader InputStreamReader(System.in));

br

=

new

BufferedReader(new

String timpaFile = null; System.out.print("Apakah

Anda

ingin

menimpa

"

+

tujuanNamaFile + " ? (y/t) "); try { timpaFile = br.readLine(); } catch(IOException ioe) { System.out.println("Kesalahan IO terjadi"); System.exit(1); } // jika jawabannya tidak, hentikan program if (timpaFile.equalsIgnoreCase("t")) return; } // Di sini kita siap untuk mengkopi file // Buat aliran input dan output FileInputStream sumber = null; try { sumber = new FileInputStream(sumberFile); } catch (FileNotFoundException e) { System.out.println("File sumber tidak ada, berupa direktori " + "atau tidak bisa dibuka, program dihentikan!"); return; } FileOutputStream kopi = null; try { kopi = new FileOutputStream(tujuanNamaFile); } catch (FileNotFoundException e) { System.out.println("File tujuan tidak valid atau tidak bisa ditulis, " + "program dihentikan!"); return; } byte[] buffer = new byte[4096]; int byteTerbaca;

try { while((byteTerbaca = sumber.read(buffer)) != -1) kopi.write(buffer, 0, byteTerbaca); } catch (IOException e) { System.out.println("Ada

masalah

di

tengah

pengkopian

program"); return; } System.out.println("Kopi file selesai dijalankan!"); } }

Perlu diingat bahwa program ini tidak bisa dijalankan lewat Eclipse. Jika Anda mencoba menjalankan lewat Eclipse, maka tampilan kesalahan akan muncul, karena tidak ada parameter yang diberikan.

Untuk menjalankan program, Anda harus membuka konsol pada Windows dengan Start -> Run -> kemudian ketik cmd dan enter. Setelah itu pergi ke direktori tempat proyek Anda berada pada Eclipse. Misalnya pada komputer saya, saya meletakkan semua proyek Eclipse pada c:\belajarjava.lyracc.com\KopiFile. Di dalamnya seharusnya Anda akan menemui 2 direktori, yaitu src dan bin. src adalah tempat di mana kode sumber berada, sedangkan bin adalah tempat dimana hasil kompilasi berada. Eclipse akan melakukan kompilasi secara otomatis. Berikut screenshot hasil jalannya program. Di sini saya mengkopi file dari c:\belajarjava.lyracc.com\KopiFile\src\KopiFile.java c:\belajarjava.lyracc.com\Kopi123.java.

ke

Jaringan (network) Dalam pemrograman, jaringan (network) hanyalah salah satu jenis dari input di mana data bisa diambil, dan output di mana data bisa dikirim. Konsep ini mempermudah pemahaman kita tentang pemrograman dalam jaringan, akan tetapi ada beberapa hal lain yang harus diperhatikan sehingga pemrograman pada jaringan dapat berhasil dengan baik. Pada Java, kita bisa menggunakan aliran input dan output untuk melakukan komunikasi pada network, seperti halnya pada file. Akan tetapi membuat koneksi jaringan antara dua komputer sedikit lebih rumit, karena ada dua komputer yang berbeda, yang keduanya harus setuju membuka koneksi. Dan ketika data dikirimkan dari satu komputer ke komputer lain, komunikasi harus dilakukan seirama sehingga data yang dikirimkan akan sampai ke komputer yang lain. Salah satu paket Java standar adalah java.net. Paket ini memiliki beberapa kelas yang bisa digunakan untuk berkomunikasi melalui jaringan. Dua jenis I/O network disediakan dalam paket ini. Yang pertama, yang lebih tinggi tingkatannya, berdasarkan pada Web dan memberikan fasilitas komunikasi seperti halnya web browser ketika mendownload suatu halaman web untuk kemudian ditampilkan. Kelas utama dalam jenis network seperti ini adalah java.net.URL dan java.net.URLConnection. Suatu objek bertipe URL adalah lambang abstrak dari sebuah URL (Universal Resource Locator), yaitu alamat web di mana dokumen HTML atau lainnya bisa ditemukan pada web. Sedangkan URLConnection adalah koneksi network ke dokumen tadi.

Jenis I/O kedua adalah melihat jaringan pada tingkatan yang lebih rendah, yaitu berdasarkan ide suatu soket (socket). Soket digunakan oleh program untuk melakukan koneksi dengan program lain pada suatu jaringan. Komunikasi melalui network melibatkan dua

soket,

yaitu masing-masing

pada

setiap komputer. Java memiliki

kelas

untuk merepresentasikan suatu soket yang digunakan dalam

java.net.Socket

komunikasi network. Istilah "soket" mungkin mirip dengan colokan kabel data (misalnya) modem, akan tetapi penting untuk diingat bahwa soket adalah objek bertipe Socket. Artinya program bisa memiliki beberapa soket dalam waktu yang sama, yang masing-masing terhubung ke program yang dijalankan pada komputer lain. Semuanya menggunakan koneksi network yang sama dari satu kabel. Bagian ini akan memberikan pengenalan tentang kelas-kelas dasar jaringan, dan bagaimana hubungannya dengan aliran input dan ouput serta pengecualian. URL dan URLConnection Kelas URL digunakan untuk merepresentasikan suatu sumber pada Web. Setiap sumber memiliki alamat, yang unik (tidak bisa sama), dan memiliki informasi yang cukup sehingga web browser bisa mencari sumber tersebut dan mengambilnya. Alamat ini disebut "url" atau "universal resource locator". Suatu objek beritpe kelas URL melambangkan alamat tersebut. Jika kita sudah memiliki objek bertipe URL, maka kita bisa membuka URLConnection ke alamat tersebut. Suatu url biasanya berupa string, misalnya "http://java.lyracc.com/belajar/java-untukpemula/bab-i-pendahuluan".

Ada juga yang disebut url relatif. URL relatif adalah lokasi

suatu sumber relatif terhadap url lain, yang biasanya disebut landasan (base) atau konteks (context)

dari

url

relatif

tersebut.

Misalnya

http://java.lyracc.com/belajar/java-untuk-pemula/ pendahuluan"

jika

konteksnya

adalah

maka url relatif dari "bab-i-

akan menunjuk pada http://java.lyracc.com/belajar/java-untuk-

pemula/bab-i-pendahuluan.

Suatu objek bertipe URL bukan string sederhana, akan tetapi dibangun dari kumpulan string yang membentuk suatu url. Objek URL juga bisa dibuat dari objek URL lain, yang merupakan konteksnya, dan string lain yang berisi relatif urlnya. Konstruktornya memiliki bentuk seperti : public URL(String alamatURL) throws MalformedURLException

dan

public

URL(URL

konteks,

String

alamatRelatif)

throws

MalformedURLException

Lihat

bahwa

kedua

konstruktor

akan

melempar

pengecualian

bertipe

MalformedURLException

jika string yang diberikan bukan nama url legal. Kelas

MalformedURLException

merupakan kelas turunan dari IOException yang wajib

ditangani, sehingga konstruktor di atas harus dipanggil dalam pernyataan try ... catch atau ditulis di dalam subrutin yang melempar pengecualian ini. Konstruktur jenis kedua akan lebih nyaman digunakan untuk applet. Dalam applet, tersedia dua

metode

yang

getDocumentBase()

bisa

digunakan

untuk

mengambil

konteks

URL.

Metode

pada kelas Applet mengembalikan objek bertipe URL. Objek URL ini

adalah lokasi tempat halaman HTML yang berisi applet tersebut berada. Dengan ini, kita bisa memerintahkan applet untuk kembali dan mengambil file lain yang disimpan di tempat yang sama. Misalnya, URL url = new URL(getDocumentBase(), "data.txt");

membuat URL baru yang merujuk pada file bernama data.txt pada komputer yang sama dan pada direktori yang sama pada halaman web di mana applet tersebut sedang berjalan. Metode lainnya, yaitu getCodeBase(), mengembalikan URL yang merupakan lokasi di mana applet tersebut berada (belum tentu sama dengan lokasi HTML-nya). Setelah kita memiliki objek URL yang benar, kita bisa memanggil openConnection() untuk membuka koneksi pada URL tersebut. Metode ini mengembalikan objek bertipe URLConnection.

Objek URLConnection bisa digunakan untuk membuka InputStream

untuk membaca halaman atau file pada alamat URL tersebut, yaitu dengan menggunakan metode getInputStream(). Misalnya : URL url = new URL(alamatURL); URLConnection koneksi = url.openConnection(); InputStream dataURL = connection.getInputStream();

Metode openConnection() dan getInputStream dapat melempar pengecualian IOException.

Jika InputStream berhasil dibuka, kita bisa menggunakannya dengan cara

biasa, termasuk membungkusnya dalam aliran input jenis lain, misalnya BufferedReader. Membaca dari aliran ini tentunya juga bisa melemparkan pengecualian. Salah satu metode instansi yang berguna dalam kelas URLConnection adalah getContentType(),

yang mengembalikan String yang menjelaskan jenis informasi pada

URL yang ditunjuk. Hasilnya bisa bernilai null jika jenisnya belum diketahui, atau tidak bisa ditentukan. Jenis dokumen bisa saja belum tersedia hingga aliran input berhasil dibuat,

sehingga lebih baik menggunakan getContentType() setelah getInputStream() berhasil dilakukan. String yang dikembalikan oleh getContentType() ditulis dalam format yang disebut MIME, misalnya "text/plain", "text/html", "image/jpeg", "image/gif", dan banyak lagi lainnya. Semua jenis MIME terdiri dari dua bagian, yaitu bagian umum, seperti "text" atau "image", dan bagian khususnya, misalnya "html" atau "gif". Jika kita hanya tertarik pada data teks misalnya, kita hanya perlu menguji apakah hasil keluaran getContentType() dimulai dengan "text". (Jenis MIME pertama kali dimaksudkan untuk menjelaskan isi email. Namanya adalah singkatan dari "Multipurpose Internet Mail Extensions". Kini, MIME digunakan secara umum untuk menjelaskan jenis suatu informasi atau file pada suatu sumber). Mari kita lihat contoh singkat bagaimana membaca data dari suatu URL. Subrutin berikut akan membuka koneksi ke URL tertentu, mengecek apakah jenisnya berupa teks, kemudian mengkopi hasilnya ke layar. Beberapa operasi dalam subrutin ini mungkin melempar pengecualian. Kita akan menambahkan "throws Exception" di kepala subrutin untuk meneruskan penanganan pengecualian ini kepada program utama yang memanggil subrutin ini. static void bacaTeksDariURL( String alamatURL ) throws Exception { // Subrutin ini mencetak isi dari alamat URL yang // diberikan ke layar. Semua kesalahan akan ditangani // oleh program yang memanggil subrutin ini /* Buka koneksi ke URL, dan ambil aliran input * untuk membaca data dari URL. */ URL url = new URL(alamatURL); URLConnection koneksi = url.openConnection(); InputStream dataURL = koneksi.getInputStream(); /* Cek apakah konten bertipe teks */ String jenisKonten = koneksi.getContentType(); if

(jenisKonten

==

null

||

jenisKonten.startsWith("text")

false) throw new Exception("URL tidak bertipe teks."); /* Kopi karakter dari aliran input ke layar

==

* hingga akhir file ditemukan (atau kesalahan ditemui) */ while (true) { int data = dataURL.read(); if (data < 0) break; System.out.print((char)data); } } // akhir bacaTeksDariURL()

Soket, Klien, dan Server Komunikasi melalui internet dilakukan berdasarkan sepasang protokol yang dinamakan Internet Protocol dan Transmission Control Protocol, yang digabungkan menjadi TCP/IP. (Sebenarnya, ada lagi protokol komunikasi yang lebih sederhana yang disebut dengan UDP yang bisa digunakan menggantikan TCP pada beberapa aplikasi. UDP juga didukung Java, akan tetapi kita akan membahas TCP/IP saja yang merupakan komunikasi dua arah yang handal digunakan pada beberapa komputer melalui jaringan). Agar dua program dapat berkomunikasi menggunakan TCP/IP, masing-masing program harus membuat soket, yang kemudian soket-soket tersebut harus terhubung satu sama lain. Setelah terhubung, komunikasi dapat dilakukan dengan menggunakan aliran input dan output seperti biasa. Setiap program harus memiliki aliran input dan outputnya masingmasing. Data yang ditulis oleh suatu program di aliran outputnya akan dikirim ke komputer lain. Di sana, data tersebut akan diisi pada aliran input program tersebut. Ketika program tadi membaca aliran inputnya, maka pada dasarnya program tersebut membaca data yang dikirim oleh program lain. Bagian tersulitnya adalah bagaimana membuat koneksi antar komputer tersebut. Dalam hal ini, dua soket akan digunakan. Pertama-tama, suatu program harus membuat soket yang menunggu secara pasif hingga koneksi lain dari soket lain di komputer lain datang. Soket yang sedang menunggu ini disebut sedang "mendengar" (listening) suatu koneksi. Di sisi lain di komputer lain, program lain membuat soket yang mengirim permintaan sambungan ke soket pendengar tadi. Ketika soket pendengar menerima permintaan sambungan dari soket lain, soket ini akan merespon, sehingga komunikasi akan terjadi. Begitu komunikasi terjadi, maka masing-masing program akan bisa membuat aliran input dan aliran output untuk koneksi ini. Komunikasi akan terus terjadi hingga salah satu program menutup (close) koneksi.

Program yang membuat soket pendengar, juga sering disebut server, dan soketnya disebut soket server. Program yang menghubungi server disebut klien (client), dan soket yang digunakan disebut soket klien. Idenya adalah suatu server di suatu tempat pada network sedang menunggu permintaan sambungan dari suatu klien. Server dianggap sebagai sesuatu yang memberikan layanan, dan klien mendapatkan layanan dengan cara menyambungkannya pada server. Pada komunikasi jaringan, ini disebut model klien/server. Dalam aplikasi dunia nyata, program server dapat memberikan koneksi kepada beberapa klien pada waktu yang sama. Ketika suatu klien terhubung pada soket pendengar, maka soket tersebut tidak berhenti mendengar. Akan tetapi, soket tersebut akan terus mendengar jika ada koneksi klien lain pada saat yang sama. Kelas URL yang telah didiskusikan sebelumnya menggunakan soket klien di belakang layar untuk melakukan komunikasi jaringan yang dibutuhkan. Di sisi lainnya adalah program server yang menerima permintaan sambungan dari objek URL, membaca permintaan objek tersebut, misalnya permintaan file di alamat tertentu, dan meresponnya dengan mengirimkan isi file tersebut melalui network ke objek URL tadi. Setelah mengirimkan data, server akan memutuskan koneksi ini. Untuk mengimplementasikan koneksi TCP/IP, paket java.net menyediakan dua kelas, yaitu ServerSocket dan Socket. Objek bertipe ServerSocket melambangkan soket pendengar yang menunggu permintaan sambungan dari klien. Objek bertipe Socket melambangkan sisi lain dari suatu sambungan, yang bisa berarti soket klien, atau bisa saja soket lain yang dibuat server untuk menangani permintaan dari klien. Dengan cara ini server bisa membuat beberapa soket dan menangani beberapa koneksi sekaligus. (Suatu ServerSocket

sendiri tidak berpartisipasi langsung pada koneksi itu sendiri; ia hanya

bertugas untuk mendengarkan permintaan sambungan, dan membuat Socket untuk melakukan koneksi yang sesungguhnya) Untuk menggunakan Socket dan ServerSocket, kita harus tahu tentang alamat Internet. Program klien harus bisa menentukan komputer mana yang akan berkomunikasi dengannya. Setiap komputer pada internet memiliki alamat IP yang merupakan alamat unik setiap komputer di dalam internet. Komputer juga bisa memiliki nama domain seperti www.yahoo.com atau www.google.com.

Suatu komputer bisa memiliki beberapa program untuk melakukan komunikasi network secara bersamaan, atau satu program mungkin berkomunikasi dengan beberapa komputer sekaligus. Agar bisa bekerja seperti ini, soket sebenarnya merupakan kombinasi antara alamat IP dan nomor port. Nomor port hanya merupakan bilangan bulat 16-bit (dari 0 hingga 216 - 1). Suatu server tidak hanya mendengar koneksi saja, akan tetapi ia mendengar koneksi dari port tertentu. Klien yang ingin berkomunikasi dengan server harus mengetahui alamat Internet komputer beserta nomor port di mana server tersebut mendengarkan permintaan sambungan. Server web, misalnya, pada umumnya mendengarkan koneksi pada port 80; layanan internet lain juga memiliki nomor port standar. (Nomor port standar adalah nomor di bawah 1024. Jika kita membuat program server sendiri, kita sebaiknya menggunakan port benomor lebih besar dari 1024). Ketika kita membuat objek bertipe ServerSocket, kita harus memberikan nomor port yang akan didengar oleh server. Konstruktornya memiliki bentuk seperti public ServerSocket(int port) throws IOException

Setelah ServerSocket berhasil dijalankan, ia akan mulai mendengarkan permintaan sambungan. Metode accept() dalam kelas ServerSocket akan menerima permintaan tersebut, kemudian mempersiapkan sambungan dengan klien, dan mengembalikan objek Socket

yang bisa digunakan untuk berkomunikasi dengan klien. Metode accept()

memiliki bentuk seperti public Socket accept() throws IOException

Ketika kita memanggil metode accept(), ia tidak akan mengembalikan hasilnya sebelum permintaan sambungan diterima (atau suatu kesalahan terjadi). Metode ini disebut "diblokade" ketika menunggu koneksi. (Ketika suatu metode diblokade, maka thread yang memanggil metode tersebut tidak bisa berbuat apa-apa. Akan tetapi thread lain di program yang sama masih bisa berjalan). ServerSocket tersebut akan terus mendengar koneksi hingga ia ditutup menggunakan metode close() atau hingga terjadi kesalahan. Misalnya kita akan membuat server yang akan mendengarkan port 1728, dan misalnya kita telah menulis metode baru beriLayanan(Socket) untuk menangani komunikasi dengan suatu klien. Maka bentuk sederhana dari program server adalah sebagai berikut : try { ServerSocket server = new ServerSocket(1728); while (true) { Socket koneksi = server.accept(); beriLayanan(koneksi);

} } catch (IOException e) { System.out.println("Server dimatikan dengan pesan kesalahan: " + e); }

Di sisi klien, soket klien dibuat dengan menggunakan konstruktor pada kelas Socket. Untuk melakukan koneksi ke server pada suatu alamat dan port tertentu, kita bisa menggunakan konstruktor public Socket(String komputer, int port) throws IOException

Parameter pertama bisa berupa alamat IP atau nama domain. Konstruktor akan memblokadi dirinya hingga koneksi tersambung atau hingga terjadi kesalahan. Setelah koneksi

tersambung,

getOutputStream()

kita

bisa

menggunakan

metode

getInputStream()

dan

pada Socket untuk mengambil aliran input dan output yang bisa

digunakan untuk komunikasi antara dua komputer. Berikut ini adalah kerangka untuk melakukan koneksi klien : void koneksiKlien(String namaKomputer, int port) { // namaKomputer bisa berupa alamat IP atau nama domain // dari komputer yang bertindak sebagai server. // port adalah port dimana server mendengarkan koneksi, // misalnya 1728. Socket koneksi; InputStream in; OutputStream out; try { koneksi = new Socket(namaKomputer,port); in = koneksi.getInputStream(); out = koneksi.getOutputStream(); } catch (IOException e) { System.out.println( "Usah melakukan sambungan gagal, dengan kesalahan : " + e); return; } . . // Gunakan aliran in dan out untuk berkomunikasi dengan server . try {

koneksi.close(); // (Atau, bisa juga bergantung pada server untuk //

memutuskan sambungan)

} catch (IOException e) { } }

// akhir koneksiKlien()

Membuat komukasi melalui jaringan terlihat lebih mudah dari yang sebenarnya. Jika jaringan yang kita gunakan benar-benar handal, mungkin perintah di atas cukup untuk digunakan. Akan tetapi, untuk membuat program tangguh yang bisa menangani segala permasalahan dalam jaringan yang kurang handal atau karena kesalahan manusia misalnya, adalah hal yang tidak mudah. Pengalaman yang bisa membawa kita menjadi programmer jaringan yang lebih baik dan lebih komplet. Yang kita bahas di sini semoga berguna sebagai pengantar untuk membawa Anda lebih jauh mencari tahu tentang pemrograman dengan jaringan. Contoh Pemrograman pada Jaringan Contoh ini melibatkan dua program, yaitu klien sederhana dan servernya. Klien melakukan koneksi dengan server, membaca satu baris teks dari server, kemudian menampilkan teks ini pada layar. Teks yang dikirim oleh server adalah tanggal dan waktu saat ini di komputer di mana server dijalankan. Untuk membuka koneksi, klien harus tahu di komputer mana server dijalankan dan di port mana server tersebut mendengarkan permintaan sambungan. Server akan mendengarkan pada port bernomor 32007. Nomor port ini bisa berapapun di antara 1025 hingga 65535, asalkan klien dan servernya menggunakan port yang sama. Nomor port antara 1 hingga 1024 hanya digunakan oleh layanan standar dan seharusnya tidak digunakan untuk server lainnya. Nama komputer atau alamat IP di mana server dijalankan harus diberikan pada paramater baris perintah. Misalnya jika server dijalankan pada komputer kita sendiri, kita bisa memanggilnya dengan "java KlienTanggal localhost". Berikut ini adalah program klien lengkapnya. import java.net.*; import java.io.*; public class KlienTanggal { static final int PORT_PENDENGAR = 32007;

/** * @param args */ public static void main(String[] args) { String komputer;

// Nama komputer yang akan disambungkan

Socket koneksi;

// Soket untuk berkomunikasi dengan // komputer tersebut

Reader masuk;

// Aliran untuk membaca data dari koneksi

/* Ambil nama komputer dari baris perintah */ if (args.length > 0) komputer = args[0]; else { // Tidak ada nama komputer yang diberikan // Beri pesan kesalahan dan program selesai System.out.println("Cara

menggunakan

:

java

KlienTanggal

<server>"); return; } /* Buat koneksi, kemudian baca dan tampilkan di layar */ try { koneksi = new Socket( komputer, PORT_PENDENGAR ); masuk = new InputStreamReader( koneksi.getInputStream() ); while (true) { int ch = masuk.read(); if (ch == -1 || ch == '\n' || ch == '\r') break; System.out.print( (char)ch ); } System.out.println(); masuk.close(); } catch (IOException e) { System.out.println("Kesalahan : } } }

" + e);

Perhatikan bahwa semua komunikasi dengan server dilakukan dalam pernyataan try ... catch.

Ini akan menangkap pengecualian IOException yang mungkin terjadi ketika

koneksi sedang dibuka atau ditutup atau sedang membaca karakter dari aliran input. Aliran yang digunakan adalah aliran sederhana Reader yang memiliki operasi input masuk.read().

Fungsi ini membaca satu per satu karakter dari aliran, kemudian

mengembalikan nomor kode Unicodenya. Jika akhir aliran telah dicapai, maka nilai -1 akan dikembalikan. Perulangan while membaca karakter ini satu per satu hingga akhir aliran ditemui atau akhir baris ditemui. Akhir baris ditandai dengan salah satu dari '\n' atau '\r' atau keduanya, tergantung dari jenis komputer di mana server tersebut berjalan. Agar program ini dapat berjalan tanpa kesalahan, maka program server harus dijalankan terlebih dahulu. Kita bisa membuat program klien dan server pada komputer yang sama. Misalnya kita bisa membuat dua jendela konsol pada windows, kemudian menjalankan server di konsol yang satu dan menjalankan klien di server yang lain. Agar ini bisa berjalan, komputer lokal kita memiliki alamat 127.0.0.1, sehingga perintah "java KlienTanggal 127.0.0.1" artinya sama dengan memerintahkan program KlienTanggal untuk melakukan sambungan dengan server yang berjalan di komputer yang sama. Atau bisa juga menggunakan alamat "localhost" sebagai pengganti "127.0.0.1". Program servernya kita namakan ServerTanggal. Program ServerTanggal membuat ServerSocket

untuk mendengarkan permintaan sambungan pada port 32007. Setelah

soket pendengar kita buat, maka server akan masuk pada perulangan tak hingga di mana ia menerima dan mengolah permintaan sambungan. Program ini akan berjalan terus menerus tanpa henti kecuali kita hentikan dengan paksa -- misalnya dengan menekan tombol Ctrl-C di jendela konsol di mana server dijalankan. Ketika koneksi diterima dari klien, server akan memanggil subrutin lain untuk menangani koneksi tersebut. Dalam subrutin itu, pengecualian apapun yang terjadi akan ditangkap sehingga server tidak akan mati. Subrutin akan membuat aliran PrintWriter untuk mengirim data melalui koneksi yang terjadi. Server akan menulis tanggal dan waktu sekarang pada aliran output ini, kemudian menutup koneksi. (Kelas standar java.util.Date akan digunakan untuk mengambil tanggal saat ini. Objek bertipe Date melambangkan tanggal dan waktu. Konstruktor standarnya, "new Date()"

membuat objek yang melambangkan tanggal dan waktu ketika objek tersebut

dibuat.) Berikut ini adalah program server lengkapnya : import java.net.*;

import java.io.*; import java.util.Date; public class ServerTanggal { static final int PORT_PENDENGAR = 32007; /** * @param args */ public static void main(String[] args) { ServerSocket pendengar; // Mendengarkan sambungan yang masuk Socket

koneksi;

//

Untuk

berkomunikasi

mengolah

sambungan

dengan

sambungan

yang

masuk /* *

Menerima

dan

selamanya,

atau

hingga

kesalahan * terjadi. (Kesalahan yang terjadi ketika sedang berkomunikasi atau *

mengirimkan

tanggal

akan

ditangkap

untuk

mencegah

server

crash) */ try { pendengar = new ServerSocket(PORT_PENDENGAR); System.out.println("Mendengarkan

pada

port

"

PORT_PENDENGAR); while (true) { koneksi = pendengar.accept(); kirimTanggal(koneksi); } } catch (Exception e) { System.out.println("Maaf, server telah mati."); System.out.println("Kesalahan :

" + e);

return; } } static void kirimTanggal(Socket klien) { // Parameternya, klien, adalah soket yang telah terhubung dengan

+

// program lain. Ambil aliran keluaran untuk melakukan sambungan, // kirim tanggal saat ini dan tutup sambungan. try { System.out.println("Sambungan dari " + klien.getInetAddress().toString()); Date sekarang = new Date(); // Tanggal dan waktu saat ini PrintWriter keluar; // Aliran output untuk mengirim tanggal keluar = new PrintWriter(klien.getOutputStream()); keluar.println(sekarang.toString()); keluar.flush(); // Pastikan data telah terkirim! klien.close(); } catch (Exception e) { System.out.println("Kesalahan : " + e); } } }

Jika kita jalankan ServerTanggal pada konsol, maka ia akan diam menunggu datangnya permintaan sambungan dan melaporkannya apabila permintaan telah masuk. Agar layanan ServerTanggal

tetap tersedia pada suatu komputer, program tersebut seharusnya

dijalankan sebagai daemon. Daemon adalah program yang terus berjalan pada suatu komputer, tidak peduli siapa yang menggunakan komputer itu. Komputer bisa dikonfigurasi untuk menjalankan daemon secara otomatis ketika komputer dinyalakan. Kemudian ia akan berjalan di latar belakang, meskipun komputer digunakan untuk hal lainnya. Misalnya, komputer yang menyediakan layanan Web menjalankan daemon yang mendengarkan permintaan sambungan untuk melihat halaman web dan meresponnya dengan mengirimkan isi halaman tersebut. Bagaimana menjalankan program sebagai daemon tidak akan kita bahas di sini, dan bisa Anda temui pada buku-buku tentang administrasi server dan jaringan. Lihat setelah memanggil keluar.println() untuk mengirim data ke klien, program server memanggil keluar.flush(). Metode flush() tersedia pada semua kelas aliran output. Metode ini digunakan untuk menjamin bahwa data yang telah dikirim pada aliran benar-benar dikirim ke tujuannya. Kita harus memanggil fungsi ini setiap kali kita menggunakan aliran output untuk mengirim data melalui jaringan. Jika tidak, ada kemungkinan program akan mengumpulkan banyak data dan mengirimkan semuanya sekaligus. Mungkin dari segi efisiensi terlihat bagus, akan tetapi tentunya pesan akan

sangat lambat sampai di program klien. Atau bahkan masih ada data yang belum terkirim hingga soket ditutup. Berikut ini adalah screen shot hasil pemanggilan program di atas pada dua konsol, masingmasing untuk server dan kliennya.

Dan program di atas dapat diunduh pada daftar sisipan di bawah, dan diimpor ke dalam Eclipse dengan menggunakan instruksi pada halaman berikut. Untuk menjalankan program di atas, jalankan program server terlebih dahulu, dari dalam konsol ketik "cd \bin" (di screen shot di atas direktorinya berada di c:\belajarjava.lyracc.com\servertanggal\bin) kemudian ketik "java ServerTanggal". Kemudian untuk menjalankan program klien, lakukan dengan cara yang serupa, yaitu buka konsol baru, kemudian ketik "cd \bin" (di screen shot di atas direktornya berada di c:\belajarjava.lyracc.com\klientanggal\bin) kemudian ketik "java KlienTanggal localhost". Untuk mengetahui di direktori mana proyek ini berada pada Eclpse Anda, klik kanan proyek tersebut dari dalam Eclipse -> Properties, seperti pada screen shot berikut ini :

Pemrograman Serentak (Concurrency) Java adalah bahasa pemrograman banyak thread, yang artinya beberapa hal bisa dilakukan bersama-sama. Thread adalah unit terkecil dari eksekusi suatu program. Thread mengeksekusi rangkaian instruksi satu demi satu. Ketika sistem menjalankan program, komputer akan membuat thread baru. (Thread dalam konteks ini disebut proses, akan tetapi perbedaanya tidank penting di sini). Instruksi-instruksi dalam program akan dieksekusi oleh thread ini secara berantai, satu demi satu dari awal hingga akhir. Thread disebut "mati" jika program selesai dieksekusi. Dalam sistem komputer modern, beberapa thread bisa tercipta dalam satu waktu. Pada satu saat tertentu, hanya ada satu thread yang bisa dijalankan, karena CPI hanya bisa melakukan satu hal dalam satu waktu. (Pada komputer dengan multiprosesor, multicore, dan hyperthreading, masing-masing prosesor atau core melakukan thread yang berbeda-beda). Akan tetapi sebenarnya komputer membagi waktu menjadi bagian-bagian kecil sehingga seolaholah seluruh thread dijalankan secara bersama-sama. Pembagian waktu berarti CPU mengeksekusi suatu thread dalam kurun waktu tertentu, setelah itu beralih mengeksekusi thread yang lain, kemudian thread lain, dan seterusnya dan kemudian kembali ke thread

pertama -- kira-kira 100 kali per detik. Di mata user, semua thread berjalan pada saat yang sama. Java adalah bahasa pemrograman banyak thread. Artinya Java bisa membuat satu atau lebih thread yang bisa dijalankan secara paralel. Hal ini adalah bagian mendasar, yang dibuat di dalam core bahasa, bukan merupakan tambahan (add-on) seperti bahasa pemrograman lain. Tetap saja pemrogaman dengan banyak thread adalah sesuatu yang tidak mudah. Penggunaan thread yang banyak digunakan adalah untuk membuat GUI (graphical user interface) yang responsif. Pada dasarnya suatu program harus dapat terus bejalan dan pada saat yang sama tetap bisa menerima input dari user, menanggapi klik mouse, dan sebagainya. Thread juga digunakan untuk mempercepat suatu proses, misalnya kita ingin membuat program yang menunggu suatu input I/O dari network, dan pada saat yang sama mengolahnya sehingga proses pengolahan berjalan serentak. Jika program harus menunggu seluruh input datang baru kemudian melakukan pengolahan, tentunya akan memakan waktu yang lebih lama, terutama apabila aliran network lambat atau pengolahannya memakan waktu lama. Jika kita memiliki CPU multiprocessor atau multicore, maka menggunakan banyak thread akan mempercepat eksekusi program, karena masing-masing thread dijalankan secara terpisah. Misalnya untuk melakukan video encoding dengan jumlah data besar, jika kita menggunakan seluruh core yang tersedia maka prosesnya akan dapat diselesaikan dengan cepat. Dasar-dasar Thread Cara

termudah

untuk

java.lang.Thread,

membuat

thread

adalah

membuat

kelas

turunan

dari

yang memiliki semua metode untuk membuat dan menjalankan

thread. Metode paling penting adalah run(), yang bisa kita beban-lebihkan untuk melakukan tugas yang kita butuhkan. Atau dengan kata lain run() adalah metode yang akan dijalankan bersamaan dengan thread lain. Contoh berikut membuat 5 thread, masing-masing memiliki nomor identifikasi unik yang dibuat dengan menggunakan variabel statik. Metode run() dibebanlebihkan untuk menghitung mundur hingga hitungMundur bernilai nol. Setelah metode run() selesai dijalankan, thread akan mati secara otomatis. (Contoh-contoh pada bagian ini bisa diunduh untuk diimport ke dalam Eclipse. Lihat akhir halaman ini untuk tautannya)

package com.lyracc.threaddasar1; public class ThreadDasar extends Thread { private int hitungMundur = 5; private static int jumlahThread = 0; public ThreadDasar() { super("Thread ke-" + ++jumlahThread); start(); } public void run() { while (true) { System.out.println( getName() + " : " + hitungMundur ); if (--hitungMundur == 0) return; } } /** * @param args */ public static void main(String[] args) { for(int i = 0; i < 5; i++) new ThreadDasar(); } }

Pada contoh program di atas, objek thread diberi nama melalui argumen pada konstruktornya. Nama ini dipanggil ketika metode run() melakukan penghitungan mundur, yaitu dengan menggunakan metode getName(). Metode run() pada thread biasanya memiliki perulangan internal yang akan terus menerus dipanggil hingga tidak lagi digunakan. Kita harus membuat suatu kondisi sehingga bisa keluar dari perulangan tersebut (misalnya pada contoh di atas, perulangan akan selesai jika hitungMundur

bernilai 0). Seringkali, run() dijalankan di dalam perulangan yang tak

pernah berhenti (kita akan lihat nanti bagaimana menghentikan suatu thread dengan aman). Pada metode main(), thread dibuat beberapa kali kemudian dijalankan. Metode start() pada kelas Thread digunakan untuk melakukan tugas tertentu sebelum metode run() dijalankan. Jadi, langkah-langkahnya adalah : konstruktor dipanggil untuk membuat objek,

kemudian memanggil start() untuk melakukan konfigurasi thread, dan kemudian metode run()

dijalankan. Jika kita tidak memanggil start() maka metode run() tidak akan

pernah dijalankan. Keluaran dari program ini akan berbeda setiap kali dijalankan, karena penjadwalan thread tidak dapat ditentukan dengan pasti (non-deterministik). Bahkan, kita bisa melihat perbedaan yang sangat jelas ketika kita menggunakan versi JDK yang berbeda. Misalnya, JDK lama tidak melakukan pembagian waktu lebih cepat, artinya, 1 thread mungkin bisa melakukan tugasnya dengan cepat hingga selesai sebelum thread lain dijalankan. Pada JDK lain kita akan melihat program akan mencetak 5 untuk seluruh thread hingga 1 untuk seluruh thread. Artinya pembagian waktunya lebih baik, karena setiap thread memiliki kesempatan yang sama untuk menjalankan program. Karenanya, untuk membuat suatu program multi-threading, kita tidak boleh terpaku pada keluaran suatu kompiler. Program kita harus dibuat seaman mungkin. Ketika objek Thread dibuat pada metode main(), kita lihat bahwa kita tidak menyimpan referensi ke objek tersebut. Pada objek biasa, tentunya objek ini akan langsung ditangkap oleh pemulung memori karena objek ini tidak direferensikan di manapun. Akan tetapi pada thread, objek hanya bisa diambil oleh pemulung memori jika metode run() selesai dijalankan. Pada contoh di atas, program masih bisa berjalan seperti biasa, dan objek Thread

akan diberikan kepada pemulung memori setelah mencetak angka 1.

Yielding (menghasilkan) Jika kita tahu bahwa kita telah mendapatkan hasil yang kita inginkan pada metode run(), kita bisa memberi tahu penjadwal thread bahwa kita telah selesai dan memberi jalan kepada thread lain untuk mendapatkan kesempatan pada CPU. Akan tetapi ini hanya sebagai petunjuk, yang artinya belum tentu dijalankan oleh penjadwal thread. Misalnya pada contoh di atas, kita bisa mengganti isi metode run() dengan public void run() { while (true) { System.out.println( getName() + " : " + hitungMundur ); if (--hitungMundur == 0) return; yield(); } }

Secara umum, yield mungkin berguna untuk situasi yang agak langka, dan kita tidak bisa menggunakannya secara serius untuk memperbaiki kinerja aplikasi kita.

Tidur (sleeping) Cara lain untuk mengatur perilaku thread kita adalah dengan memanggil sleep untuk menunda eksekusi thread selama waktu tertentu (dalam mili detik). Misalnya pada kode berikut, kita ubah metode run() menjadi seperti : public void run() { while (true) { System.out.println( getName() + " : " + hitungMundur ); if (--hitungMundur == 0) return; try { sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } } }

Ketika kita memanggil sleep(), metode ini harus diletakkan di dalam blok try karena sleep()

bisa melemparkan pengecualian, yaitu jika tidurnya diganggu sebelum waktunya

selesai. Hal ini terhadi misalnya apabila thread lain yang memiliki referensi ke thread ini memanggil interrupt() pada thread ini. Pada contoh di atas, kita lemparkan lagi pengecualian yang terjadi dengan pengecualian lain bertipe RuntimeException, karena kita tidak tahu bagaimana pengecualian ini harus ditangani, dan membiarkan metode yang memanggilnya menangkap pengecualian baru ini. Metode sleep() tidak digunakan untuk mengatur bagaimana thread akan berjalan menurut urutan tertentu. Metode ini hanya menghentikan eksekusi suatu thread sementara. Yang dijamin adalah bahwa thread akan tidur selama paling sedikit 100 mili detik (atau mungkin sedikit lebih lama hingga thread jalan kembali). Urutan thread diatur oleh penjadwal thread yang memiliki mekanisme sendiri tergantung dari keadaan thread lain atau bahkan aplikasi lain di luar Java, oleh karena itu sifatnya disebut non-deterministik. Jika kita harus mengatur thread mana dahulu yang harus dijalankan, cara terbaik mungkin tidak menggunakan thread sama sekali, atau mendesain agar suatu thread memanggil thread lain dengan suatu urutan tertentu. Tentunya cara terakhir lebih rumit dari yang dibayangkan. Prioritas Prioritas suatu thread digunakan untuk memberi tahu penjadwal thread tentang prioritas thread tersebut. Tetap saja urutannya tidak bisa ditentukan karena sifatnya yang non-

deterministik. Jika ada beberapa thread yang sedang diblok dan menunggu giliran untuk dijalankan, penjadwal thread akan cenderung menjalankan thread dengan prioritas tertinggi terlebih dahulu. Akan tetapi, tidak berarti thread dengan prioritas rendah tidak akan pernah dijalankan, hanya lebih jarang dijalankan ketimbang thread dengan prioritas tinggi. Perhatikan contoh berikut : package com.lyracc.prioritasthread; public class PrioritasThread extends Thread { private int hitungMundur = 5; private volatile double d = 0; // No optimization public PrioritasThread(int prioritas) { setPriority(prioritas); start(); } public void run() { while (true) { for(int i = 1; i < 100000; i++) d = d + (Math.PI + Math.E) / (double)i; System.out.println(this.toString() + " : " + hitungMundur); if (--hitungMundur == 0) return; } } /** * @param args */ public static void main(String[] args) { new PrioritasThread(Thread.MAX_PRIORITY); for(int i = 0; i < 5; i++) new PrioritasThread(Thread.MIN_PRIORITY); } }

Pada contoh di atas, kita ubah konstruktornya untuk mengeset prioritas kemudian menjalankan thread. Pada metode main() kita buat 6 thread, yang pertama dengan prioritas maximum, dan yang lain dengan prioritas minimum. Perhatikan keluarannya, bagaimana

thread pertama dijalankan lebih dulu sedangkan thread-thread lain berjalan seperti biasa dalam kondisi acak karena memiliki prioritas yang sama. Di dalam metode run() kita lakukan perhitungan matematika selama 100.000 kali. Tentunya ini perhitungan yang memakan waktu sehingga setiap thread harus menunggu giliran di saat thread lain sedang dijalankan. Tanpa perhitungan ini, thread akan dilaksanakan sangat cepat dan kita tidak bisa melihat efek dari prioritas thread. Prioritas suatu thread bisa kita set kapan saja (tidak harus pada konstruktor) dengan metode setPriority(int prioritas)

dan kita bisa membaca prioritas suatu thread dengan

menggunakan metode getPriority(). Meskipun JDK memiliki 10 tingkat prioritas, akan tetapi sistem operasi memiliki tingkat prioritas yang berbeda-beda. Windows misalnya memiliki 7 tingkat dan Solaris memiliki 231 tingkat prioritas. Yang lebih pasti adalah menggunakan konstanta MAX_PRIORITY, NORM_PRIORITY,

dan MIN_PRIORITY pada kelas thread.

Thread Daemon Thread daemon adalah thread yang bekerja di belakang layar yang memberikan layanan umum kepada thread-thread lain selama program berjalan, akan tetapi thread ini bukan bagian penting dari suatu program. Artinya ketika semua thread yang bukan daemon selesai dijalankan, program akan berhenti, dan jika masih ada thread non-daemon yang masih dieksekusi, program tidak akan berhenti. Perhatikan contoh program berikut ini. package com.lyracc.threaddaemon; public class ThreadDaemon extends Thread { public ThreadDaemon() { setDaemon(true); // Harus dipanggil sebelum start start(); } public void run() { while (true) { try { sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(this); }

} /** * @param args */ public static void main(String[] args) { for (int i = 0; i < 5; i++) new ThreadDaemon(); } }

Perintah setDaemon() sebelum metode start() dipanggil. Pada metode run(), thread diperintahkan untuk tidur selama 100 mili detik. Ketika semua thread dimulai, program langsung berhenti sebelum thread bisa mencetak dirinya. Ini karena semua thread kecuali main()

adalah thread daemon. Hanya thread non-daemon saja yang bisa mencegah

program untuk terus berjalan. Untuk mengetahui suatu thread adalah thread daemon atau bukan, kita bisa menggunakan perintah isDaemon(). Suatu thread daemon akan membuat thread yang juga merupakan thread daemon. Menggabungkan thread Perintah join() bisa digunakan pada thread lain untuk menunda eksekusi hingga thread lain tersebut selesai dijalankan. Misalnya, jika thread a memanggil t.join() pada thread t,

maka eksekusi thread a akan terhenti sementara hingga thread t selesai dijalankan (atau

ketika t.isAlive() bernilai false). Kita bisa juga memanggil join() dengan argumen waktu (baik dalam mili detik, ataupun milidetik dan nanodetik), yaitu jika thread target tidak selesai dalam kurun waktu tersebut, eksekusi pada thread induk akan kembali dilakukan. Panggilan join() bisa dibatalkan dengan memanggil interrupt() pada thread induk, sehingga klausa try ... catch diperlukan pada metode join(). Mari kita lihat contoh berikut ini. package com.lyracc.joindemo; class ThreadPemalas extends Thread { private int waktu; public ThreadPemalas(String namaThread, int waktuTidur) { super(namaThread);

waktu = waktuTidur; start(); } public void run() { try { sleep(waktu); } catch (InterruptedException e) { System.out.println(getName() + " dibangunkan. " + "isInterrupted(): " + isInterrupted()); return; } System.out.println(getName() + " sudah bangun."); } } class ThreadPenggabung extends Thread { private ThreadPemalas sleeper; public ThreadPenggabung(String namaThread, ThreadPemalas pemalas) { super(namaThread); this.sleeper = pemalas; start(); } public void run() { try { sleeper.join(); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(getName()

+

"

sleeper.getName()); } } public class JoinDemo { /** * @param args */ public static void main(String[] args) {

selesai

setelah

"

+

ThreadPemalas brr = new ThreadPemalas("brr", 2000); ThreadPemalas grr = new ThreadPemalas("grr", 2000); ThreadPenggabung saya = new ThreadPenggabung("saya",brr); ThreadPenggabung anda = new ThreadPenggabung("anda",grr); grr.interrupt(); } }

Hasil keluarannya adalah seperti pada gambar berikut.

ThreadPemalas

adalah thread yang akan ditidurkan sepanjang waktu yang diberikan pada

konstruktornya. Metode run() bisa berhenti jika waktu tidur sudah habis atau ada interupsi yang terjadi. Di dalam klausa catch, interupsi akan dilaporkan. Fungsi isInterrupted() melaporkan apakah thread ini diinterupsi atau tidak. Akan tetapi ketika thread ini diinterupsi, kemudian pengecualiannya ditangkap oleh klausa catch, misalnya, maka tanda interupsi akan segera dihapus. Oleh karenanya isInterrupted() akan selalu bernilai false

pada program di atas. Tanda interupsi akan digunakan pada situasi lain yang

mungkin berada di luar pengecualian. ThreadPenggabung

adalah thread yang menunggu hingga ThreadPemalas selesai dengan

tugasnya, yaitu dengan memanggil join() ke objek ThreadPemalas pada metode run()nya. Pada metode utama main(), setiap ThreadPemalas tersambung pada ThreadPenggabung. Dan kita lihat pada keluarannya, jika ThreadPemalas selesai bekerja, baik karena dibangunkan melalui interupsi atau karena waktu sudah selesai, ThreadPenggabung yang tersambung juga akan menyelesaikan tugasnya. Variasi Kode Pada contoh-contoh di atas, semua objek thread yang kita buat diturunkan dari kelas Thread.

Kita hanya membuat objek yang berfungsi sebagai thread dan tidak memiliki

tugas dan fungsi lain. Akan tetapi, kelas kita mungkin saja merupakan kelas turunan dari kelas lain. Karena Java tidak mendukung pewarisan berganda, kita tidak bisa menurunkan kelas tersebut bersamaan dengan kelas Thread.

Dalam hal ini, kita bisa menggunakan cara alternatif yaitu dengan mengimplementasi interface Runnable. Runnable hanya memiliki satu metode untuk diimplementasi, yaitu metode run(). Contoh berikut mendemonstrasikan contoh penggunaannya : package com.lyracc.runnablesederhana; public class RunnableSederhana implements Runnable { private int hitungMundur = 5; public void run() { while (true) { System.out.println(Thread.currentThread().getName() + " : " + hitungMundur); if (--hitungMundur == 0) return; } } public static void main(String[] args) { for (int i = 1; i <= 5; i++) { // Buat thread baru dan jalankan Thread a = new Thread(new RunnableSederhana(), "Thread ke-" + i); a.start(); } } }

Satu-satunya yang dibutuhkan oleh kelas RunnableSederhana adalah metode run(), akan tetapi jika kita ingin melakukan hal lainnya, seperti getName(), sleep(), dan lainnya, kita harus

secara

eksplisit

memberikan

referensi

dengan

menggunakan

Thread.currentThread().

Ketika suatu kelas mengimplementasikan interface Runnable, artinya kelas ini memiliki metode bernama run(), akan tetapi tidak berarti bahwa kelas ini bisa melakukan sesuatu seperti kelas Thread atau kelas-kelas turunan yang kita buat dari kelas ini. Kita harus membuat objek Thread sendiri seperti ditunjukkan dalam metode main() di atas, kemudian menjalankan start() sendiri. Kemudahan yang ditawarkan oleh interface Runnable adalah kemungkinan untuk menggabungkannya dengan kelas dan interface lain. Misalnya kita ingin membuat kelas

baru yang merupakan kelas turunan dari suatu kelas lain. Kita cukup menambahkan impement Runnable

pada definisi kelasnya untuk membuat kelas yang bisa kita jadikan

thread. Dengan cara ini, kita masih bisa mengakses anggota kelas induk secara langsung, tanpa melalui objek lain. Akan tetapi, kelas dalam (inner class) juga bisa mengakses anggota kelas luar (outer class). Kadang-kadang kita ingin juga membuat kelas dalam yang merupakan turunan dari kelas Thread. Perhatikan beberapa variasi untuk mendeklarasikan dan menggunakan thread pada contoh berikut ini. package com.lyracc.variasithread; // Kelas dalam bernama class KelasDalamBernama { private int hitungMundur = 5; private Dalam dalam; // Kelas Dalam adalah kelas dalam (inner class) yang // merupakan kelas turunan kelas Thread private class Dalam extends Thread { Dalam(String nama) { super(nama); start(); } public void run() { while (true) { System.out.println(getName() + " : " + hitungMundur); if (--hitungMundur == 0) return; try { sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } // akhir Dalam // Konstruktor KelasDalamBernama // Membuat objek baru yang merupakan instansi kelas Dalam

public KelasDalamBernama(String nama) { dalam = new Dalam(nama); } } // akhir KelasDalamBernama // Kelas dalam anonim class KelasDalamAnonim { private int hitungMundur = 5; private Thread t; // Konstruktor KelasDalamAnonim public KelasDalamAnonim(String nama) { // Kelas anonim turunan Thread t = new Thread(nama) { public void run() { while (true) { System.out.println(getName() + " : " + hitungMundur); if (--hitungMundur == 0) return; try { sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } } }; // akhir kelas anonim t.start(); } } // akhir KelasDalamAnonim // Kelas dalam implementasi runnable bernama class KelasRunnableBernama { private int hitungMundur = 5; private Dalam dalam; // Kelas Dalam adalah kelas dalam (inner class) yang // merupakan kelas yang mengimplementasi Runnable private class Dalam implements Runnable { Thread t;

Dalam(String nama) { t = new Thread(this, nama); t.start(); } public void run() { while (true) { System.out.println(t.getName() + " : " + hitungMundur); if (--hitungMundur == 0) return; try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } // akhir kelas Dalam // Konstruktor KelasRunnableBernama // Membuat objek baru yang merupakan instansi kelas Dalam public KelasRunnableBernama(String nama) { dalam = new Dalam(nama); } } // akhir KelasRunnableBernama // Kelas dalam implementasi runnable anonim class KelasRunnableAnonim { private int hitungMundur = 5; private Thread t; public KelasRunnableAnonim(String nama) { t = new Thread(new Runnable() { public void run() { while (true) { System.out.println(Thread.currentThread().getName() + " : " + hitungMundur); if (--hitungMundur == 0) return; try { Thread.sleep(10);

} catch (InterruptedException e) { throw new RuntimeException(e); } } } }, nama); // akhir kelas dalam anonim t.start(); } } // akhir KelasRunnableAnonim // Menjalankan thread dari dalam metode dan kelas anonim class ThreadViaMetode { private int hitungMundur = 5; private Thread t; private String nama; public ThreadViaMetode(String nama) { this.nama = nama; } public void runThread() { if (t == null) { // Definisi kelas anonim dari dalam metode t = new Thread(nama) { public void run() { while (true) { System.out.println(getName()

+

hitungMundur); if (--hitungMundur == 0) return; try { sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } } }; // akhir kelas dalam anonim t.start(); }

"

:

"

+

} } // akhir ThreadViaMetode public class VariasiThread { public static void main(String[] args) { new KelasDalamBernama("KelasDalamBernama"); new KelasDalamAnonim("KelasDalamAnonim"); new KelasRunnableBernama("KelasRunnableBernama"); new KelasRunnableAnonim("KelasRunnableAnonim"); new ThreadViaMetode("ThreadViaMetode").runThread(); } }

Jika kita menggunakan Runnable, pada dasarnya kita menyatakan bahwa kita ingin membuat suatu proses -- yang implementasinya berada di dalam metode run() -- bukan suatu objek yang melakukan proses tertentu. Tentunya hal ini tergantung dari cara pandang kita, apakah kita ingin menganggap suatu thread sebagai objek atau sesuatu yang sama sekali berbeda, yaitu proses. Jika kita menganggap suatu thread sebagai proses, tetntunya kita akan terbebas dari cara pandang berorientasi objek yaitu "semuanya adalah objek". Artinya juga, kita tidak perlu membuat seluruh kelas menjadi Runnable jika hanya kita ingin memulai proses di bagian tertentu program kita. Karenanya, mungkin lebih masuk akal untuk menyembunyikan thread di dalam kelas kita menggunakan kelas dalam. KelasDalamBernama[.code] membuat kelas dalam yang merupakan kelas turunan dari

kelas

Thread,

konstruktornya.

Cara

dan ini

membuat baik

jika

instansi kita

kelas

ingin

kelas

ini

di

dalam

dalam

tersebut

memiliki suatu kemampuan tertentu (metode lain) yang ingin kita gunakan. Akan

tetapi,

[code]Thread

seringkali

kita

membuat

thread

hanya

untuk

memanfaatkan

saja, artinya kita mungkin tidak perlu membuat kelas yang memiliki nama.

KelasDalamAnonim

adalah alternatif dari KelasDalamBernama di mana kelas dalamnya

merupakan kelas anonim yang merupakan kelas turunan dari kelas Thread. Kelas anonim ini dibuat di dalam konstruktor dan disimpan dalam bentuk referensi t bertipe Thread. Jika metode kelas lain membutuhkan akses ke t, maka kita bisa menggunakannya seperti Thread

biasa tanpa perlu mengetahui tipe objek t sesungguhnya.

Kelas ketiga dan keempat pada contoh di atas mirip dengan contoh pertama dan kedua, akan tetapi menggunakan interface Runnable. Contoh ini hanya ingin menunjukkan bahwa

menggunakan Runnable tidak menambah nilai apa-apa, kecuali membuat kodenya lebih sulit dibaca. Kelas ThreadViaMetode menunjukkan bagaimana membuat thread dari dalam metode. Kita bisa memanggil metode tersebut jika kita siap untuk menjalankan thread ini. Metode ini akan selesai setelah thread berjalan. Jika thread hanya melakukan tugas sampingan, mungkin cara ini lebih cocok daripada mengimplementasikan kelas khusus untuk melakukan fungsi-fungsi thread Berbagi Sumber Daya Kita bisa bayangkan sebuah program dengan thread tunggal hanya memiliki satu hal yang berpindah dari satu bagian ke bagian lain secara harmonis, karena perpindahan data dari satu tempat ke tempat lain diatur hanya oleh satu alur. Jika ada dua atau lebih thread yang menggunakan, membaca, menulis, menghapus data yang sama, tentunya hal ini menjadi lebih rumit. Kita harus bisa memahami bagaimana thread-thread bekerja sama dalam berbagi sumber daya pada komputer, termasuk memori, hard disk, tampilan, input/output dan lain-lain, sehingga program yang kita buat menjadi lebih baik. Ini bukan hal yang mudah, terutama karena suatu thread bersifat non-deterministik. Kita tidak bisa menentukan atau memprediksi kapan suatu thread akan dijalankan oleh penjadwal. Bisa saja pada saat yang bersamaan dua thread mencoba untuk mengakses data yang sama, menghapus data yang sama, melakukan debit di rekening yang sama, mencetak di printer yang sama, menampilkan gambar di layar yang sama. Tabrakan sumber daya harus bisa dicegah sedini mungkin. Cara Buruk Mengakses Sumber Daya Kita ambil contoh berikut, di mana suatu kelas "menjamin" bahwa ia akan memberikan angka genap setiap kali kita memanggil ambilNilai(). Akan tetapi, ada thread kedua yang dinamakan Hansip yang selalu memanggil ambilNilai() untuk mengecek apakah nilainya selalu genap. Sepertinya ini cara yang tidak perlu, karena setelah kita melihat kode berikut, hasilnya pasti selalu genap. Akan tetapi, kita akan melihat ada beberapa kejutan yang terjadi. Berikut ini adalah program versi pertama. package com.lyracc.selalugenap; public class SelaluGenap { private int i; public void berikut() {

i++; i++; } public int ambilNilai() { return i; } public static void main(String[] args) { final SelaluGenap genap = new SelaluGenap(); new Thread("Hansip") { public void run() { while (true) { int nilai = genap.ambilNilai(); // Jika ganjil, keluar dan cetak nilainya if (nilai % 2 != 0) { System.out.println(nilai); System.exit(0); } } } }.start(); while (true) genap.berikut(); } }

Pada metode main(), objek SelaluGenap akan dibuat -- sifatnya harus final karena objek ini harus bisa diakses oleh kelas anonim yang berupa Thread. Jika nilai yang dibaca oleh thread berupa bilangan ganjil, maka bilangan tersebut akan dicetak di layar kemudian keluar dari program. Apa yang terjadi adalah program pasti akan keluar dengan mencetak nilai ganjil. Ini berarti ada ketidakstabilan dalam program tersebut. Ini adalah contoh masalah mendasar dengan pemrograman banyak thread. Kita tidak pernah tahu kapan suatu thread akan jalan. Thread kedua bisa jalan ketika thread pertama baru selesai menjalankan i++; yang pertama di dalam metode berikut(). Di sini thread kedua menganggap ada kesalahan perhitungan, padahal proses belum selesai.

Kadang-kadang kita memang tidak peduli ketika suatu sumber daya (dalam contoh di atas, variabel i) sedang diakses apakah sedang digunakan atau tidak. Akan tetapi supaya program banyak thread bisa bekerja dengan baik, kita harus mencegah supaya dua thread tidak mengakses sumber daya yang sama, terutama di saat-saat kritis. Mencegah tabrakan seperti ini bisa dicegah dengan meletakkan kunci pada sumber daya ketika sedang digunakan. Thread pertama yang sedang mengubah variabel i seharusnya mengunci variabel ini sehingga thread kedua yang ingin mengambil nilainya harus menunggu hingga proses penambahan selesai. Pemecahan Masalah Tabrakan Sumber Daya Bersama Untuk memecahkan masalah tabrakan pada thread, hampir semua metode serentak melakukan akses serial ke suatu sumber daya yang digunakan bersama. Artinya hanya satu thread yang bisa mengakses suatu sumber daya pada suatu waktu. Biasanya hal ini dilakukan dengan membuat kunci sehingga satu thread saja yang bisa mengakses kunci tersebut. Kunci ini sering disebut mutex atau mutual exclusion. Mari kita ambil contoh di rumah kita hanya ada satu kamar mandi. Beberapa orang (thread) ingin masuk ke kamar mandi (sumber daya bersama), dan mereka ingin masuk sendirian. Untuk masuk ke dalam kamar mandi, seseorang harus mengetok pintu untuk mengetahui apakah ada orang di dalamnya. Jika tidak ada, maka mereka bisa masuk dan mengunci pintunya. Thread lain yang mau menggunakan kamar mandi "diblok" sehingga tidak bisa masuk, sehingga thread harus menunggu hingga seseorang keluar dari kamar mandi. Analogi di atas sedikit berbeda jika ketika seseorang keluar dari kamar mandi dan ada beberapa orang yang ingin mengakses kamar mandi secara bersamaan. Karena tidak ada "antrian" maka kita tidak tahu siapa yang harus masuk berikutnya, artinya penjadwal thread bersifat non-deterministik. Yang terjadi adalah, jika banyak orang menunggu di depan kamar mandi, maka siapa yang paling dekat dengan kamar mandi akan masuk terlebih dahulu. Seperti telah diulas sebelumnya, kita bisa memberi tahu penjadwal thread dengan perintah yield dan setPriority() akan tetapi tetap saja masih sangat bergantung kepada JVM dan implementasi pada suatu platform dan tidak bisa ditentukan dengan pasti siapa yang berhak masuk terlebih dahulu. Java memiliki fitur untuk mencegah terjadinya tabrakan sumber daya, yaitu dengan menggunakan kata kunci synchronized. Ketika suatu thread berusaha untuk mengeksekusi suatu perintah yang diberi kata kunci synchronized, Java akan mengecek apakah sumber daya tersebut tersedia. Jika ya, maka kunci ke sumber daya tersebut akan

diambil, kemudian perintah dijalankan, dan setelah selesai melepaskannya kembali. Akan tetapi synchronized tidak selalu berhasil. Sumber daya bersama bisa berbentuk lokasi memori (dalam bentuk objek), atau bisa juga berupa file, I/O atau bahkan printer. Untuk mengontrol akses ke sumber daya bersama, kita biasanya membungkusnya dalam bentuk objek. Metode lain yang mencoba untuk mengakses sumber daya tersebut bisa diberi kata kunci synchronized. Artinya jika thread sedang mengeksekusi salah satu metode synchronized, thread lain diblok untuk mengeksekusi metode synchronized lain dalam kelas itu hingga thread pertama selesai. Karena biasanya data dari suatu kelas kita buat private dan akses ke memori hanya bisa dilakukan dengan menggunakan metode, maka kita bisa mencegah tabrakan dengan membuat metode menjadi synchronized. Berikut ini adalah contoh pendeklarasian synchronized. synchronized void a() { /* perintah Anda di sini */ } synchronized void b() { /* perintah Anda di sini */ }

Setiap objek memiliki kunci masing-masing yang otomatis dibuat ketka objek tersebut dibuat (kita tidak perlu membuat kode spesial). Ketika kita memanggil metode yang diberi tanda synchronized, objek tersebut dikunci dan tidak boleh ada lagi metode synchronized

yang bisa dieksekusi hingga metode sebelumnya selesai dijalankan dan

kunci dilepas. Karena hanya ada satu kunci untuk setiap objek, maka kita tidak mungkin menyimpan 2 data pada satu tempat pada saat yang bersamaan. Satu thread bisa mengunci objek beberapa kali. Ini terjadi jika satu metode memanggil metode lain di kelas yang sama, kemudian metode tersebut memanggil metode lain lagi di kelas yang sama dan seterusnya. JVM akan melacak berapa kali objek tersebut terkunci. Setiap kali suatu metode selesai, kunci akan dilepas. Ketika objek tidak terkunci lagi, maka kuncinya bernilai 0, yang artinya thread lain bisa mulai menggunakan metode pada objek ini. Ada juga kunci per kelas, yang artinya kunci ini berlaku untuk suatu kelas. Otomatis semua objek yang diciptakan dari kelas yang sama memiliki kunci bersama. Caranya yaitu dengan menggunakan synchronized static metode sehingga suatu objek bisa juga mengunci kelas sehingga objek lain yang menggunakan metode ini tidak bisa jalan apabila sedang digunakan oleh objek lain. Memperbaiki SelaluGenap Kita akan ubah sedikit program SelaluGenap di awal bagian ini untuk memberikan kata kunci synchronized pada metode berikut() dan ambilNilai(). Jika kita hanya

meletakkan kunci pada salah satu metode, maka metode yang tidak diberi kunci akan tetap bebas untuk dieksekusi mengabaikan ada atau tidaknya kunci. Di sini lah kunci pemrograman serentak, di mana kita harus memberi kunci di setiap akses ke sumber daya bersama. Metode ini akan berjalan terus menerus, oleh karena itu kita akan gunakan waktuMulai untuk menyimpan waktu ketika thread mulai berjalan, kemudian secara periodik mengecek waktu saat ini. Jika proses sudah berjalan lebih dari 4 detik, kita hentikan proses kemudian mencetak hasilnya. package com.lyracc.selalugenapsynchronized; public class SelaluGenapSynchronized { private int i; synchronized public void berikut() { i++; i++; } synchronized public int ambilNilai() { return i; } public static void main(String[] args) { final

SelaluGenapSynchronized

genap

=

new

SelaluGenapSynchronized(); new Thread("Hansip") { // mencatat waktu ketika thread dimulai private long waktuMulai = System.currentTimeMillis(); public void run() { while (true) { int nilai = genap.ambilNilai(); // Jika ganjil, keluar dan cetak nilainya if (nilai % 2 != 0) { System.out.println(nilai); System.exit(0); } // Selesaikan program jika sudah melewati 4 detik if (System.currentTimeMillis() - waktuMulai > 4000) {

System.out.println(nilai); System.exit(0); } } } }.start(); while (true) genap.berikut(); } }

Bagian Kritis Kadang-kadang kita hanya ingin mencegah beberapa thread untuk mengakses sebagian kode saja di dalam suatu metode, bukan keseluruhan metode. Bagian kode yang kita ingin lindungi ini disebut bagian kritis (critical section) dan juga bisa dibuat dengan kata kunci synchronized.

Akan tetapi, kata kunci ini digunakan dengan menyatakan objek mana

yang memiliki kunci yang harus dicek sebelum bagian ini dijalankan. Berikut ini adalah bentuk umum dari pernyataan synchronized untuk melindung bagian kritis : synchronized(objekKunci) { // Kode di bagian ini hanya bisa diakses // Jika objekKunci sedang tidak diakses oleh thread lain }

Bentuk umum di atas juga disebut blok tersinkron (synchronized block); sebelum blok ini bisa dieksekusi, kunci pada objek objekKunci harus dicek terlebih dahulu. Jika thread lain telah mengunci ojek ini, maka bagian kritis tidak bisa dimasuki hingga thread lain selesai dan melepas kuncinya. Siklus Hidup Thread Suatu thread bisa berada dalam salah satu kondisi berikut : 1. Baru : Objek thread baru saja dibuat, akan tetapi belum mulai dijalankan, sehingga belum bisa berbuat apa-apa. 2. Bisa-jalan : Artinya objek ini sudah dimulai dan sudah bisa dijalankan oleh mekanisme pembagian waktu oleh CPU. Sehingga thread ini bisa jalan kapan saja, selama diperintahkan oleh penjadwal thread. 3. Mati : suatu thread biasanya mati ketika selesai menjalankan metode run(). Sebelumnya, kita bisa memanggi metode stop(), akan tetapi program bisa berada dalam

kondisi tidak stabil jika metode ini dipanggil. Kita akan lihat beberapa metode lain untuk menghentikan thread di bagian berikutnya. 4. Diblok : Thread seharusnya bisa berjalan, akan tetapi ada yang menghalanginya. Salah satunya adalah jika thread menunggu di bagian kritis sementara ada thread lain yang sedang menjalankan bagian kritis tersebut. Ketika suatu thread berada dalam kondisi diblok, penjadwal thread akan mengabaikannya dan tidak memberikan waktu CPU. Bagaimana Suatu Thread Berada dalam Kondisi Diblok Ketika suatu thread diblok, ada suatu alasan kenapa thread tersebut tidak bisa terus berjalan. Suatu thread dapat diblok karena beberapa alasan sebagai berikut : 

Kita memberi perintah thread untuk tidur dengan sleep(milidetik) sehingga thread tidak akan jalan dalam waktu yang sudah disebutkan



Kita memerintahkan thread untuk menunggu dengan perintah wait(). Thread tidak akan dijalankan kembali hingga diberikan pesan notify() atau notifyAll().



Thread sedang menunggu selesainya operasi I/O



Thread mencoba memanggil metode dengan kata kunci synchronized, akan tetapi thread lain sedang memegang kuncinya.

Kerjasama Antar Thread Setelah kita mengerti bagaimana thread bisa bertabrakan satu sama lain, dan bagaimana caranya mencegah tabrakan antar thread, langkah berikutnya adalah belajar bagaimana membuat thread dapat bekerja sama satu sama lain. Kuncinya adalah komunikias antar thread yang diimplementasi dengan aman dalam metode-metode pada kelas Object, yaitu wait()

dan notify().

wait() dan notify() Pertama-tama penting untuk mengerti bahwa sleep() tidak melepas kunci thread ketika dipanggil. Artinya jika sleep() dipanggil dari dalam bagian kritis, maka thread lain tidak bisa masuk hingga thread yang memanggil sleep() bangun, meneruskan eksekusi, hingga keluar dari bagian kritis. Sedangkan wait() melepas kunci ketika dipanggil, sehingga thread lain bisa masuk ke dalam bagian kritis. Ada dua bentuk wait(). Yang pertama memiliki argumen waktu dalam bentuk mili detik (mirip dengan sleep(). Perbedaannya dengan sleep() adalah : 

wait()



Kita

melepaskan kunci

bisa

membatalkan

notifyAll(),

wait()

dengan

atau hingga waktu tunggu berlalu.

menggunakan

notify()

atau

Bentuk kedua dari wait() adalah wait() yang tidak memiliki argumen. Jenis wait() ini akan terus berlangsung hingga dibatalkan dengan notify atau notifyAll(). Aspek penting dari wait(), notify() dan notifyAll() adalah metode ini merupakan bagian dari kelas dasar Obejct dan bukan bagian dari kelas Thread seperti sleep(). Meskipun kelihatan janggal, hal ini sangat penting karena semua objek memiliki kunci. Artinya kita bisa memanggil wait() dari dalam metode synchronized, tidak peduli apakah kelas tersebut merupakan kelas turunan dari Thread atau bukan. Sebetulnya satu-satunya tempat kita bisa memanggil wait(), notify() dan notifyAll() adalah dari dalam blok atau metode synchronized. (sleep() bisa dipanggil dari manapun karena ia tidak berhubungan dengan kunci suatu objek). Jika kita memanggil wait(), notify()

atau notifyAll() dari luar metode atau blok synchronized, compiler tidak

akan memperingatkan Anda, akan tetapi ketika program dijalankan, kita akan mendapatkan pengecualian IllegalMonitorStateException dengan pesan kesalahan yang tidak dimengerti, seprti "thread ini bukan pemiliknya". Pesan ini berarti bahwa thread yang memanggil wait(), notify() atau notifyAll() harus memiliki kunci objek sebelum bisa memanggil salah satu metode ini. Kita juga bisa meminta suatu objek untuk memanipulasi kuncinya sendiri. Caranya, pertama-tama kita harus mengambil kuncinya. Misalnya, jika kita ingin memanggil notify()

ke suatu objek x, kita harus melakukannya di dalam blok synchronized untuk

mengambil kunci x, seperti : synchronized(x) { x.notify(); }

Biasanya, wait() digunakan jika kita menunggu sesuatu yang dikontrol oleh sesuatu di luar kontrol metode kita (di mana sesuatu ini hanya bisa diubah oleh thread lain). Kita tidak ingin menunggu dan berulang-ulang menguji apakah sesuatu itu sudah tersedia, karena cara ini akan memboroskan penggunaan CPU. Kita bisa menggunakan wait() untuk memerintahkan suatu thread untuk menunggu hingga sesuatu tersebut berubah, dan hanya ketika notify() dipanggil, maka thread tersebut akan bangun dan mengeceknya. Dengan kata lain wait() digunakan melakukan aktifitas tak-sinkron antara beberapa thread. Sebagai contoh, anggap suatu restoran memiliki satu orang koki dan satu orang pelayan. Pelayan harus menunggu hingga si koki selesai memasak makanan. Ketika koki selesai, ia akan memberi tahu pelayan, kemudian membawa makanan ini ke customer, kemudian

menunggu kembali. Koki di sini kita sebut sebagai produsen, dan pelayan disebut sebagai konsumen. package com.lyracc.rumahmakan; class Pesanan { private int i = 0; public Pesanan(int i) { this.i = i; } public String toString() { return "pesanan " + i; } } // akhir kelas Pesanan class Pelayan extends Thread { private RumahMakan rumahMakan; public Pelayan(RumahMakan r) { rumahMakan = r; start(); } public void run() { while (true) { while (rumahMakan.pesanan == null) // tunggu hingga dipanggil dengan notify oleh Koki synchronized (this) { try { wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } System.out.println("Pelayan

mengantarkan

rumahMakan.pesanan); // pesanan sudah diantar, pesanan sekarang kosong rumahMakan.pesanan = null; } }

"

+

} // akhir kelas Pelayan class Koki extends Thread { private RumahMakan rumahMakan; private Pelayan pelayan; public Koki(RumahMakan r, Pelayan p) { rumahMakan = r; pelayan = p; start(); } public void run() { // masak 10 makanan for (int i = 0; i < 10; i++) { if (rumahMakan.pesanan == null) { rumahMakan.pesanan = new Pesanan(i); System.out.print("Pesanan selesai! "); // coba panggil pelayan jika tidak sibuk synchronized (pelayan) { pelayan.notify(); } } try { sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } } System.out.println("Makanan habis.."); System.exit(0); } } // akhir kelas Koki public class RumahMakan { Pesanan pesanan; public static void main(String[] args) { RumahMakan rumahMakan = new RumahMakan(); Pelayan pelayan = new Pelayan(rumahMakan); new Koki(rumahMakan, pelayan);

} }

Keluarannya ada sebagai berikut.
src="/sites/java.lyracc.com/files/kerjasamathread_gbr1.png"

alt=""

/> Pesanan

adalah kelas sederhana yang berisi pesanan. Konstruktor menerima angka yang

diibaratkan seperti pesanan, kemudian membebanlebihkan metode toString() untuk mencetak objek ini langsung dengan System.out.println(). Seorang Pelayan harus tahu RumahMakan tempat ia bekerja, karena ia harus ke sana untuk mengantarkan pesanan dari "jendela pemesanan", yaitu rumahMakan.pesanan. Pada metode run(), Pelayan masuk dalam mode menunggu. Kuncinya dimiliki oleh pelayan ini sendiri. Kunci ini yang akan digunakan oleh Koki untuk membangunkan Pelayan jika makanan sudah siap dengan metode notify(). Pada aplikasi yang lebih kompleks, misalnya jika pelayannya banyak, kita bisa memanggil notifyAll()

untuk membangunkan semua pelayan. Setiap pelayan nanti akan menguji

apakah panggilan itu untuknya atau tidak. Perhatikan bahwa wait() ditulis di dalam pernyataan while untuk menguji apakah pesanan sudah datang. Mungkin ini agak terasa ganjil karena ketika thread ini dibangunkan ketika menunggu pesanan, seharusnya pesanannya sudah tersedia khan? Masalahnya jika aplikasinya terdiri dari banyak pelayan, thread lain mungkin sudah keburu mengantarkan pesanannya ketika thread ini sedang bangun. Untuk itu, lebih aman apabila kita menggunakan bentuk berikut untuk semua aplikasi yang menggunakan wait() : while (sesuatuYangDitunggu) wait();

Dengan melakukan ini, kita menjamin bahwa kondisi di atas akan terpenuhi sebelum thread mendapatkan sesuatu yang ditunggu. Jika thread sudah dibangunkan akan tetapi pesanan tidak ada, maka thread akan kembali tidur. Objek Koki harus tahu di rumah makan mana ia bekerja. Pesanan yang dia masak akan dia letakkan pada jendela pesanan (dalam hal ini rumahMakan.pesanan) dan dia juga harus tahu siapa Pelayan yang akan mengantarkan pesanan yang sudah selesai dimasak. Pada contoh sederhana di atas, Koki membuat objek Pesanan, kemudian setelah selesai akan memanggil Pelayan dengan notify(). Karena panggilan notify() dilakukan di dalam klausa synchronized, maka sudah bisa dipastikan Koki memanggil pelayan jika pelayan tersebut sedang tidak digunakan oleh thread lain.

Kunci Mati (Deadlock) Thread bisa diblok dan objek bisa memanggil metode synchronized ke suatu objek sehingga objek lain tidak bisa mengakses objek tersebut hingga kuncinya dilepas. Karenanya mungkin saja satu thread tersangkut menunggu suatu thread, akan tetapi thread yang ditunggu ini juga sedang menunggu thread lain, dan seterusnya. Jika rangkaian kunci kembali ke thread pertama, maka semua thread akan diam menunggu satu sama lain dan tidak akan pernah jalan. Kasus ini dinamakan kunci mati (deadlock). Jika program yang kita buat tiba-tiba mengalamai deadlock, kita akan segera tahu dan memperbaikinya. Akan tetapi permasalahan utamanya adalah deadlock sulit untuk dideteksi. Sering kali program yang kita buat tampak baik-baik saja, akan tetapi mungkin menyimpan bahaya laten deadlock, yang suatu saat nanti terjadi ketika program sudah dirilis (bahkan sering kali deadlock ini juga tidak bisa direproduksi sehingga menyulitkan debugging). Mencegah deadlock dengan membuat desain program yang lebih hati-hati sangat penting ketika kita membuat program banyak thread. Mari kita lihat contoh klasik dari deadlock yang ditemukan oleh Dijkstra, yaitu "ilmuwan yang sedang makan". Misalnya ada 5 orang ilmuwan (kita bisa mengganti berapa saja). Ilmuwan-ilmuwan ini menghabiskan sebagian waktu untuk berfikir dan sebagian lagi untuk makan. Ketika mereka berfikir, mereka tidak membutuhkan apa-apa, akan tetapi ketika mereka makan, mereka duduk di meja dengan jumlah alat makan yang terbatas. Mereka membutuhkan dua garpu untuk mengambil spaghetti dari mangkok di tengah meja. Kesulitannya adalah karena ilmuwan tidak punya uang, mereka tidak mampu untuk membeli banyak garpu. Hanya ada 5 garpu yang tersedia. Garpu-garpu ini diletakkan di meja tersebar di dekat masing-masing ilmuwan ini. Ketika ilmuwan ingin makan, dia harus mengambil garpu di sebelah kiri dan kanannya. Jika ilmuwan di sebelahnya sedang menggunakan garpu tersebut, maka ia harus menunggu hingga garpunya selesai digunakan. Persoalan ini menjadi menarik karena menjelaskan bahwa program yang sepertinya berjalan dengan benar akan tetapi mudah terkena deadlock. Kita bisa mengganti beberapa konstanta sehingga deadlock bisa lebih cepat terjadi, atau bisa dicegah sama sekali. Parameter-parameter yang bisa diganti adalah konstanta bertipe final static int di awal deklarasi kelas IlmuwanMakan. Jika kita menggunakan banyak ilmuwan dan waktu berfikir yang lama, deadlock akan lebih jarang terjadi. package com.lyracc.ilmuwanmakan; import java.util.*;

class Garpu { private static int hitung = 0; private int nomor = hitung++; public String toString() { return "garpu " + nomor; } } // akhir kelas Garpu class Ilmuwan extends Thread { private static Random acak = new Random(); private static int hitung = 0; private int nomor = hitung++; private Garpu garpuKiri; private Garpu garpuKanan; static int waktuFikirMaks = IlmuwanMakan.WAKTU_FIKIR_MAKS; public Ilmuwan(Garpu kiri, Garpu kanan) { garpuKiri = kiri; garpuKanan = kanan; start(); } // Ilmuwan berfikir, gunakan sleep untuk mensimulasi public void berfikir() { System.out.println(this + " berfikir"); try { sleep(acak.nextInt(waktuFikirMaks)); } catch (InterruptedException e) { throw new RuntimeException(e); } } // Ilmuwan makan public void makan() { // cek apakah garpu kirinya tersedia synchronized (garpuKiri) { System.out.println(this + " punya " + this.garpuKiri + ". Menunggu

" + this.garpuKanan);

// kemudian cek apakah garpu kanannya tersedia synchronized (garpuKanan) { System.out.println(this + " makan"); } } } public String toString() { return "Ilmuwan " + nomor; } // Metode ketika thread dijalankan // masing-masing ilmuwan akan berfikir kemudian makan // begitu seterusnya public void run() { while (true) { berfikir(); makan(); } } } // akhir kelas ilmuwan // Kelas timeout untuk menghentikan proses setelah // waktu yang ditentukan class Timeout extends Timer { public Timeout(int jeda, final String pesan) { super(true); // Daemon thread schedule(new TimerTask() { public void run() { System.out.println(pesan); System.exit(0); } }, jeda); } } // akhir kelas Timeout // Kelas utama public class IlmuwanMakan { final static int JUMLAH_ILMUWAN = 3;

// bisa diganti

final static int WAKTU_FIKIR_MAKS = 10; // mili detik, bisa diganti

final static boolean DEADLOCK = true;

// ubah ini menjadi false

untuk mencegah deadlock final static int WAKTU_TIMEOUT = 10000; // mili detik atau buat 0 jika tidak ingin timeout public static void main(String[] args) { // Buat array ilmuwan sejumlah JUMLAH_ILMUWAN Ilmuwan[] ilmuwan = new Ilmuwan[JUMLAH_ILMUWAN]; // Mula-mula buat 2 garpu Garpu kiri = new Garpu(); Garpu kanan = new Garpu(); // Garpu pertama hanya sebagai penanda // yaitu garpu di kiri ilmuwan pertama Garpu pertama = kiri; int i = 0; // buat masing-masing ilmuwan // yang pertama memiliki garpu kiri dan kanan // ilmuwan kedua duduk di sebelah kanan ilmuwan pertama // sehingga garpu kirinya adalah garpu kanan ilmuwan pertama // buat garpu baru untuk garpu kanannya // demikian seterusnya hingga JUMLAH_ILMUWAN minus 1 while (i < ilmuwan.length - 1) { ilmuwan[i++] = new Ilmuwan(kiri, kanan); kiri = kanan; kanan = new Garpu(); } // Sekarang buat ilmuwan terakhir // Jika kita ingin membuat deadlock (makan menghadap meja) : // - garpu kirinya adalah garpu kanan ilmuwan sebelumnya // - garpu kanannya adalah garpu kiri ilmuwan pertama // // Jika tidak (makan berbalik arah) // - garpu kirinya adalah garpu kiri ilmuwan pertama // - garpu kanannya adalah garpu kanan ilmuwan sebelumnya if (DEADLOCK) ilmuwan[i] = new Ilmuwan(kiri, pertama);

else ilmuwan[i] = new Ilmuwan(pertama, kiri); // Keluar dari program setelah jeda waktu selesai if (WAKTU_TIMEOUT > 0) new Timeout(WAKTU_TIMEOUT, "Waktu habis.."); } }

Kelas Garpu dan Ilmuwan menggunakan penghitung otomatis untuk memberi nomor identifikasi tersendiri untuk setiap objek Garpu dan Ilmuwan yang diciptakan. Setiap Ilmuwan

diberi referensi ke garpu kiri dan garpu kanan. Garpu-garpu ini akan diambil oleh

ilmuwan ketika hendak makan. Variabel statik waktuFikirMaks adalah waktu maksimum yang digunakan oleh ilmuwan untuk berfikir. Jika nilainya tidak nol, maka nilai variabel ini akan digunakan sebagai argumen perintah sleep() dalam kelas Ilmuwan. Mungkin kita beranggapan dengan mengubah waktu berfikir setiap ilmuwan, mereka tidak akan makan secara bersamaan sehingga kemungkinan terjadinya deadlock menjadi lebih kecil. Padahal sebenarnya tidak demikian. Di dalam metode makan(), seorang ilmuwan akan mengambil garpu dengan melakukan sinkronisasi pada garpu tersebut. Jika garpu sedang digunakan oleh ilmuwan lain, maka ilmuwan tersebut akan menunggu hingga garpu selesai digunakan. Mula-mula garpu kiri dahulu yang dicoba untuk diambil, baru kemudian garpu kanan. Setelah digunakan, garpu kanan akan dilepas terlebih dahulu baru kemudian garpu kiri. Dalam metode run() serorang ilmuwan makan dan berfikir terus menerus. Ada empat konstanta yang bisa kita ubah-ubah di dalam kelas IlmuwanMakan. JUMLAH_ILMUWAN

dan WAKTU_FIKIR_MAKS adalah banyaknya ilmuwan yang ada dan waktu

fikir ilmuwan seperti dijelaskan sebelumnya. Variabel ketiga DEADLOCK berupa boolean yang bisa berisi true atau false. Jika bernilai true maka program cepat atua lambat pasti akan mengalami deadlock. Untuk menghindari deadlock, kita bisa menggantinya dengan false.

Variabel keempat, yaitu WAKTU_TIMEOUT digunakan untuk menghentikan semua

proses pada waktu tertentu. Pada proses yang sulit atau tidak mungkin deadlock (jika variabel DEADLOCK false, atau jumlah ilmuwan banyak, atau waktu fikir ilmuwan sangat panjang), maka proses akan berhenti pada waktu time out, seringkali sebelum deadlock terjadi.

Setelah array objek Ilmuwan dibuat, dua objek Garpu akan dibuat. Objek pertama, juga disimpan dalam variabel pertama akan digunakan kemudian. Setiap objek ilmuwan akan diberi garpu kiri dan kanannya, kecuali objek ilmuwan terakhir. Setiap kali, garpu kiri dipindah ke garpu kanan. Bayangkan meja ilmuwan dibuat dalam urutan melingkar berlawanan arah jarum jam. Garpu kiri ilmuwan baru adalah garpu kanan ilmuwan sebelumnya. Sedangkan garpu kanan ilmuwan baru adalah objek garpu baru. Pada versi di mana DEADLOCK bernilai true, garpu kiri ilmuwan terakhir adalah garpu kanan ilmuwan sebelumnya, akan tetapi garpu kanannya adalah garpu pertama, karena semua ilmuwan duduk pada posisi melingkar. Dengan pengaturan seperti ini, mungkin saja pada suatu waktu semua ilmuwan akan makan dan saling menunggu garpu di sebelahnya, dan ilmuwan sebelahnya menunggu garpu sebelahnya lagi. Dan karena posisi duduknya melingkar, semua saling menunggu satu sama lain. Coba ganti variabelnya dengan beberapa nilai dan amati seberapa cepat deadlock terjadi. Deadlock ditandai dengan semua ilmuwan saling menunggu satu sama lain hingga waktu time out berakhir. (Seperti pada gambar berikut).

Untuk memecahkan masalah ini, kita harus mengerti bahwa deadlock bisa terjadi jika keempat kondisi berikut ini terjadi pada saat yang sama : 1. Saling melarang (mutual exclusion): Paling sedikit salah satu sumber daya yang digunakan objek tidak boleh digunakan bersama. Dalam hal ini, satu garpu bisa digunakan oleh dua orang ilmuwan 2. Paling sedikit salah satu proses sedang memegang suatu sumber daya, dan di saat yang sama menunggu sumber daya lain yang dipegang oleh proses lain. Dalam hal ini, agar deadlock terjadi, seorang ilmuwan pasti sedang memegang satu garpu dan menunggu garpu lain yang dipegang oleh ilmuwan lain. 3. Suatu sumber daya tidak bisa diambil secara paksa. Proses hanya bisa melepas sumber daya dalam kondisi normal. Ilmuwan-ilmuwan kita adalah orang yang

beradab, sehingga tidak bisa merebut garpu yang sedang dipegang oleh ilmuwan lain. 4. Lingkaran menunggu sedang terjadi, di mana proses pertama sedang menunggu satu sumber daya yang dipegang oleh proses kedua, yang juga sedang menunggu sumber daya yang dipegang oleh proses ketiga, dan seterusnya hingga proses terakhir menunggu sumber daya yang dipegang oleh proses pertama, sehingga semua proses saling menunggu satu sama lain. Pada contoh ini, lingkaran menunggu terjadi karena semua ilmuwan mengambil garpu kiri terlebih dahulu baru kemudian garpu kanan. Kita bisa memecahkan deadlock dengan membalik garpu kiri dan garpu kanan pada ilmuwan terakhir, sehingga ilmuwan terakhir akan mengambil garpu kanan terlebih dahulu, baru kemudian garpu kiri. Karena semua kondisi di atas harus terjadi secara bersama-sama agar deadlock bisa terjadi, maka untuk mencegah terjadinya deadlock, kita harus memecah salah satu kondisi saja. Pada program ini, cara termudah adalah dengan memecah kondisi keempat. Akan tetapi ini bukan satu-satunya pemecahan, kita bisa memecahkannya dengan teknik yang lebih canggih. Untuk ini saya mereferensikan Anda pada buku-buku teknik threading tingkat lanjut untuk lebih detailnya. Kesimpulannya, Java tidak menyediakan bantuan secara alami untuk mencegah deadlock: Anda harus menghindarinya sendiri dengan membuat program multi threading dengan lebih hati-hati. Menghentikan Thread Salah satu perubahan pada Java 2 untuk mengurangi kemungkinan terjadinya deadlock adalah dengan dideprekasi (artinya pengembangannya dihentikan, dan user disarankan untuk menghindari penggunaannya) metode stop(), suspend(), dan resume() pada kelas Thread.

Alasan mengapa metode stop() dideprekasi adalah karena metode ini tidak melepas kunci yang sudah dimilikinya, dan jika objek tersebut berada dalam kondisi "cacat" seperti ini, thread lain bisa melihat dan mengubah objek cacat ini. Hasilnya akan muncul masalah yang tersembunyi yang akan sangat sulit dideteksi. Java menyediakan cara lain untuk menghentikan thread, yaitu dengan mengeset suatu variabel untuk memberi tahu thread tersebut agar menghentikan dirinya sendiri yaitu dengan keluar dari metode run()-nya. Variabel ini akan dicek pada metode run() yang jika bernilai true, maka metode run() akan berhenti. Berikut ini adalah contohnya : package com.lyracc.hentikanthread;

import java.util.*; class Berhenti extends Thread { // Harus bertipe volatile: private volatile boolean stop = false; private int hitung = 0; public void run() { // Jika stop masih bernilai false teruskan cetak angka // Jika stop bernilai true, blok ini tidak lagi dijalankan while (!stop && hitung < 10000) { System.out.println(hitung++); } // Jika stop berubah menjadi true if (stop) System.out.println("Permintaan stop dideteksi"); } public void requestStop() { stop = true; } } public class HentikanThread { /** * @param args */ public static void main(String[] args) { final Berhenti threadBaru = new Berhenti(); threadBaru.start(); new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Permintaan berhenti"); threadBaru.requestStop(); } }, 500); // run() setelah 500 mili detik } }

Variabel stop harus bertipe volatile sehingga metode run() pasti bisa melihat variabel ini (jika tidak, maka nilainya bisa saja di-cache). Tugas thread ini adalah mencetak 10000 angka, yang akan berhenti ketika hitung >= 10000 atau objek lain meminta berhenti dengan

memanggil

synchronized [code]true

requestStop().

Perhatikan

bahwa

requestStop()

tidak

karena stop bertipe boolean dan volatile (mengubah boolean menjadi

adalah operasi atomis yang tidak bisa dihentikan di tengah jalan, karena

dilakukan dalam 1 clock). Pada main(), objek Berhenti dimulai. Pada saat yang sama, Timer dimulai untuk memanggil requestStop() setelah setengah detik (500 mili detik). Konstruktor Timer diisi true untuk memastikan bahwa program berhenti saat itu juga. Menginterupsi Thread yang Diblok Kadang-kadang, ketika thread dalam keadaan diblok (misalnya ketika sedang menunggu input), thread tersebut tidak bisa membaca variabel seperti kita lakukan di atas. Di sini, kita bisa menggunakan metode interrupt() pada kelas Thread untuk mengeluarkannya dari kondisi diblok. Misalnya, package com.lyracc.interupsi; import java.util.*; class ThreadDiblok extends Thread { public ThreadDiblok() { System.out.println("Memulai blokade"); start(); } public void run() { try { synchronized (this) { wait(); // Memblok selamanya } } catch (InterruptedException e) { System.out.println("Diinterupsi"); } System.out.println("Keluar dari run()"); } } public class Interupsi {

static ThreadDiblok threadDiBlok = new ThreadDiblok(); /** * @param args */ public static void main(String[] args) { new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Bersiap-siap untuk interupsi"); threadDiBlok.interrupt(); threadDiBlok

=

null;

// buat

null

untuk

diambil

oleh

pemulung memori } }, 2000); // run() setelah 2 detik } }

Panggilan wait() di dalam ThreadDiBlok.run() akan memblok thread selamanya. Ketika Timer selesai, objek akan melakukan interupsi dengan memanggil interrupt(). Kemudian objek threadDiBlok diset ke null sehingga bisa diambil oleh pemulung memori untuk dibersihkan.

Memulai SWT Untuk memulai pemrograman dengan SWT, mari kita buat program sederhana yang kita namakan HelloSWT. 

Anda membutuhkan "link" ke pustaka SWT. Ada dua cara untuk melakukannya :

1. Menggunakan pustaka SWT bawaan dari Eclipse. Untuk ini Anda tidak perlu mendownload apa-apa. Pustaka SWT bawaan eclipse terdapat pada direktori Eclipse

Anda,

misalnya

pada

Windows

(C:\eclipse\plugins\org.eclipse.swt.win32.win32.x86_3.4.1.v3449c.jar) atau pada Linux (eclise/plugins/org.eclipse.swt.gtk.linux.x86_3.4.1.v3452b.jar) 2. Menggunakan pustaka SWT beserta sumber kodenya untuk dokumentasi lebih lengkap.

Pustaka

SWT

ini

bisa

diunduh

pada

alamat

berikut

:

http://www.eclipse.org/swt/. Pilih Releases -> Stable -> (platform Anda, misalnya Windos atau Linux). Setelah diunduh, import ke dalam Eclipse seperti Anda mengimport proyek-proyek pada website ini, yaitu dengan File -> Import -> General -> Existing Projects Into Workspace -> Select Archieve File -> (file zip SWT hasil download) -> Finish. Langkah ini hanya dilakukan satu kali saja. 

Buat proyek baru dari Eclipse, File -> New -> Java Project, kemudian isi Project Name dengan HelloSWT dan click Next



Kita harus menambahkan pustaka SWT ke dalam proyek kita.

1. Jika Anda menggunakan SWT bawaan Eclipse seperti di atas, pilih halaman Libraries. Klik Add External JAR, kemudian navigasi ke direktori plugin di dalam instalasi Eclipse Anda. Misalnya di komputer saya, direktori itu berada di C:\eclipse\plugins. Pilih JAR untuk SWT pada direktori tersebut. Namanya tergantung dari sistem operasi Anda, misalnya pada Windows file ini bernama org.eclipse.swt.win32.win32.x86_3.4.1.v3449c.

ditambahkan di dalam folder Libraries.

Klik OK setelah file ini

1. Jika Anda mengunduh proyek SWT, pilih halaman Projects. Klik Add, kemudian tambahkan org.eclipse.swt. Kemudian klik OK setelah proyek ini ditambahkan.



Folder proyek baru akan dibuat, seperti pada gambar berikut.



Kemudian klik kanan pada folder src, dan pilih New -> Class. Isi nama kelas dengan HelloSWT, nama package dengan helloswt, dan tik "public static void main(String[] args)" untuk membuat metode main() secara otomatis.



Ketik kode berikut ini di dalam metode main() Display display = new Display(); Shell shell = new Shell(display); shell.setLayout( new RowLayout()); Label label = new Label(shell, SWT.NONE); label.setText("Hello, World!"); shell.pack(); shell.open(); while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep(); display.dispose(); label.dispose();



Perhatikan bahwa Display, Shell, RowLayout dan Label diberi tanda merah sebagai tanda bahwa kesalahan program terjadi.



Sekarang pindahkan mouse Anda pada kesalahan pada kelas Display. Eclipse akan memberi tahu Anda kesalahan apa yang terjadi. Pada contoh ini, kelas 'Display' belum

diketahui

oleh

(org.eclipse.swt.widgets).

Eclipse.

Klik

pada

pilihan

Import

'Display'

Lihat sekarang di awal program Anda Eclipse

menambahkan import org.eclipse.swt.widgets.Display; secara otomatis.



Lakukan hal yang sama pada semua kesalahan, yaitu Shell, Label, RowLayout dan SWT.NONE,

sehingga tidak ada lagi kesalahan yang dilaporkan oleh Eclipse.



Untuk menjalankan program Anda, klik tombol Run seperti pada gambar berikut.



Berikut ini adalah tampilan program SWT pertama Anda.

Mengkompilasi dan Membuat Program SWT Berjalan di Luar Eclipse Untuk bisa membuat program kita berguna untuk orang lain, kita harus bisa mengkompilasi dan membuat program tersebut sebagai satu "paket". Proses ini disebut menyebarkan (deploy). Pada Eclipse, program yang telah kita buat bisa kita deploy dalam format JAR (Java Archive), yang menggabungkan semua file kelas yang sudah dikompilasi beserta pustaka yang dibutuhkan untuk bisa menjalankan program tersebut. Mari kita lihat contoh program HelloSWT yang sudah dibahas sebelumnya. Untuk mendeploy program ini sehingga bisa dijalankan di luar Eclipse, lakukan langkah-langkah berikut :



Klik kanan pada nama proyek Anda, kemudian pilih Export. Setelah itu kotak dialog akan terbuka. Kemudian pilih Runnable JAR File dari dalam folder Java.



Pilih HelloSWT - HelloSWT pada Launch configuration dan juga masukkan di mana file JAR hasilnya akan ditempatkan. Jika nama direktori tidak diberikan, Eclipse akan meletakkan file JAR tersebut pada direktori di mana workspace berada, yaitu di mana data proyek ditempatkan. (Misalnya, di komputer saya proyek HelloSWT berada pada direktori C:\belajarjava.lyracc.com\HelloSWT, maka file JAR tersebut akan diletakkan pada direktori C:\belajarjava.lyracc.com\)



Klik Finish, kemudian OK untuk setiap pertanyaan yang mungkin muncul berikutnya. Sekarang, gunakan Windows Explorer untuk mencari di mana file JAR hasilnya berada. Double click pada file tersebut dan Anda akan bisa menjalankannya langsung seperti aplikasi lainnya. Anda bisa juga mengirimkan file

ini melalui email atau mengkopinya melalui flash disk ke teman atau kerabat Anda tanpa perlu menyertakan Eclipse.



CATATAN : Ingat bahwa SWT bergantung penuh pada sistem operasi yang Anda gunakan, karena SWT menggunakan widget bawaan sistem operasi seperti dijelaskan pada bagian sebelumnya. Ketika Anda membuat program ini pertama kali, Anda menambahkan pustaka SWT yang spesifik terhadap sistem operasi di mana

Eclipse

berjalan.

Artinya,

jika

Anda

menambahkan

pustaka

org.eclipse.swt.win32.win32.x86_3.4.1.v3449c, maka program JAR Anda hanya akan bisa dijalankan pada sistem operasi Windows. Untuk bisa menjalankannya pada sistem operasi lain, misalnya Linux, maka Anda harus menambahkan pustaka SWT khusus Linux yang bisa diunduh secara terpisah atau menggunakan Eclipse pada Linux. 

Berikut ini adalah screen shot hasil jalannya program

Melihat Lebih Dekat HelloSWT Secara umum aplikasi SWT membutuhkan beberapa langkah sebagai berikut : 1. Buat Display baru 2. Buat satu atau lebih Shell 3. Buat manager layout untuk Shell baru 4. Buat widget di dalam shell 5. Buka jendela shell 6. Buat perulangan pengirim event 7. Buang (dispose) display dan widget-widget lainnya 8. Tentunya import berbagai paket yang diperlukan oleh program package helloswt; import org.eclipse.swt.SWT; import org.eclipse.swt.layout.RowLayout; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Shell; public class HelloSWT { /** * @param args */ public static void main(String[] args) { Display display = new Display(); Shell shell = new Shell(display); shell.setLayout( new RowLayout()); Label label = new Label(shell, SWT.NONE); label.setText("Hello, World!"); shell.pack(); shell.open(); while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep(); display.dispose(); label.dispose(); } }

Mari kita bahas satu per satu

1. Membuat Display baru Membuat Display dapat dilakukan dengan membuat instansi dari objek bertipe Display, misalnya seperti perintah berikut Display display = new Display();

Display (tampilan) adalah objek maya yang merupakan kontainer induk semua komponen GUI. Suatu tampilan sebetulnya tidak terlihat, akan tetapi komponen yang ditambahkan ke dalam tampilan dapat dilihat. Biasanya, suatu aplikasi hanya membutuhkan satu tampilan.

2. Membuat Shell baru Membuat Shell dapat dilakukan dengan membuat instansi dari objek bertipe Shell, misalnya seperti perintah berikut Shell shell = new Shell(display);

Pada pernyataan di atas, konstruktor Shell mengambil parameter yang merupakan induk di mana shell ini akan diletakkan. Pada pernyataan di atas, kita membuat objek shell bertipe Shell yang memiliki induk objek display. Shell adalah jendela suatu aplikasi. Shell tertinggi adalah shell yang berada langsung di bawah objek bertipe Display, dan merupakan jendela utama suatu aplikasi. Shell sebenarnya adalah widget komposit, yaitu suatu widget yang terdiri dari beberapa widget lain. Oleh karenanya shell juga bisa berisi shell lain. Untuk aplikasi sederhana yang menampilkan kata "Hello World!", kita hanya membutuhkan satu shell saja yang kita letakkan pada objek display.

3. Membuat manager layout untuk Shell baru Untuk membuat manager layout, kita menggunakan metode instansi dari objek shell, yaitu setLayout()

yang mengambil parameter jenis layout yang akan disusun pada shell.

Misalnya, shell.setLayout( new RowLayout());

Pada contoh di atas, kita memerintahkan objek shell untuk mengatur widget-widget di dalamnya dalam urutan seperti baris. RowLayout adalah kelas layout yang digunakan objek shell untuk mengatur objek widget di dalamnya. Manager layout digunakan untuk mengatur secara otomatis peletakkan setiap widget. Pada SWT, objek komposit seperti Shell tidak mengetahui bagaimana widget harus ditampilkan. Oleh karenanya jika kita tidak memberikan manager layout kepada objek bertipe Shell, maka tidak ada widget yang akan ditampilkan. Bahasan khusus tentang layout cukup kompleks, dan karenanya kita akan bahas tersendiri pada bagian selanjutnya.

4. Membuat widget di dalam shell Widget adalah komponen pembangun GUI. Menu, tombol, teks, kotak cek, kotak input teks, hingga kanvas, adalah contoh-contoh widget. Setiap widget memiliki sifat dan cara kerja yang berbeda-beda. Pada contoh ini, kita menggunakan widget yang sangat sederhana yang dinamakan Label. Widget ini digunakan untuk menampilkan teks, misalnya digunakan sebagai label atau pertanyaan pada suatu input teks. Pada contoh HelloSWT, kita gunakan konstruktor yang mengambil 2 parameter. Yang pertama, adalah kontainer induk di mana Label ini akan ditampilkan, dan parameter kedua adalah bit gaya. Label label = new Label(shell, SWT.NONE);

Label ini kemudian kita isi dengan kata "Hello Word!" untuk menampilkan kata ini pada jendela utama. label.setText("Hello, World!");

5. Membuka jendela shell Setelah Display, Shell, dan widget-widgetnya disiapkan, kita perlu secara eksplisit memerintahkan shell untuk membuka jendela dan menggambar seluruh widget yang sudah disiapkan. Untuk ini kita gunakan perintah shell.open();

6. Membuat perulangan pengirim event SWT mengharuskan kita untuk membuat sendiri perulangan untuk mengirimkan event. Artinya, blok perintah berikut ini "harus" selalu ada dalam semua aplikasi SWT yang akan kita buat. while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep();

7. Membuang (dispose) display dan widget-widget lainnya Karena SWT bekerja langsung dengan widget bawaan sistem operasi, maka tanggung jawab untuk menghapus komponen GUI ada di tangan programmernya. Hal ini disebabkan widget tersebut berada di luar jangkauan pemulung memori Java yang hanya bisa meraih objek yang dibuat dan dijalankan dalam JVM (Java Virtual Machine). Untuk menghapus widget dari memori, kita dapat menggunakan metode dispose() yang dimiliki oleh hampir semua widget SWT. Pada contoh program ini, kita memiliki 2 widget, yaitu shell dan label, sehingga keduanya harus dihapus dengan menggunakan perintah display.dispose(); label.dispose();

8. Mengimport berbagai paket yang diperlukan oleh program Kita bisa menggunakan Eclipse untuk membantu kita mengimpor setiap paket (seperti yang diilustrasikan pada bagian sebelumnya), atau menggunakan wildcard seperti import org.eclipse.swt.widgets.*

Beberapa paket penting yang tersedia pada SWT : Nama Paket org.eclipse.swt

Kegunaan Berisi kelas SWT, kumpulan konstanta, dan kelas-kelas pengecualian dan kesalahan Widget dan kelas-kelas yang berhubungan dengannya, misalnya

org.eclipse.swt.widgets

menu, kotak dialog, dukungan event, kelas super abstrak untuk layout, dan sebagainya

org.eclipse.swt.events org.eclipse.swt.layout

org.eclipse.swt.graphics

Event tingkat tinggi, pendengar event, dan colokan (adapter) Kelas layout standar seperti FillLayout, RowLayout, GridLayout, FormLayout, dan kelas-kelas lainnya Huruf, warna, gambar, dan operasi grafik dasar, seperti untuk menggambar garis dan lingkaran Widget buatan sendiri dan kelas lain yang dibuat khusus untuk

org.eclipse.swt.custom

Eclipse; tidak bergantung pada platform apapun (implementasinya sama pada semua sistem operasi)

org.eclipse.swt.dnd

org.eclipse.swt.accessibility org.eclipse.swt.printing

Kelas bantuan untuk melakukan drag-and-drop pada berbagai platform Perluasan untuk memberikan bantuan dan dukungan untuk orang cacat Dukugan printer dan kotak dialog untuk melakukan percetakan Berisi kelas Program, untuk mempermudah pada saat program

org.eclipse.swt.program

dijalankan, pemetaan dokumen, dan icon; juga dibuat untuk Eclipse, akan tetapi sangat bergantung pada platformnya (implementasinya bisa berbeda untuk setiap sistem operasi) Menyediakan widget sebagai web broswer, dan kelas-kelas yang

org.eclipse.swt.browser

mendukungnya. Menggunakan browser bawaan sistem operasi untuk implementasinya

org.eclipse.swt.awt

org.eclipse.swt.win32.ole

Menyediakan dukungan untuk membuat UI yang berisi campuran widget dari SWT dan AWT Hanya tersedia pada Windows; menyediakan fasilitas untuk mengakses OLE (Object Linking and Embedding)

Pengenalan Konsep Widget pada SWT Secara tradisional, widget bisa dibayangkan seperti perangkat abstrak yang berguna untuk melakukan tugas tertentu. Istilah ini popules dalam bidan ekonomi. Para pembuat software meminjam istilah ini untuk menyebut suatu paket program pembuat GUI (grahical user interface). SWT adalah kepanjangan dari Standard Widget Toolkit karena widget merupakan dasar pembangun suatu aplikasi yang dibangun dengan menggunakan SWT. Apa itu widget? Widget adalah elemen GUI yang dapat berinteraksi dengan user. Widget mengatur dan menentukan kondisinya sendiri dengan memggunakan kombinasi beberapa operasi grafik. Dengan menggunakan mouse atau keyboard, user bisa mengubah kondisi suatu widget. Ketika kondisi suatu widget berubah, baik diubah oleh user ataupun diubah oleh suatu kode program, maka widget akan menggambar dirinya kembali untuk merefleksikan hasil perubahannya. Siklus hidup widget Widget memiliki siklus hidup sendiri. Widget dibuat oleh programmer dan dibuang ketika tidak lagi dibutuhkan. Karena siklus hidup suatu widget sangat penting untuk memahami SWT, maka kita akan bahas lebih jauh pada bagian ini. 1. Membuat Widget Widget dibuat dengan menggunakan konstruktornya, atau dengan kata lain membuat instansi suatu kelas. Ketika widget dibuat, widget akan mengambil sumber daya komputer (memori, prosesor) dari sistem operasi. Artinya semua widget akan berada di level sistem operasi, sehingga unjuk kerja dan pengaturan memori akan lebih optimal. Konstruktor akan mengambil argumen yang biasanya tidak akan bisa diubah setelah widget dibuat. Ada 4 kemungkinan konstruktor dari suatu jenis widget : 

Widget()



Widget(Widget induk)



Widget(Widget induk, int bitGaya)



Widget(Widget induk, int bitGaya, int posisi)

Widget tidak bisa dibuat tanpa induk. Ini bisa dilihat dari pengenalan tentang widget di bagian sebelumnya bagaimana widget tersusun secara hirarkis. Jenis induknya tergantung

dari jenis widgetnya. Misalnya, induk dari suatu menu harus berupa menu, dan tidak bisa berupa tombol. Kompiler akan mengecek apakah induk suatu widget sesuai dengan tipenya, jika tidak, kompiler akan menampilkan pesan kesalahan. (Pada beberapa platform, kita dibolehkan untuk mengubah induk suatu widget. Akan tetapi SWT tidak memiliki metode getParent() pada kelas-kelas Widgetnya. Ini disebabkan karena kompleksitasnya yang mengharuskan kita untuk melakukan type cast kepada tipe induk yang benar.) Bit gaya (style) adalah nilai bit integer yang digunakan untuk mengatur perilaku dan tampilan suatu widget. Biasanya bit gaya hanya dibutuhkan pada saat widget dibuat, misalnya memilih jenis editor multi baris atau baris tunggal. Karena atribut ini tidak bisa diubah setelah widget dibuat, maka gaya suatu widget juga tidak bisa diubah setelah widget diinstansikan. Semua gaya widget dikumpulkan sebagai konstanta pada kelas org.eclipse.swt.SWT. Kita bisa menggambungkan beberapa gaya dengan menggunakan operasi OR. Misalnya kode berikut akan membuat widget teks multi baris yang memiliki tepi serta scroll bar horizontal dan vertikal. Text teks = new Text (induk, SWT.MULTI | SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER);

Gaya suatu widget bisa kita ambil setelah widget tersebut dibuat dengan menggunakan metode instansi getStyle(). Untuk mengujinya, kita bisa menggunakan operasi AND yang jika hasilnya tidak nol, maka widget tersebut memiliki gaya yang diuji. Misalnya, kode berikut menguji apakah suatu widget teks memiliki tepi, kemudian mencetak hasilnya pada konsol. if ((teks.getStyle() & SWT.BORDER) != 0) System.out.println("teks memiliki tepi"); else System.out.println("teks tidak memiliki tepi");

Paremeter posisi memungkinkan kita membuat widget baru pada suatu induk di posisi tertentu. Jika tidak diberikan, maka secara otomatis widget baru akan ditempatkan di akhir posisi. Hal ini akan lebih memudahkan kita untuk membuat widget pada urutan tertentu, misalnya membuat menu dengan urutan tertentu. 2. Membuang widget Ketika widget tidak lagi dibutuhkan, termasuk ketika program selesai, maka widget harus dihapus secara eksplisit dengan menggunakan metode instansi dispose(). Metode ini akan menyembunyikan widget, menghapus widget yang ditampungnya, dan membuat semua referensi di dalamnya menjadi null.

Jika metode dispose() tidak dipanggil setelah program selesai dijalankan, maka hal ini akan menyebabkan kebocoran memori, di mana memori pada sistem operasi lambat laun akan habis dipenuhi oleh widget yang tidak dihapus setelah program selesai. Memanggil metode dispose() untuk widget yang sudah dibuang, akan melemparkan pengecualian SWTException. Untuk mengetahui apakah suatu widget sudah dihapus, kita bisa menggunakan metode instansi isDisposed(). Ada dua aturan yang penting untuk diingat : 

Jika Anda membuat widget, maka pastikan Anda menghapusnya. Atau dengan kata lain, semua widget yang Anda buat dengan konstruktor wajib dihapus. Akan tetapi jika Anda mendapatkan widget dari metode instansi suatu widget, misalnya Font huruf = kontrol.getFont(),



maka Anda tidak perlu menghapusnya

Jika Anda menghapus suatu widget, maka semua widget di bawahnya akan dihapus juga. Atau dengan kata lain, jika Anda menghapus suatu Shell, maka isi seluruh Shell akan dihapus secara otomatis. Demikian juga halnya dengan menu, jika Anda menghapus menu utama, maka semua sub-menu akan otomatis dihapus.

Event dan Listener 

Event



Event adalah inti dari pemrograman GUI. GUI program tidak memiliki alur apa yang akan terjadi ketika program dijalankan, dalam arti langkah per langkah dari awal hingga akhir. Akan tetapi, program harus bisa bereaksi akan berbagai event (kejadian) yang bisa berasal dari mouse atau keyboard. User bisa menekan tombol keyboard apa saja, menggeser mouse, atau menekan tombol mouse. User bisa melakukannya kapan saja, dan komputer harus bisa bereaksi dengan tepat.



Dalam Java, event dilambangkan oleh objek. Ketika suatu event terjadi, sistem akan mengumpulkan informasi yang sesuai dengan even tersebut, kemudian membuat objek yang berisi informasi ini. Jenis even berbeda dilambangkan oleh objek dengan kelas yang berbeda pula. Setelah objek event dibuat, ia akan diberikan sebagai parameter pada subrutin yang ditugaskan untuk menangani event tersebut. Dengan menulis subrutin ini, programmer bisa memberi tahu apa yang harus dilakukan jika mouse diklik atau keyboard ditekan, misalnya.



Sebagai programmer Java, kita hanya melihat even dari sisi yang lebih umum. Banyak sekali hal yang terjadi antara tombol ditekan hingga subrutin yang kita buat melakukan tugasnya. Secara garis besar, dalam metode main() kita harus menuliskan perulangan dalam bentuk seperti :



ketika program masih berjalan:



Tunggu hingga even berikutnya terjadi



Panggil subrutin untuk menangai event tersebut



Perulangan ini disebut perulangan event. Pada SWT kita harus menulis sendiri perulangan event ini pada metode main() kita dalam bentuk



while (!shell.isDisposed())



if (!display.readAndDispatch())



display.sleep();



SWT memiliki dua jenis event, yaitu event tanpa tipe dan event bertipe.



Event tanpa tipe diwakili oleh kelas Event. Kelas ini menyimpan informasi yang berbeda-beda tergantung dari jenis. Akan tetapi secara umum semua event jenis apapun memiliki informasi berikut :

Informasi Penjelasan display

Display di mana event ini terjadi

widget

Widget di mana event ini terjadi

type

Jenis event yang terjadi



Jenis event yang terjadi beserta penjelasannya dirangkum dalam tabel berikut ini :

Jenis Event

Penjelasan

SWT.KeyDown

Tombol ditekan

SWT.KeyUp

Tombol dilepaskan

SWT.MouseDown

Tombol mouse ditekan

SWT.MouseUp

Tombol mouse dilepaskan

SWT.MouseMove

Mouse berpindah posisi

SWT.MouseEnter

Mouse masuk ke wilayah klien

SWT.MouseHover

Mouse berada di sekitar klien

SWT.MouseExit

Mouse keluar dari wilayah klien

SWT.MouseDoubleClick Mouse di-double click SWT.Paint

Suatu widget diberi perintah untuk menggambar dirinya

SWT.Move

Posisi suatu widget berubah

SWT.Resize

Ukuran widget berubah

SWT.Dispose SWT.Selection

Widget dihapus Suatu aksi pemilihan dilakukan dalam widget (misalnya memilih item pada drop down list

SWT.DefaultSelection

Ada pilihan awal pada suatu widget

SWT.FocusIn

Widget menerima fokus dari keyboard

SWT.FocusOut

Widget kehilangan fokus dari keyboard

SWT.Expand

Item pada pohon dikembangkan

SWT.Collapse

Item pada pohon ditutup

SWT.Iconify

Jendela Shell diminimasi

SWT.Deiconify

Jendela Shell dibuka (restore)

SWT.Close

Jendela Shell ditutup (dengan tombol X)

SWT.Show

Widget bisa dilihat

SWT.Hide

Widget disembunyikan

SWT.Modify

Teks berubah pada suatu kontrol

SWT.Verify

Input teks sedang diverifikasi

SWT.Activate

Widget sedang diaktifkan

SWT.Deactivate

Widget dimatikan

SWT.Help

User meminta pertolongan tentang suatu widget

SWT.DragDetect

Aksi drag-and-drop dideteksi

SWT.MenuDetect

User menekan tombol kik kanan untuk mengaktifkan menu konteks

SWT.Arm

Item pada menu digambarkan

SWT.Traverse

Navigasi pada keyboard dideteksi

SWT.HardKeyDown

Tombol pada hardware ditekan (untuk perangkat genggam)

SWT.HardKeyUp

Tombol pada hardware dilepas (untuk perangkat genggam)



Suatu event juga bisa memiliki tipe. Artinya event yang dihasilkan merupakan objek bertipe suatu kelas, misalnya MouseEvent, bukan hanya bertipe kelas Event yang jenisnya disimpan dalam variabel tertentu. Event bertipe mengikuti pola

JavaBeans

standar.

Kelas-kelas

ini

terdapat

dalam

paket

org.eclipse.swt.events 

Tabel berikut menggambarkan perbandingan antara event bertipe dan jenis event dari event tanpa tipe.

Event Bertipe Jenis Event Tanpa Tipe ArmEvent ControlEvent

SWT.Arm SWT.Move SWT.Resize

DisposeEvent SWT.Dispose FocusEvent HelpEvent KeyEvent

MenuEvent ModifyEvent

SWT.FocusIn SWT.FocusOut SWT.Help SWT.KeyDown SWT.KeyUp SWT.Hide SWT.Show SWT.Modify SWT.MouseDoubleClick

MouseEvent

SWT.MouseDown SWT.MouseUp

MouseEvent

SWT.MouseMove SWT.MouseEnter

MouseEvent

SWT.MouseExit SWT.MouseHover

PaintEvent SelectionEvent

SWT.Paint SWT.DefaultSelection SWT.Selection SWT.Activate

ShellEvent

SWT.Close SWT.Deactivate

SWT.Iconify SWT.Deiconify TraverseEvent SWT.Traverse TreeEvent VerifyEvent

SWT.Collapse SWT.Expand SWT.Verify



Pertanyannya kenapa ada dua jenis event yang berbeda?



Pada versi awal SWT, hanya ada satu jenis yaitu jenis tanpa tipe. Setelah diskusi yang cukup antar beberapa programmer Eclipse, komunitas user SWT dan developernya, maka akhirnya diputuskan untuk menambahkan jenis bertipe seperti pada JavaBeans. Alasannya adalah untuk memudahkan pemrograman SWT bagi programmer yang sudah terlanjur terbiasa dengan AWT/Swing. Jenis tanpa tipe masih tetap ada seperti biasa.



Listener



Supaya suatu event berarti, suatu program harus bisa mendeteksi event dan bereaksi akan event tersebut. Untuk mendeteksi suatu event, suatu program harus mendengarkannya. Mendengarkan event ini dilakukan oleh objek yang berna,a pendengar event (event listener). Objek listener harus memiliki metode instansi untuk menangani event yang didengarkannya. Bentuknya bervariasi tergantung dari jenis event yang ditanganinya.



Ada beberapa hal detail yang harus diingat untuk bisa bekerja dengan event. Beberapa langkah yang harus diingat :



1. Menambahkan import paket yang dibutuhkan, misalnya "org.eclipse.swt.events"



2. Mendeklarasikan kelas yang mengimplementasikan interface suatu listener



3. Menambahkan aksi yang dilakukan oleh kelas baru tersebut. Aksi ini adalah aksi yang dilakukan untuk menangani suatu event



4. Mendaftarkan event tersebut ke komponen yang mungkin memberikan event.



Objek

apapun

bisa

bertindah

sebagai

event

listener

asalkan

ia

mengimplementasikan interface yang tepat. Suatu komponen dapat mendengarkan event yang dihasilkannya sendiri. Suatu kelas dapat dibuat secara khusus hanya untuk mendengarkan suatu event. Kebanyakan orang menganggap lebih mudah untuk menggunakan kelas bertingkat anonim untuk mendengarkan suatu objek. (Kelas bertingkat anonim telah dibahas sebelumnya di sini).



Seperti hanya Event, SWT memiliki dua jenis listener : tanpa tipe dan bertipe. Masing-masing digunakan untuk menangani event tanpa tipe dan event bertipe.



Listener Tanpa Tipe (untuk menangani event tanpa tipe)



nterface generik yang digunakan untuk menangai event tanpa tipe dinamakan Listener.

Listener tanpa tipe dapat ditambahkan pada suatu widget dengan

menggunakan metode addListener(). 

Metode addListener() memiliki bentuk seperti



addListener(int jenisEvent, Listener listener)



Metode ini akan menambah listener ke dalam koleksi listener yang akan dipanggil ketika event tipe tertentu terjadi. Ketika suatu event terjadi, maka listener akan dipanggil dengan menggunakan metode handleEvent().



Contoh berikut mengilustrasikan bagaimana menambah suatu Listener ke dalam suatu widget, yang akan dipanggil ketika event SWT.Dispose terjadi.



widget.addListener(SWT.Dispose, new Listener() {



public void handleEvent(Event event) {



// widget was disposed



}



});



Perhatikan bahwa bentuk di atas menggunakan kelas anonim yang langsung diturunkan dari interface Listener. Di dalam kelas anonim tersebut, metode handleEvent()

harus diimplementasikan, di mana implementasinya adalah tugas

yang harus dilakukan ketika widget dihapus. 

Jika beberapa listener ditambahkan, maka mereka akan dipanggil dengan urutan ketika mereka ditambahkan (first in first called). Artinya listener pertama diberi kesempatan untuk mengolah event (mungkin untuk memfilter sejumlah data) sebelum listener lain melakukan tugasnya. Kita juga bisa menambah listener yang sama beberapa kali, yang artinya listener tersebut akan dipanggil beberapa kali.



Kita bisa menghapus listener dari suatu widget dengan menggunakan metode removeListener().

Bentuknya adalah sebagai berikut



removeListener(int jenisEvent, Listener listener)



Untuk menghapus suatu listener, kita harus memberikan instansi yang persisi sama ketika listener tersebut ditambahkan. JIka beberapa instansi listener yang sama sudah ditambahkan sebelumnya, maka kita harus menghapusnya berulang kali sejumlah ia ditambahkan. Secara umum, menghapus suatu listener mungkin tidak

diperlukan. Listener akan diambil oleh pemulung memori ketika suatu widget dihapus dan listener ini tidak lagi digunakan di manapun di dalam program. 

Kita juga bisa memanggil suatu listener untuk melakukan tugas tertentu, yaitu dengan menggunakan metode notifyListeners, yang memiliki bentuk seperti



notifyListeners(int jenisEvent, Event event)



jenisEvent

adalah jenis event yang akan dilakukan, dan Event adalah objek yang

berisi event yang akan dilakukan. Hal penting yang harus dicatat adalah memanggil metode notifyListeners() tidak menyebabkan event akan benar-benar terjadi. Misalnya memanggil notifyListeners() dengan jenis SWT.MouseDown tidak akan menyebabkan tombol terlihat seperti ditekan. Dan juga memanggil notifyListeners()

tidak menjamin bahwa semua data pada event terinisialisasi

seperti pada event sesungguhnya. 

Listener Bertipe (untuk menangani Event bertipe)



Karena event bertipe dibuat mengikuti pola listener pada JavaBeans, penggunaan listener bertipe sangat mirip dengan penggunaan listener pada AWT/Swing.



Misalnya untuk mendengarkan event ketika suatu widget dihapus, maka aplikasi bisa menggunakan addDisposeListener(), yang memiliki bentuk seperti



addDisposeListener(DisposeListener listener)



Metode ini menambahkan listener ke dalam koleksi listener yang akan dipanggil ketike suatu widget dihapus. Ketika suatu widget dihapus, maka listener akan dipanggil dengan memanggil metode widgetDisposed().



Potongan kode berikut digunakan untuk menangani event ketika suatu widget dihapus.



widget.addDisposeListener(new DisposeListener() {



public void widgetDisposed(DisposeEvent event) {



// widget was disposed



}



});



DisposeListener

adalah suatu interface. Jika ada lebih dari satu metode yang

didefinisikan dalam listener, maka SWT akan secara otomatis menambahkan kelas adapter yang berisi implementasi kosong dari metode-metode yang didefinisikan pada interface tersebut. Misalnya interface SelectionListener memiliki dua metode, yaitu widgetSelected() dan widgetDefaultSelected, yang keduanya mengambil

argumen

bertipe

SelectionEvents.

Dalam

hal

ini

kelas

SelectionAdapter

tersedia untuk memberikan implementasi kosong untuk setiap

metode. Kelas adapter ini hanyalah sebagai kelas bantu yang sesuai dengan konvensi pada listener JavaBeans. 

Listener bertipe bisa dihapus dengan menggunakan metode penghapus untuk setiap listner. Misalnya, listener untuk event ketika suatu widget dihapus bisa dibuang dengan menggunakan removeDisposeListener(), yang memiliki bentuk



removeDisposeListener(DisposeListener listener)



listener

adalah objek listener yang akan dihapus dari koleksi listener yang

dipanggil ketika widget dihapus. 

Tabel

berikut merangkum event

bertipe, nama

interface

listener yang

menanganinya, serta metode pada interface tersebut, dibandingkan dengan listener tanpa tipe. Event

Interface

Bertipe

Listener

ArmEvent

ArmListener

ControlEven t DisposeEven t

ControlListener (dan ControlAdapter) DisposeListener FocusListener

FocusEvent (dan FocusAdapter) HelpEvent KeyEvent

HelpListener

Tipe

widgetArmed(ArmEvent)

SWT.Arm

controlMoved(ControlEvent)

SWT.Move

controlResized(ControlEvent)

SWT.Resize

widgetDisposed(DisposeEvent)

SWT.Dispose

focusGained(FocusEvent)

SWT.FocusIn

focusLost(FocusEvent)

SWT.FocusOut

helpRequested(HelpEvent)

SWT.Help SWT.KeyDown

KeyAdapter)

keyReleased(keyEvent)

SWT.KeyUp

menuHidden(MenuEvent)

SWT.Hide

menuShown(MenuEvent)

SWT.Show

modifyText(ModifyEvent)

SWT.Modify

MenuEvent (dan MenuAdapter)

t

Jenis Event Tanpa

KeyListener (dan keyPressed(KeyEvent)

MenuListener

ModifyEven

Metode

ModifyListener

MouseListener MouseEvent (dan

mouseDown(MouseEvent)

MouseAdapter)

MouseEvent

MouseMoveListe ner MouseTrackListe

MouseEvent

ner

(dan

MouseTrackAdapt er)

PaintEvent SelectionEve nt

ShellEvent

TraverseEve nt TreeEvent

mouseDoubleClick(MouseEvent)

PaintListener

mouseUp(MouseEvent)

SWT.MouseDoubleC lick SWT.MouseDown SWT.MouseUp

mouseMove(MouseEvent)

SWT.MouseMove

mouseEnter(MouseEvent)

SWT.MouseEnter

mouseExit(MouseEvent)

SWT.MouseExit

mouseHover(MouseEvent)

SWT.MouseHover

paintControl(PaintEvent)

SWT.Paint

SelectionListener widgetDefaultSelected(SelectionE SWT.DefaultSelectio (dan

vent)

SelectionAdapter) widgetSelected(SelectionEvent)

ShallListener (dan ShellAdapter)

TraverseListener

n SWT.Selection

shellActivated(ShellEvent)

SWT.Activate

shellClosed(ShellEvent)

SWT.Close

shellDeactivated(ShellEvent)

SWT.Deactivate

shellIconified(ShellEvent)

SWT.Iconify

shellDeiconified(ShellEvent)

SWT.Deiconify

keyTraversed(TraverseEvent)

SWT.Traverse

TreeListener (dan treeCollapsed(TreeEvent)

SWT.Collapse

TreeAdapter)

treeExpanded(TreeEvent)

SWT.Expand

verifyText(VerifyEvent)

SWT.Verify

VerifyEvent VerifyListener Penanganan Mouse

Semua sistem operasi di mana SWT diimplementasikan mendukung perangkat tunjuk. Biasanya berbentuk mouse, akan tetapi bisa jadi berupa trackball, trackpad, atau jenis perangkat keras lainnya. Pada komputer genggam, perangkat tunjuk bisa jadi berupa stylus. Untuk mempermudah pembahasan, kita akan gunakan mouse sebagai perangkat tunjuk, tidak peduli bagaimana perangkat aslinya. Posisi suatu mouse biasanya digambarkan dalam bentuk ikon kecil pada layar yang disebut kursor. Hal ini berlaku untuk semua platform, kecuali pada Windows CE, karena perangkat

Windows CE biasanya berupa perangkat tunjuk "langsung", seperti stylys, yang tidak membutuhkan kursor. Mouse biasanya memiliki tiga tombol (kecuali pada Macintosh yang hanya memiliki satu tombol, walaupun sebenarnya mouse lebih dari 1 tombol pun bisa digunakan). Mouse digunakan untuk menunjuk, klik, geser (drag) dan memilih komponen kontrol GUI. Bisa juga digunakan untuk menampilkan menu konteks yang biasanya ditampilkan dengan mengklik kanan suatu mouse. Perilaku "drag-and-drop" mouse kurang lebih sangat bergantung pada platformnya. Ketika kita menggeser mouse, kursor akan berbah bentuk, tergantung dari kontrol apa di bawahnya. Misalnya, widget teks akan mengubah tampilan kursor seperti huruf I untuk menunjukkan bahwa user bisa mengetikkan sesuatu pada widget tersebut. Di dalam kursor, ada titik pusat yang menunjukkan koordinat x dan y suatu mouse ketika event pada mouse terjadi. Event pada Mouse Ketika tombol mouse ditekan atau mouse digerakkan, event mouse dibuat dan akan diberikan kepada widget yang ada di bawahnya. Akan tetapi ketika tombol mouse ditekan dan ditahan (terus ditekan), dan mouse berada di luar widget (mungkin ada di widget lain atau pada aplikasi lain di desktop), eventnya akan diberikan kepada widget awal di mana mouse tersebut ditekan. Pengalihan event sementara ini disebut pengambilan mouse. Widget yang menerima event disebut widget pengambil. Pengambilan mouse terhadi secara otomatis pada SWT. (Ini mungkin bukan sesuatu masalah, akan tetapi sebagai informasi saja kepada Anda). Tabel - Isi Event Mouse ketika suatu tombol mouse ditekan, dilepaskan atau mouse digeser Nama Field

Penjelasan

button

Tombol yang ditekan atau dilepaskan

x

Koordinat x ketika event terjadi

y

Koordinat y ketika event terjadi

stateMask

Bit mask yang menyatakan kondisi keyboard dan mouse sebelum event terjadi

Ketika mouse ditekan atau dilepas, field bernama "button" akan diisi oleh tombol mana yang ditekan. Tombol mouse diberi nomor dari kiri ke kanan yang dimulai dari 1. Untuk

user kidal (dan mengkonfigurasi sistem operasi untuk orang kidal), penomoran tombol tetap sama, akan tetapi dimulai dari kanan ke kiri. Pemetaan tombol untuk orang kidal ini tidak tampak oleh SWT dan aplikasi kita, karena dilakukan secara otomatis oleh sistem operasi. Ketika terjadi event pada mouse, koordinat x dan y-nya juga dilaporkan dalam event. Koordinat yang dilaporkan adalah koordinat relatif widget ketika event tersebut dibuat (bukan koordinat global layar atau aplikasi kita). Karena user mungkin telah memindahkan mouse setelah menekan tombol, maka lokasi sebenarnya ketika event ini ditangani mungkin berbeda dengan ketika event dibuat. Hal ini untuk menghindari program kita untuk bertindak terlalu sensitif terhadap pergerakan mouse. (Jika kita membutuhkan lokasi yang aktual pada saat-saat tertentu, kita bisa menggunakan metode getCursorLocation() yang dimiliki oleh kelas Display.) Event pada mouse juga menggunakan field lain yang dinamakan stateMask untuk menunjukkan keadaan mouse. Seperti pada penanda tombol, stateMask berisi keadaan mouse sebelum terjadinya suatu event. Misalnya, jika tidak ada tombol mouse yang ditekan atau tombol keyboard lain yang ditekan ketika tombol kiri mouse ditekan, maka event mouse akan diisi dengan button bernilai 1 dan stateMask bernilai 0. stateMask tidak berisi "tombol 1". Akan tetapi ketika terjadi event lain ketika mouse kiri sedang ditekan, maka stateMask akan berisi 1. Keadaan suatu mouse dilambangkan oleh konstanta pada kelas SWT, seperti pada tabel berikut : stateMask

Penjelasan

SWT.BUTTON1

Tombol 1 ditekan

SWT.BUTTON2

Tombol 2 ditekan

SWT.BUTTON3

Tombol 3 ditekan

SWT.BUTTON_MASK Bitwise-OR dari tombol-tombol yang ditekan Berikut ini adalah event pada mouse yang disediakan oleh SWT. Seperti disebutkan pada bagian sebelumnya, event dan listener SWT terdiri dari event/listener tanpa tipe dan event/listener bertipe. Keduanya disarikan dalam tabel berikut : Kelas

Interface/Kelas

Event

Listener (listener Metode (listener bertipe)

(event

bertipe)

Jenis event (event Penjelas tanpa tipe)

an

bertipe) mouseDoubleClick(Mouse SWT.MouseDouble Event)

MouseEv ent

MouseListener (dan

Click

Mouse di-double click Tombol

mouseDown(MouseEvent) SWT.MouseDown

mouse ditekan

MouseAdapter)

Tombol mouseUp(MouseEvent)

SWT.MouseUp

mouse dilepaska n

MouseEv MouseMoveListe ent

ner

Mouse mouseMove(MouseEvent) SWT.MouseMove

berpinda h posisi Mouse

mouseEnter(MouseEvent)

SWT.MouseEnter

masuk ke wilayah klien Mouse

MouseTrackListe MouseEv ner ent

(dan mouseExit(MouseEvent)

SWT.MouseExit

MouseTrackAda

berada di sekitar klien

pter)

Mouse keluar mouseHover(MouseEvent) SWT.MouseHover

dari wilayah klien

Mari kita lihat contoh penggunaan mouse event pada program berikut. Anda bisa mengunduh program ini dan mengimportnya pada Eclipse di sini. package net.lyracc.pelacakmouse; import org.eclipse.swt.*;

import org.eclipse.swt.widgets.*; public class PelacakMouse { /** * @param args */ public static void main(String[] args) { // Membuat display dan shell baru Display display = new Display(); Shell shell = new Shell(display); // Kelas Listener baru, menggunakan listener tanpa tipe Listener mouseListener = new Listener() { //

metode

handleEvent

pada

interface

Listener

harus

diimplementasikan public void handleEvent(Event e) { String output = "UNKNOWN"; switch (e.type) { case SWT.MouseDown: output = "DOWN"; break; case SWT.MouseUp: output = "UP"; break; case SWT.MouseMove: output = "MOVE"; break; case SWT.MouseDoubleClick: output = "DOUBLE"; break; case SWT.MouseEnter: output="ENTER"; break; case SWT.MouseExit: output = "EXIT"; break; case SWT.MouseHover: output="HOVER"; break; } //

Mengambil

stateMask

pada

event,

kemudian

menampilkannya // dalam bentuk heksadesimal output += ": stateMask=0x" + Integer.toHexString(e.stateMask); //

Jika

tombol

Ctrl

ditekan,

keluarannya if ((e.stateMask & SWT.CTRL) != 0) output += " CTRL";

tambahkan

CTRL

pada

//

Jika

tombol

Alt

ditekan,

tambahkan

ALT

pada

SHIFT

pada

keluarannya if ((e.stateMask & SWT.ALT) != 0) output += " ALT"; //

Jika

tombol

Shift

ditekan,

tambahkan

keluarannya if ((e.stateMask & SWT.SHIFT) != 0) output += " SHIFT"; // Jika tombol Command ditekan, tambahkan COMMAND pada keluarannya if ((e.stateMask & SWT.COMMAND) != 0) output += " COMMAND"; // Jika tombol kiri mouse ditekan, tambahkan BUTTON1 pada keluarannya if ((e.stateMask & SWT.BUTTON1) != 0) output += " BUTTON1"; // Jika tombol tengah mouse ditekan, tambahkan BUTTON2 pada keluarannya if ((e.stateMask & SWT.BUTTON2) != 0) output += " BUTTON2"; // Jika tombol kanan mouse ditekan, tambahkan BUTTON3 pada keluarannya if ((e.stateMask & SWT.BUTTON3) != 0) output += " BUTTON3"; //

Mengambil

field

button

pada

event,

menampilkannya // dalam bentuk heksadesimal output += ", button=0x" + Integer.toHexString(e.button); // Mengambil koordinat x dan y output += ", x=" + e.x + ", y=" + e.y; // Menampilkan pesan keluaran pada konsol

kemudian

System.out.println(output); } }; // Tambahkan listener pada setiap event yang ingin kita pantau shell.addListener(SWT.MouseDown, mouseListener); shell.addListener(SWT.MouseUp, mouseListener); shell.addListener(SWT.MouseMove, mouseListener); shell.addListener(SWT.MouseDoubleClick, mouseListener); shell.addListener(SWT.MouseEnter, mouseListener); shell.addListener(SWT.MouseExit, mouseListener); shell.addListener(SWT.MouseHover, mouseListener); // Ubah ukuran jendela menjadi 200 x 200 piksel shell.setSize(200, 200); // Perintah "standar" SWT, harus ada pada setiap aplikasi SWT shell.open(); while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep(); display.dispose(); } }

Program di atas akan melacak aktivitas mouse kemudian menampilkannya pada konsol. Jangan lupa untuk menambahkan pustaka SWT sebelum menjalankan program ini seperti dibahas pada bagian ini. Klik Run pada Eclipse dan jalankan sebagai Java Application. Setelah jendela aplikasi yang kita buat keluar, coba jalankan mouse dan perhatikan "Console" pada Eclipse seperti gambar berikut.

Penanganan Keyboard Membuat API yang bisa dijalankan di berbagai platform untuk mengakses keyboard bukan sesuatu yang mudah. Bahkan untuk platform yang sama tetapi dengan versi sistem operasi atau kedaerahan (locale) yang berbeda, karakter bisa dimasukkan dengan cara yang berbeda. Metode input, atau sering juga disebut IM (input method) atau IME (input method engine), adalah mesin pengolah karakter yang disediakan oleh setiap sistem operasi. Tugasnya untuk mengubah urutan tombol keyboard menjadi karakter yang bisa dibaca sesuai dengan konfigurasi locale usernya. Misalnya, pada locale Jepang, tombol yang dimasukkan diproses oleh IME sehingga user bisa memasukkan karakter Kanji. Untungnya, kebanyakan kontrol (widget yang bisa berinteraksi dengan user) bisa menangani keyboard tanpa perlu campur tangan aplikasi. Misalnya, ketika user memasukkan karakter Kanji pada kontrol teks, kontrol tersebut akan mengolah karakter dan menampilkannya. Jika ada menu konteks, maka menu ini akan secara otomatis disediakan. Ketika user menekan tombol pada mouse, maka event yang dihasilkan akan diberikan kepada widget yang ada dibawahnya. Apa yang terjadi ketika tombol keyboard di tekan? Komponen mana yang harus menangani event yang dihasilkan? Ketika suatu tombol pada keyboard ditekan, tombol tersebut akan diberikan kepada subsistem berikut dalam urutan : 1. Sistem jendela

2. Akselerator untuk menu 3. Traversal 4. Kontrol fokus Artinya setiap subsistem diberi kesempatan untuk bereaksi terhadap tombol keyboard, dalam urutan seperti di atas. Jika salah satu subsistem mampu menangani tombol tersebut, maka tombol ini tidak akan diteruskan ke subsistem berikutnya. Dalam hal ini kita sebut tombol tersebut telah digunakan. Kita akan diskusikan setiap subsistem dari bawah ke atas, mulai dari kontrol fokus, karena konsep ini adalah konsep dasar yang diperlukan dalam pemrograman GUI. Kontrol Fokus Program GUI menggunakan fokus input untuk menentukan komponen mana yang yang harus menangani event dari keyboard. Pada suatu saat, hanya ada elemen pada layar yang bisa menerima input, yaitu di mana semua event dari keyboard akan diarahkan. Mungkin merupakan sesuatu yang baik untuk memberi user sedikit bantuan untuk mengetahui apakah suatu komponen memiliki fokus input. Misalnya, jika komponen tersebut adalah tempat mengetik pada program pengolah kata, maka biasanya kursornya akan berubah menjadi bentuk I dan berkedip-kedip. Contoh lainnya adalah misalnya dalam suatu formulir, input teks yang sedang dalam fokus memiliki warna latar belakang yang berbeda dengan input teks yang tidak memiliki fokus. Untuk memberikan fokus kepada suatu komponen, kita bisa menggunakan metode setFocus()

yang terdapat pada hampir semua widget. Jika kontrol adalah objek bertipe

suatu widget yang bisa menerima fokus dan sukses adalah variabel bertipe boolean, maka sukses = kontrol.setFocus();

memberi perintah kepada kontrol untuk mencoba mengambil fokus input. Jika kontrol atau salah satu komponen yang ditampungnya berhasil mengambil fokus, fungsi ini akan mengembalikan true. Jika gagal, maka false akan dikembalikan. Widget komposit (yaitu widget yang bisa berisi widget-widget lain) akan berusaha untuk memberi fokus kepada widget yang ditampungnya sebelum mengambil fokus untuk dirinya sendiri. Beberapa widget lain, seperti label, biasanya tidak mengambil fokus. Suatu kontrol tidak bisa mengambil fokus jika ia tidak aktif atau disembunyikan, atau jika input diblokade karena modalitas (atau karena kontrol lain tidak mengijinkan fokus berpindah tempat). Fungsi lain kontrol.isFocusControl() mengembalikan true jika kontrol tersebut sedang memegang fokus atau false jika tidak. Kita juga bisa mencari tahu kontrol mana yang

sedang memiliki fokus dengan menggunakan metode pada kelas Display yaitu Display.getFocusControl().

Berikut ini adalah daftar event dan listener yang berkaitan dengan fokus. Kelas Event Interface/Kelas (event

Listener (listener

bertipe)

bertipe)

Metode

(listener

bertipe)

Jenis

event

(event

tanpa Penjelasan

tipe) Widget

focusGained(FocusEvent) SWT.FocusIn FocusListener

menerima fokus

dari

keyboard

FocusEvent (dan

Widget

FocusAdapter) focusLost(FocusEvent)

SWT.FocusOut

kehilangan fokus

dari

keyboard Mari kita lihat contoh berikut ini untuk memahami lebih lanjut tentang fokus input. Kita akan buat 2 widget yang berupa input teks. Ketika input teks atas menerima fokus, maka judul aplikasi kita ganti dengan "Fokus pada input teks atas". Ketika input teks bawah menerima fokus, maka judul aplikasi kita ganti dengan "Fokus pada input teks bawah". Jika input teks atas kehilangan fokus, kita isi input teks yang kehilangan fokus dengan "Saya kehilangan fokus", begitu input teks atas menerima fokus kembali, kita akan hapus kalimat tersebut.

Contoh program ini dapat Anda unduh di sini, untuk diimport pada Eclipse. Pembahasan detail tentang contoh program ini akan dibahas kemudian. Event pada Tombol Ketika suatu tombol pada keyboard ditekan, event tombol akan dibuat dan diberikan kepada aplikasi kita. Akan tetapi, tergantung pada platformnya, kedaerahan (locale), dan kombinasi tombol, ada kalanya event tidak terjadi. Misalnya, pada karakter Eropa yang memiliki aksen, mesin pengolah karakter dari sistem operasi akan mengambil tombol

tersebut untuk diolah. Misalnya pada kedaerahan Jerman jika karakter ^ ditekan kemudian diikuti dengan tombol e, maka karakter ê akan ditampilkan. Demikian juga jika tombol bantu ditekan untuk mengolah bahasa Jepang, IME akan mengolah urutan karakter menjadi karakter Kanji. Dengan kata lain, event tingkat rendah seperti ini sangat bergantung pada platform dan sistem operasi, sehingga tidak terlalu berguna untuk kebanyakan program. SWT menyembunyikan event sistem operasi dan hanya menampilkan satu event tombol saja setelah sistem operasi selesai mengolah tombol tersebut. Berikut ini adalah daftar event dan listener yang berkaitan dengan tombol. Kelas Event (event bertipe)

KeyEvent

Interface/Kelas Listener

(listener

bertipe)

KeyListener

(dan

Metode

(listener

bertipe)

Jenis

event

(event

tanpa Penjelasan

tipe)

keyPressed(KeyEvent) SWT.KeyDown

KeyAdapter) keyReleased(keyEvent) SWT.KeyUp

Tombol ditekan Tombol dilepaskan

Event SWT.KeyDown dan SWT.KeyUp merupakan representasi tingkat tinggi dari tombol yang ditekan dan dilepaskan. Event-event ini berguna jika kita ingin mencegat suatu tombol tertentu dan melakukan aksi khusus ketika tombol itu ditekan. Berikut ini adalah isi event keyboard ketika ditekan/dilepaskan. Nama Field character keyCode stateMask doit character

Penjelasan Nilai Unicode dari karakter yang ditekan Konstanta yang menunjukkan tombol mana yang ditekan, misalnya SWT.PAGE_UP Melambangkan tombol tambahan, misalnya SWT.SHIFT Suatu boolean yang bisa digunakan untuk membatalkan aksi penekanan tombol berisi karakter yang kita masukkan lewat keyboard setelah diolah oleh sistem

operasi. Misalnya jika kita menekan tombol maka character berisi 'a'. Jika tombol <Shift> dan ditekan, maka character berisi 'A'. Jika tombol dan ditekan,

maka character akan diisi karakter yang bersesuaian dengan Ctrl+a, yaitu karakter dengan kode Unicode '\u0001' (atau SOH). Beberapa tombol seperti Enter, Backspace, Tab, memiliki kode karakter Unicode tersendiri. SWT juga memiliki konstanta untuk mewakili tombol-tombol ini, yaitu Konstanta character Penjelasan SWT.BS

Tombol backspace

SWT.CR

Tombol Enter

SWT.DEL

Tombol Del

SWT.ESC

Tombol Esc

SWT.LF

Tombol LF

SWT.TAB

Tombol Tab

keyCode

berisi karakter yang tidak bisa diwakilkan dengan karakter Unicode, misalnya

tombol , tombol , tombol <Panah Atas>, dan lain-lain termasuk tombol angka pada keypad dan tombol <+> <-> <*> pada keypad. Beberapa tombol tersebut dilambangkan dalam konstanta sebagai berikut. Khusus untuk keypad, apabila tombol <+> ditekan, maka selain keyCode berisi SWT.KEYPADD_ADD, character juga berisi '+'. SWT.F 1 SWT.F 2 SWT.F 3 SWT.F 4 SWT.F 5

SWT.F11

SWT.PAGE_DOWN

SWT.F12

SWT.HOME

SWT.F13

SWT.END

SWT.F14

SWT.INSERT

SWT.F15

SWT.F SWT.ARROW_U 6

P

SWT.KEYPA SWT.KEYPAD_EQ D_0 SWT.KEYPA D_1 SWT.KEYPA D_2 SWT.KEYPA D_3

SWT.KEYPAD_MULT SWT.KEYPA IPLY SWT.KEYPAD_ADD

D_4

OWN

RACT

SWT.KEYPAD_CR

SWT.HELP

SWT.CAPS_LOCK

SWT.NUM_LOCK

SWT.KEYPA SWT.SCROLL_LO D_5

SWT.F SWT.ARROW_D SWT.KEYPAD_SUBT SWT.KEYPA 7

UAL

D_6

CK SWT.PAUSE

SWT.F SWT.ARROW_LE SWT.KEYPAD_DECI SWT.KEYPA 8

FT

MAL

D_7

SWT.BREAK

SWT.F SWT.ARROW_RI SWT.KEYPAD_DIVID SWT.KEYPA SWT.PRINT_SCRE 9 SWT.F 10

GHT

E

SWT.PAGE_UP

SWT.KEYPAD_0

stateMask

D_8

EN

SWT.KEYPA D_9

berisi tombol sebelum tombol ditekan, yang biasanya , <Shift>, ,

. Pada kebanyakan keyboard hanya ada 3 tombol pertama, akan tetapi ada juga yang memiliki lebih dari 3 tombol. Tombol-tombol ini disebut tombol pengubah. SWT membuat tombol-tombol ini menjadi kode seperti stateMask SWT.MOD1

Penjelasan Tombol pengubah pertama ditekan (biasanya SWT.CONTROL pada Windows atau SWT.COMMAND pada Macintosh)

SWT.MOD2

Tombol pengubah kedua ditekan (biasanya SWT.SHIFT)

SWT.MOD3

Tombol pengubah ketiga ditekan (biasanya SWT.ALT)

SWT.MOD4

Tombol pengubah keempat ditekan (biasanya 0)

SWT.MODIFIER_MASK Gabungan dari keempatnya (menggunakan bitwise OR) Dengan representasi seperti ini, maka SWT bisa dijalankan pada beberapa platform, dan tidak bergantung dengan tombol apa yang ada pada suatu sistem operasi. Bayangkan jika Anda ingin menggunakan + untuk membuat karakter menjadi tebal, akan tetapi tombol tidak tersedia pada Macintosh. Untuk menguji tombol pengubah mana yang ditekan, kita bisa menggunakan bitwise AND, misalnya (e.stateMask & SWT.SHIFT). Berikut ini adalah contoh program pelacak keyboard yang akan melaporkan tombol apa yang Anda tekan dan lepaskan. Contoh program ini dapat Anda unduh di sini untuk mengimportnya ke dalam Eclipse. Jalankan program ini pada Eclipse, kemudian ketik apa saja di program Anda, perhatikan "Console" di Eclipse akan penuh dengan berbagai laporan tentang tombol yang ditekan dan dilepaskan.

Kadang kala dalam kondisi yang sangat langka, kita harus mengolah sendiri tombol kita sebelum diolah oleh suatu wudget. Karena SWT menggunakan widget bawaan sistem operasi, pengolahan tombol terjadi di level sistem operasi. Misalnya, ketika user mengetik pada widget teks, listener SWT.KeyDown akan dijalankan, kemudian sistem operasi akan memasukkan karakter dan menggambarnya kembali dijalankan oleh sistem operasi. Dengan menggunakan doit, kita bisa membuang karakter tersebut untuk tidak meneruskannya ke sistem operasi. Contoh berikut akan menghalangi user untuk memasukkan karakter pada widget teks dengan mengeset doit menjadi false setiap kali event SWT.KeyDown terjadi. package com.lyracc.penghalangtombol; import org.eclipse.swt.*; import org.eclipse.swt.widgets.*; public class PenghalangTombol { /** * @param args */ public static void main(String[] args) { Display display = new Display(); Shell shell = new Shell(display);

Text text = new Text(shell, SWT.SINGLE | SWT.BORDER); text.addListener(SWT.KeyDown, new Listener() { public void handleEvent(Event event) { event.doit = false; } }); text.pack(); shell.pack(); shell.open(); while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep(); display.dispose(); } }

Traversal Traversal atau penelusuran berarti memindahkan fokus dari satu kontrol ke kontrol lain. Tombol traversal berbeda dengan tombol akselerasi dan tombol sistem jendela (yang akan dibahas nanti), yaitu : Suatu kontrol bebas memilih apakah akan menjalankan operasi traversal atau mengolah tombol yang ditekan. Jika kontrol memilih untuk menjalankan operasi traversal maka tombol tersebut tidak akan diproses lebih lanjut. Ada dua jenis traversal, yaitu mnemonik dan tab. Traversal Mnemonik Mnemonik biasanya tertulis sebagai karakter yang diberi garis bawah pada label suatu widget. Suatu aksi akan dilakukan jika user menekan kombinasi tombol yang cocok dengan mnemonik tersebut, biasanya dengan menekan tombol bersamaan dengan karakter yang digaris bawah tersebut. Gambar berikut adalah contoh mnemonik pada program OpenOffice ketika kita membuka kotak dialog Format Font

Jika kita menekan + H maka tampilan Help akan ditampilkan. Menekan tombol kombinasi untuk memanggil mnemonik sama dengan mengaktifkan widget tersebut. Pada contoh di atas, mnemonik + H diterapkan pada tombol, yang artinya ketika kita menekan + H, sama dengan kita menekan tombol Help. Beberapa widget yang tidak bisa menerima pilihan, seperti label dan kotak grup masih bisa menerima mnemonik, akan tetapi fungsinya hanya untuk memindahkan fokus ke widget tersebut. Bagaimana caranya menambahkan mnemonik? Mudah saja. Cukup tambahkan '&' di depan karakter yang akan kita tandai sebagai mnemonik, kemudian masukkan string ini sebagai argumen pada metode setText() suatu widget. Misalnya pada perintah berikut : Button tombol1 = new Button(shell, SWT.PUSH); tombol1.setText("&Klik saya");

akan membuat tombol dengan mnemonik + K, seperti pada gambar berikut ini :

Untuk membuat mnemonik pada karakter '&' sendiri, gunakan '&&', misalnya "Ini && Itu" akan menghasilkan "Ini & Itu"

Traversal Tab Traversal tab didukung pada semua platform. Tidak seperti pada mnemonik, pada traversal tab, kita tidak perlu mendefinisikan apa-apa, karena setiap platform memiliki cara sendiri bagaimana memindahkan fokus dari satu widget ke widget lain. Misalnya, ketika kita menekan tombol , maka fokus akan otomatis pindah ke widget berikutnya. Ketika sampai pada widget terakhir, maka fokus akan diulang dari widget pertama. Nama traversal tab mungkin agak sedikit salah sasaran, karena sepertinya hanya tombol saja yang bisa digunakan untuk memindahkan fokus dari satu widget ke widget lain. Pada beberapa platform, menekan tombol panah juga memindahkan fokus. Beberapa tombol lain seperti <Esc> digunakan untuk menutup kotak dialog, dan sebenarnya termasuk dalam tombol traversal tab juga. Berikut ini adalah daftar event dan listener yang berkaitan dengan traversal. Kelas Event (event bertipe)

Interface/Kelas Listener (listener

Jenis Metode (listener bertipe)

event

(event tanpa Penjelasan tipe)

bertipe)

Navigasi TraverseEvent TraverseListener keyTraversed(TraverseEvent) SWT.Traverse

pada keyboard dideteksi

Berikut ini adalah isi event ketika event traversal terjadi. Nama Field Penjelasan detail

Detail traversal yang terjadi

doit

Suatu boolean yang bisa digunakan untuk membatalkan aksi traversal

detail

berisi salah satu dari nilai-nilai berikut.

isi detail

Penjelasan Traversal yang terjadi ditutupnya suatu kotak

SWT.TRAVERSE_ESCAPE

dialog, misalnya dengan menekan tombol Cancel atau tombol <Esc>

SWT.TRAVERSE_RETURN

Traversal yang terjadi ketika kotak dialog selesai diisi misalnya setelah menekan tombol

OK atau tombol <Enter> SWT.TRAVERSE_TAB_PREVIOUS

SWT.TRAVERSE_TAB_NEXT

SWT.TRAVERSE_ARROW_PREVIOUS

SWT.TRAVERSE_ARROW_NEXT SWT.TRAVERSE_MNEMONIC SWT.TRAVERSE_PAGE_PREVIOUS

SWT.TRAVERSE_PAGE_NEXT SWT.TRAVERSE_NONE

Traversal yang terjadi ketika fokus pindah ke group tab sebelumnya Traversal yang terjadi ketika fokus pindah ke group tab sesudahnya Traversal yang terjadi ketika fokus pindah ke item sebelumnya Traversal yang terjadi ketika fokus pindah ke item sesudahnya Traversal mnemonik terjadi Traversal yang terjadi ketika untuk pindah ke halaman sebelumnya pada kotak dialog Traversal yang terjadi ketika untuk pindah ke halaman berikutnya pada kotak dialog Traversal tidak terjadi

Variabel detail bukan hanya untuk dibaca akan tetapi kita juga bisa mengisinya apabila kita ingin mengubah jenis traversal. Misalnya kita ingin mengubah tombol <Enter> bukan untuk menutup dialog akan tetapi untuk memindahkan fokus ke widget lain, kita bisa mengisi variabel detail dengan SWT.TRAVERSE_ARROW_PREVIOUS. doit

digunakan untuk membatalkan traversal jika variabel ini diisi false. Akan tetapi lihat

bahwa pada variabel detail juga bisa SWT.TRAVERSE_NONE. Apa perbedaannya? Ingat bahwa tombol yang tidak digunakan untuk traversal akan diberikan kepada widget yang menerima traversal untuk diolah lebih lanjut. Artinya jika event doit kita isi dengan true, traversal akan dilakukan dan tombol akan "dikonsumsi" (tidak diberikan kepada widget untuk diproses kembali). Jika doit kita isi denga false, traversal tidak dilakukan dan tombol akan diberikan kepada widget untuk diproses. Apa yang terjadi jika detail juga diisi dengan SWT.TRAVERSE_NONE? Jika detail diisi dengan SWT.TRAVERSE_NONE maka widget tidak akan melakukan traversal, tidak peduli apakah isi doit berisi true atau false. Akan tetapi, variabel doit menentukan apakah tombol akan diberikan kepada widget untuk diproses.

Jadi jika doit berisi false dan detail berisi SWT.TRAVERSE_NONE, maka tombol akan diberikan kepada widget, dan traversal tidak dilakukan. Akan tetapi jika doit berisi true dan detail berisi SWT.TRAVERSE_NONE, maka traversal tidak dilakukan, dan tombol akan dikonsumsi dan tidak akan diberikan kepada widget. Berikut ini adalah contoh penggunaan traversal.

Program ini akan membuat 6 tombol. Coba tekan tombol . Fokus akan pindah ke tombol berikutnya setiap kali Anda menekan tombol . Ketika Anda melewati tombol 4 atau tombol 6, akan tercetak "Button {4} ditelusuri". Jika Anda menekan tombol <Shift> + fokus akan berpindah ke tombol sebelumnya. Akan tetapi jika Anda sampai pada tombol 4 atau tombol 6, event traversal yang terjadi akan ditangkap dan traversal akan diabaikan. Akibatnya Anda tidak akan bisa pindah dari tombol 4 ke tombol 3 atau tombol 6 ke tombol 5. Pada saat yang sama di konsol akan tercetak "Anda tidak bisa kembali!". Program lengkapnya adalah sebagai berikut, yang bisa diunduh di sini. package com.lyracc.traversalkustom; import org.eclipse.swt.*; import org.eclipse.swt.widgets.*; import org.eclipse.swt.events.*;

public class TraversalKustom { /** * @param args */ public static void main(String[] args) { Display display = new Display(); Shell shell = new Shell(display); shell.setSize(300, 200); Button b1 = new Button(shell, SWT.PUSH); Button b2 = new Button(shell, SWT.PUSH); Button b3 = new Button(shell, SWT.PUSH); Button b4 = new Button(shell, SWT.PUSH); Button b5 = new Button(shell, SWT.PUSH); Button b6 = new Button(shell, SWT.PUSH); b1.setBounds(10,10,50,50); b2.setBounds(100,10,50,50); b3.setBounds(200,10,50,50); b4.setBounds(10,100,50,50); b5.setBounds(100,100,50,50); b6.setBounds(200,100,50,50); b1.setText("1"); b2.setText("2"); b3.setText("3"); b4.setText("4"); b5.setText("5"); b6.setText("6"); TraverseListener traverseListener = new TraverseListener() { public void keyTraversed(TraverseEvent e) { if (e.detail == SWT.TRAVERSE_TAB_PREVIOUS) { System.out.println("Anda tidak bisa kembali!"); e.doit = false; } System.out.println(e.widget + " ditelusuri"); } }; b4.addTraverseListener(traverseListener); b6.addTraverseListener(traverseListener);

shell.open(); while (!shell.isDisposed()) if (!display.readAndDispatch()) display.sleep(); display.dispose(); } }

Tombol Akselerator dan Tombol Sistem Jendela Tombol Akselerator Akselerator adalah tombol shortcut ke salah satu menu, misalnya pada kebanyakan program pengolah kata menekan tombol dan S artinya menyimpan teks yang sedang diedit. Akselerator biasanya berupa rangkaian tombol yang ditekan bersamaan, bisa 2 tombol seperti contoh di atas atau mungkin lebih, misalnya pada Firefox, tombol + <Shift> + J membuka konsol kesalahan (error console). Akselerator selalu berhubungan dengan menu, sehingga akselerator bersifat global, yang berarti kita bisa menekan tombol akselerator dari dalam widget manapun yang sedang aktif pada saat itu. Ketika akselerator dipanggil, maka tombol-tombol yang ditekan akan dikonsumsi langsung oleh aplikasi dan tidak diberikan kepada widget apa-apa. Akselerator direpresentasikan pada SWT dalam bentuk kode integer tertentu. Kode integer tersebut berisi gabungan beberapa tombol, yaitu tombol pengubah (seperti , <Shift>, ) dan satu tombol lain yang berupa karakter atau keyCode (seperti tanda panah, F1 hingga F15, <Esc>, dll). Lihat bahasan tentang fokus kontrol untuk mengerti lebih jauh tentang bagaimana penanganan tombol pada SWT. Tombol akselerator tidak bisa hanya terdiri dari tombol pengubah saja. Berikut ini adalah beberapa contoh akselerator. Akselerator

Rangkaian Tombol

SWT.CONTROL + 'A'

+

SWT.SHIFT SWT.ARROW_UP SWT.MOD1 + 'S'

+

<Shift> + tombol panah ke atas Tombol

pengubah

pertama

(biasanya



atau

) + <S>

SWT.MOD1 + SWT.MOD2 + Tombol pengubah pertama + Tombol pengubah kedua + 'B'



Akselerator diberikan kepada menu atau toolbar dengan menggunakan metode setAccelerator(int

kodeAkselerator)

di mana kodeAkselerator adalah kode

akselerator seperti dicontohkan pada tabel di atas. Untuk mereset akselerator, isi kodeAkselerator

dengan 0.

Untuk mengambil tombol akselerator suatu menu atau toolbar bisa digunakan dengan menggunakan metode getAccelerator() yang mengembalikan nilai integer. Misalnya jika item adalah suatu item pada menu, maka potongan kode berikut akan menambahkan akselerator pada item tersebut : item.setText("Pilih &Semua\tCtrl+S"); item.setAccelerator(SWT.MOD1 + 'S'); item.addListener(SWT.Selection, new Listener() { public void handleEvent(Event e) { System.out.println("Item dipilih."); } });

Karakter '\t' di dalam setText memberi tahu SWT bahwa karakter setelah itu adalah tombol akseleratornya. Perlu dicatat bahwa hanya menambahkan teks akselerator pada metode setText() tidak membuat tombol akselerator otomatis ditambahkan dalam metode setAccelerator(). Menambahkan teks akselerator pada setText() berfungsi untuk membetulkan kesalahan yang terjadi jika tombol akselerator tidak terdapat pada platform yang dituju. Misalnya pada contoh di atas, tombol tidak ada pada Macintosh, akan tetapi SWT akan mengganti tampilan Ctrl-S menjadi

-S.

Tombol Sistem Jendela Tombol yang diproses oleh sistem jendela tidak akan sampai pada aplikasi kita. Misalnya, tombol Alt-F4 pada beberapa sistem akan menutup jendela yang aktid. Manager jendela akan melakukan aksi terlebih dahulu dan tombol tersebut akan dikonsumsi oleh manager jendela. Manager jendela tidak sama dengan sistem operasi. Pada Windows, manager jendela itu terintegrasi dengan sistem operasi. Pada Linux misalnya manager jendela bisa bermacam-macam, misalnya KDE dan Gnome. Tombol-tombol mana yang akan dimanage oleh manager jendela berbeda-beda, tergantung dari sistem jendela tersebut. Karena tidak adanya kesamaan pada setiap manager jendela, maka kita tidak bisa mencegat penekenan tombol ini misalnya dialihkan untuk melakukan fungsi lain.