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.Orang didefisikan sebagai :class Orang { String nama; int nomorID; Date tanggalLahir; int umur; }
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 berikutvariabel_array [ekspresi_integer]
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;
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];
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
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 adalah variabel bertipe int, maka daftar[idks] dan daftar[2*idks+3] 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] ); }
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];
daftar merupakan variabel lokal dalam subrutin, maka perintah di atas akan persis sama dengan dua perintah :int[] daftar; daftar = new int[5];
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 };
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 };
new seperti ini adalahnew TipeDasar [ ] { daftar_nilai_nilai }
TipeDasar dipentingkan. Misalnya buatTombol merupakan metode yang mengambil array String sebagai parameter, maka kita bisa menuliskanbuatTombol( new String[] { "Stop", "Jalan", "Berikut", "Sebelum" } );Catatan terakhir : untuk alasan sejarah, maka deklarasi
int[] daftar;
int daftar[];
int[]. Akan lebih masuk akan untuk mengikuti siintaks "nama_tipe nama_variabel" seperti pada bentuk bertama.Array Dinamis
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
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]; // Hingga 10 pemain. int jumlahPemainAktif = 0; // Di awal game, tidak ada pemain yang aktif
jumlahPemainAktif akan lebih dari 0, dan objek pemailn akan disimpan dalam array, misalnya ArrayPemain[0], ArrayPemain[1], ArrayPemain[2], dan seterusnya. Ingat bahwa pemain ArrayPemain[jumlahPemainAktif] 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++;
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--;
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 sepertifor (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 berikutBentukGeometri[] 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(); // parameter di sini int jmlGambar = 3; // Lacak jumlah objek di dalam array
BentukGeometri memiliki metode "void gambarUlang(Graphics g)" untuk menggambar pada grafik g, maka semua grafik dalam array bisa digambar dengan perulangan sederhanafor (int i = 0; i < jmlGambar; i++) gambar[i].gambarUlang(g);
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 DinamisDalam 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; // Ukuran array baru Pemain[] temp = new Pemain[ukuranBaru]; // 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
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
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. Referensi ke bilangan[i] diganti dengan bilangan.get[i]. 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
Bersambung............
Tidak ada komentar:
Posting Komentar