KATA PENGANTAR Puji Syukur kehadirat Allah SWT, atas rahmat, taufiq dan hidayah-Nya penyusunan modul struktur data ini dapat terselesaikan. Modul Struktur data ini disusun menyesuaikan dengan SAP (Satuan Acara Perkuliahan) dan GBPP (Garis Besar Program dan Pengajaran) program studi D3 Manajemen Informatika Universitas Trunojoyo. Pembahasan Modul ini meliputi : Memulai pemrograman java , Dasar pemrograman Java , Seleksi, Perulangan dan Program Rekursif, Akses terhadap kelas dan unsur pewarisan , Array,vector & Matrix , Sorting & Searching, Stack, Queue, Collections,Arraylist, Set, Singly Linked List & Doubly Linked List, Tree, Hash Table , Graph Semoga dengan tersusunnya modul praktikum struktur data ini, mahasiswa dapat lebih memahami dan mampu membuat program JAVA dengan struktur data yang lebih baik Bangkalan, 12 Mei 2010
Penyusun
1
DAFTAR ISI Kata Pengantar ......................................................................................................... 1 Daftar Isi .................................................................................................................. 2 Memulai Pemrograman Java .................................................................................... 3 Dasar-Dasar Pemrograman Java .............................................................................. 4 Seleksi .................................................................................................................... 11 Perulangan Dan Program Rekursif ........................................................................ 17 Akses Terhadap Kelas Dan Unsur Pewarisan ........................................................ 25 Array, Vector Dan Matrix ...................................................................................... 36 Sorting Dan Searching ........................................................................................... 42 Stack, Queue, Collections,Arraylist, Set ................................................................ 53 Singly Linked List & Doubly Linked List ............................................................. 67 Tree ........................................................................................................................ 82 Hash Table ............................................................................................................. 89 Graph ................................................................................................................... 101
2
MODUL 1 MEMULAI PEMROGRAMAN JAVA 1.
Tujuan •
2.
Dasar Teori • • •
3.
Console merupakan Tempat untuk menulis perintah(command), Contoh : Terminal (Linux) , MSDOS Command Prompt (Windows) Text Editor , Contoh : Notepad, Wordpad, Vi Integrated Development Environment (IDE) merupakan environment pemrograman yang terintegrasi pada aplikasi. IDE menyediakan developer GUI, text atau code editor, compiler/interpreter dan debugger.
Tugas Pendahuluan 1. 2.
4.
Membuat program java menggunakan text editor dan console
Jelaskan fitur-fitur teknologi Java seperti, Java Virtual Machine(JVM), garbage collection, dan code security. Jelaskan perbedaan fase-fase pada program Java.
Praktikum
Percobaan 1. Program Java pertama package Hello; public class Hello { public static void main(String[ ] args) { // TODO Auto-generated method stub System.out.print("Saya mau belajar pemrograman Java"); } }
5.
Tugas Praktikum
1. Berikan penjelasan setiap baris program dari percobaan 1 diatas 3
MODUL 2 DASAR-DASAR PEMROGRAMAN JAVA
1.
Tujuan a. b. c.
2.
Dasar Teori • •
3.
ADT merupakan kumpulan dari elemen-elemen data yang disajikan dengan satu set operasi yang digambarkan pada elemen-elemen data tersebut Keyword merupakan identifier khusus yang sudah disediakan oleh Java untuk tujuan tertentu.
Tugas Pendahuluan 1. 2.
4.
Memahami konsep ADT (Abstract Data Type) Memahami Class dan Object Memahami Kata-kata kunci (keyword) dan operator-operator pada Java
Apa yang dimaksud dengan kelas dan object. Berikan contoh Apa yang dimaksud dengan Java literal, tipe data primitif, tipe variabel, identifier dan operator. Berikan contoh
Praktikum
Percobaan 1a. Program class Mobil ; Package Mobil_1 package Mobil_1; public class Mobil { private String Warna; private int Jumlah_Pintu; private double Isi_Tangki;
4
public Mobil() { super(); } public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) { super(); Warna = warna; Jumlah_Pintu = jumlah_Pintu; Isi_Tangki = isi_Tangki; } public String getWarna() { return Warna; } public void setWarna(String warna) { Warna = warna; } public static int Maju(int maju) { int majukedepan = 0; majukedepan = majukedepan + maju; return (majukedepan); } public int Mundur(int mundur) { int mundurbelakang = 0; mundurbelakang = mundurbelakang + mundur; return (mundurbelakang); } public int getJumlah_Pintu() { return Jumlah_Pintu; } public void setJumlah_Pintu(int jumlah_Pintu) { Jumlah_Pintu = jumlah_Pintu; } public double getIsi_Tangki() { return Isi_Tangki; } 5
public void setIsi_Tangki(float isi_Tangki) { Isi_Tangki = isi_Tangki; } }
Percobaan 1b. Program class TestDrive1; package Mobil_1 package Mobil_1; public class TestDrive1 { public static void main(String[] args) { System.out.println("Mobil maju sejauh " + Mobil.Maju(25) + " meter"); } }
Percobaan 2a. Program class Mobil, package Mobil_2 package Mobil_2; public class Mobil { public String Warna; private int Jumlah_Pintu; private double Isi_Tangki;
public Mobil() { super(); } public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) { super(); Warna = warna; Jumlah_Pintu = jumlah_Pintu; Isi_Tangki = isi_Tangki; } public String getWarna() { return Warna; 6
} public void setWarna(String warna) { Warna = warna; } public int Maju(int maju) { int majukedepan = 0; majukedepan = majukedepan + maju; return (majukedepan); } public int Mundur(int mundur) { int mundurbelakang = 0; mundurbelakang = mundurbelakang + mundur; return (mundurbelakang); } public int getJumlah_Pintu() { return Jumlah_Pintu; } public void setJumlah_Pintu(int jumlah_Pintu) { Jumlah_Pintu = jumlah_Pintu; } public double getIsi_Tangki() { return Isi_Tangki; } public void setIsi_Tangki(float isi_Tangki) { Isi_Tangki = isi_Tangki; } }
Percobaan 2b. Program class TestDrive2, package Mobil_2
package Mobil_2; public class TestDrive2 { 7
public static void main(String[] args) { Mobil mobilku = new Mobil(); mobilku.Warna = "merah"; System.out.println ("Mobilku yang berwarna " + mobilku.Warna + " mundur sebanyak " + mobilku.Mundur(15) + " meter"); } }
Percobaan 3a. Program class Mobil, package Mobil_3 package Mobil_3; public class Mobil { private String Warna; private int Jumlah_Pintu; private double Isi_Tangki;
public Mobil() { super(); } public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) { super(); Warna = warna; Jumlah_Pintu = jumlah_Pintu; Isi_Tangki = isi_Tangki; } public String getWarna() { return Warna; } public void setWarna(String warna) { Warna = warna; } public int Maju(int maju) { int majukedepan = 0; majukedepan = majukedepan + maju; 8
return (majukedepan); } public int Mundur(int mundur) { int mundurbelakang = 0; mundurbelakang = mundurbelakang + mundur; return (mundurbelakang); } public int getJumlah_Pintu() { return Jumlah_Pintu; } public void setJumlah_Pintu(int jumlah_Pintu) { Jumlah_Pintu = jumlah_Pintu; } public double getIsi_Tangki() { return Isi_Tangki; } public void setIsi_Tangki(float isi_Tangki) { Isi_Tangki = isi_Tangki; } } Percobaan 3b. Program class TestDrive3, package Mobil_3
package Mobil_3; import Mobil_3.Mobil;
public class TestDrive3 { public static void main(String[] args) { Mobil mobil_Adi = new Mobil("Merah", 4, 7.5); System.out.println ("Mobilku yang berwarna " + mobil_Adi.getWarna() + " maju sebanyak " + mobil_Adi.Maju(125) + " meter" + " dan menghabiskan bensin " + mobil_Adi.getIsi_Tangki() + " liter bok!"); } } 9
5.
Tugas Praktikum
1.
Diberikan table dibawah ini, deklarasikan variable yang terdapat didalamnya dengan tipe data yang sesuai dan berikan inisialisasi. Tampilkan hasil outputnya yaitu nama variable dan nilainya Variable name Number Letter Result Str
2.
Data tipe integer character boolean String
Initial value 10 a true hello
Berikut ini merupakan tampilan yang diharapkan sebagai hasil eksekusi program : number = 10 letter = a result = true str = hello Buatlah program yang menghasilkan output nilai rata-rata dari tiga angka. Nilai dari masing-masing tiga angka tersebut adalah 10, 20 dan 45. Tampilan output yang diharapkan adalah : number 1 = 10 number 2 = 20 number 3 = 45 Average is = 25
3.
Diberikan tiga angka, tuliskan program yang menghasilkan output angka dengan nilai terbesar dari tiga angka tersebut. Gunakan operator kondisi ?: (Anda akan memerlukan dua operator ?: ) . Sebagai contoh , diberikan angka 10, 23 dan 5. Program Anda akan menghasilkan output : number 1 = 10 number 2 = 23 number 3 = 5 Nilai tertingginya adalah angka = 23
4.
Diberikan pernyataan berikut, tulis kembali soal tersebut dengan menambahkan tanda kurung pada urutan sesuai dengan bagaimana pernyataan tersebut akan dievaluasi. a/b^c^d–e+ f–g*h+i 3 * 10 * 2 /15 – 2 + 4 ^ 2 ^ 2 r ^ s * t / u – v + w ^ x – y++ 10
MODUL 3 SELEKSI 1.
Tujuan • Mampu membuat program menerima input dari keyboard • Memahami pernyataan IF • Memahami pernyataan Nested IF (IF bersarang) • Memahami switch...case
2.
Dasar Teori • Terdapat dua cara untuk mendapatkan input: menggunakan class BufferedReader, lewat console menggunakan class JOptionPane , GUI(graphical user interface) • IF, Nested IF dan switch case merupakan bagian dari Struktur kontrol keputusan, yang digunakan untuk memilih bagian dari code yang akan dieksekusi.
3.
Tugas Pendahuluan 1.
4.
Jelaskan penggunaan class BufferedReader dan class JOptionPane untuk mendapatkan input dari keyboard. Berikan masing-masing contoh program sederhana yang menggunakan class-class tersebut
Praktikum
Percobaan 1. Input dari keyboard
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class IF { public static void main (String[] args) { System.out.println("Masukkan bilangan Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); 11
} catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); if (Data > 5) System.out.print ("Angka yang anda masukkan lebih besar dari 5"); } } Percobaan 2. Pernyataan IF import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class IF_ELSE { public static void main (String[] args){ System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); if (Data > 5) System.out.print ("Angka yang anda masukkan lebih besar dari 5"); else System.out.print ("Angka yang anda masukkan lebih kecil dari 5"); } } Program 3. Pernyataan Nested IF import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class Nested_IF { public static void main(String[] args) { 12
System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); if (Data > 5) if (Data%2==0)System.out.println("Angka yang anda masukkan lebih besar dari 5 dan genap."); else System.out.println("Angka yang anda masukkan lebih besar dari 5 dan ganjil."); else if (Data%2==0)System.out.println("Angka yang anda masukkan lebih kecil dari 5 dan genap."); else System.out.println("Angka yang anda masukkan lebih kecil dari 5 dan ganjil."); } } Percobaan 4. Program AND import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class ProgramAND { public static void main(String[] args) { System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); 13
if ((Data%2==0) && (Data%3==0)) System.out.println("Bilangan yang anda masukkan adalah kelipatan 2 dan kelipatan 3."); else System.out.println("Bilangan yang anda masukkan bukan kelipatan 2 dan kelipatan 3."); } } Percobaan 5. Program OR import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class ProgramOR { public static void main(String[] args) { System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); if ((Data%2==0) || (Data%3==0)) System.out.println("Bilangan yang anda masukkan adalah kelipatan 2 atau kelipatan 3."); else System.out.println("Bilangan yang anda masukkan bukan kelipatan 2 atau kelipatan 3."); } }
public class MultipleAction { public static void main(String[] args) { System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); if (Data > 10) { double Dataku = Data / 5.0; System.out.println ("Data yang Anda masukkan " + Data + " dan hasil baginya dengan 5 adalah " + Dataku); } } }
Percobaan 7. Switch Case import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class switch_case { public static void main(String[] args) { System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String hurufInput = null; try { hurufInput = bfr.readLine(); 15
} catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(hurufInput).intValue(); switch (Data) { case 4 : System.out.println("Kiri"); break; case 6 : System.out.println("Kanan"); break; case 8 : System.out.println("Atas"); break; case 2 : System.out.println("Bawah"); break; default : System.out.println("Masukkan nilai yang sah."); System.out.println("4, 6, 8, atau 2"); break; } }} 5.
Tugas Praktikum 1.
Ambil tiga nilai ujian dari user dan hitung nilai rata-rata dari nilai tersebut. Berikan output rata-rata dari tiga nilai ujian. Berikan juga smiley face pada output jika nilai rata-rata lebih besar atau sama dengan 60, selain itu beri output :-( a. Gunakan BufferedReader untuk mendapatkan input dari user, dan System.out untuk output hasilnya. b. Gunakan JOptionPane untuk mendapatkan input dari user dan output hasilnya
2.
Ambil sebuah angka sebagai input dari user, dan outputnya berupa kata yang sesuai dengan angka. Angka yang dimasukkan antara 1-10. Jika user memasukkan nilai yang tidak sesuai berikan output “Invalid number”. a. Gunakan statement if-else untuk menyelesaikan b. Gunakan statement switch untuk menyelesaikan 16
MODUL 4 PERULANGAN DAN PROGRAM REKURSIF 1.
Tujuan • •
2.
Dasar Teori • •
3.
Struktur kontrol perulangan digunanakan untuk mengeksekusi bagian tertentu sesuai dengan jumlah angka pengulangannya. Sifat- sifat Rekursif • Dapat digunakan ketika inti dari masalah terjadi berulang kali • Sedikit lebih efisien dari iterasi tapi lebih elegan • Method-methodnya dimungkinkan untuk memanggil dirinya sendiri • Data yang berada dalam method tersebut seperti argument disimpan sementara kedalam stack sampai method pemanggilnya diselesaikan
Tugas Pendahuluan 1. 2.
4.
Memahami perulangan (loop) dengan Java Memahami fungsi Rekursif
Jelaskan beberapa struktur kontrol perulangan yang ada Jelaskan perbedaan Rekursif dan Iterasi
Praktikum
Percobaan 1. Program loop_while import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class loop_while { public static void main(String[] args) { System.out.println("Masukkan angka Anda : "); 17
BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); int i=1; while (i <= Data) { System.out.println("Bilangan " + i); i++; } } }
Percobaan 2. Program loop_do_while import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class loop_do_while { public static void main(String[] args) { int Data; do { System.out.print("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } Data = Integer.valueOf(angkaInput).intValue(); } while (Data != 99); System.out.println("Anda keluar dari LOOP"); 18
} }
Percobaan 3. Program loop_for import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class loop_FOR { public static void main(String[ ] args) { System.out.println("Masukkan angka Anda : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); for(int ulang = 1; ulang<=Data; ulang++) { System.out.println("Bilangan : " + ulang); } } }
Percobaan 4. program nestedloop import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class nestedLOOP { public static void main(String[] args) { int ulang = inputData(); buatSegitiga(ulang); } private static int inputData() { 19
System.out.print("Masukkan jumlah segitiga yang Anda mau : "); BufferedReader bfr = new BufferedReader (new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } private static void buatSegitiga(int ulang) { for (int i=1; i<=ulang; i++) { for (int j=1; j<=(ulang-i); j++) { System.out.print(" "); } for(int k=1; k<=i; k++){ System.out.print("#"); } System.out.println(""); } } }
Percobaan 5. Program TryCatch public class ProgramDenganTryCatch { public static void main(String args[]) { int[] myArray = new int[10]; try { System.out.println("Sebelum pemberian nilai yang sah"); myArray[0] = 1; System.out.println("Sebelum pemberian yang tidak sah"); // Kode penyeModul kesalahan (exception). myArray[100] = 1; System.out.println("Setelah exception array"); 20
Percobaan 6. Program BagidenganNol public class BagiDenganNol { public static void main(String[ ] args) { int bilangan = 100; System.out.println("Sebelum pembagian"); for(int i=5; i>=0; i--) { try { System.out.print (bilangan + " / " + i + " = "); System.out.println(bilangan/i); } catch(RuntimeException r){ System.out.println( "Error karena pembagian nol!"); } finally { System.out.println ("Bagian finally dijalankan"); } } System.out.println("Selesai"); } }
Percobaan 7 Program Rekursif Segitiga Phytagoras import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class RekursifSegitigaPhytagoras { public static void main(String[] args) { 21
System.out.print("Masukkan tinggi segitiga Phytagoras : "); final int tinggi = inputData(); triangle(tinggi); } private static int triangle(int n) { int bilangan = 0; if (n == 1) { bilangan = 1; System.out.println("Bilangan ke-" + n + " adalah " + bilangan); return bilangan; } else { bilangan = n + triangle(n - 1); System.out.println("Bilangan ke-" + n + " adalah " + bilangan); } return (bilangan); } private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } }
Percobaan 8. Program RekursifFaktorial import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class RekursifFaktorial { 22
public static void main(String[ ] args) { System.out.print("Masukkan bilangan yang akan diFAKTORIAL-kan : "); final int bilangan = inputData( ); System.out.print("Faktorial dari " + bilangan + " adalah " + faktorial(bilangan)+ ". Mudah kan?"); } private static int faktorial(int bilangan) { if (bilangan == 0) return 1; else bilangan = bilangan * faktorial(bilangan - 1); return bilangan; } private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } }
Percobaan 9. Hanoi Rekursif class HanoiRekursif { static int nDisks = 4; public static void main(String[] args) { doTowers(nDisks, 'A', 'B', 'C'); } 23
public static void doTowers(int topN, char from, char inter, char to) { if(topN==1) System.out.println("Disk 1 dari " + from + " ke "+ to); else { doTowers(topN-1, from, to, inter); // dari --> media tengah. System.out.println("Disk " + topN + " dari " + from + " ke "+ to); doTowers(topN-1, inter, from, to); // media tengah --> ke } } } // Akhir kelas HanoiRekursif
5.
Tugas Praktikum 1. 2.
3.
Buat sebuah program yang mencetak nama Anda selama seratus kali. Buat tiga versi program ini menggunakan while loop, do while dan for loop Hitung pangkat sebuah nilai berdasarkan angka dan nilai pangkatnya. Buat tiga versi dari program ini menggunakan while loop, do while dan for loop Buat program AnagramRekursif , output diharapkan sebagai berikut :
24
MODUL 5 AKSES TERHADAP KELAS DAN UNSUR PEWARISAN 1.
Tujuan • • •
2.
Dasar Teori •
3.
Visibility adalah cara bagaimana suatu data/atribut serta fungsi/metoda yang dimiliki suatu kelas/objek dapat diakses dari kelas-kelas/bjek-objek lain. Contoh : public, private, protected, default
Sebutkan perbedaan public, private, protected dan default Apa yang dimaksud dengan pewarisan (inheritance) ? Berikan contoh
Praktikum
Percobaan 1a. package Big_Cat; class Big_Cat package bigCat; // Kelas abstrak public abstract class Big_Cat { protected static String name; protected abstract void eat(); } // Kelas turunan class Lion extends Big_Cat { // Kostruktor untuk kelas Lion public Lion (String nameLion) { // Mengisi peubah yang diwarisi dari kelas abstrak Lion.name = nameLion; 25
} // Implementasi metoda yang diwarisi dari kelas abstrak public void eat() { System.out.println("Lion can eat meat."); } } //Kelas turunan class Tiger extends Big_Cat { // Kostruktor untuk kelas Lion public Tiger (String nameTiger) { // Mengisi peubah yang diwarisi dari kelas abstrak Tiger.name = nameTiger; } // Implementasi metoda yang diwarisi dari kelas abstrak public void eat() { System.out.println("Tiger can eat meat and drink milk."); } } //Kelas turunan class Cat extends Big_Cat { // Kostruktor untuk kelas Lion public Cat (String nameCat) { // Mengisi peubah yang diwarisi dari kelas abstrak Cat.name = nameCat; } // Implementasi metoda yang diwarisi dari kelas abstrak public void eat() { System.out.println("Cat can eat meat, drink milk, and sometimes rice."); } }
Percobaan 1b. package bigCat class TestBigCat package bigCat; 26
public class TestBigCat { public static void main(String[] args) { // Memanfaatkan kelas Lion Lion myLion = new Lion("Simba"); System.out.println("My lion is " + Lion.name); myLion.eat(); // Memanfaatkan kelas Tiger Tiger myTiger = new Tiger("Harimau"); System.out.println("My tiger is " + Tiger.name); myTiger.eat(); // Memanfaatkan kelas Cat Cat myCat = new Cat("Kucingku manis"); System.out.println("My cat is " + Cat.name); myCat.eat(); } } Percobaan 2a. package bigCatNoOverload class BigCatNoOverload package bigCatNoOverload; public class Big_Cat_NoOverload { protected static String name; protected void eat() { System.out.println("Semua kucing besar makan daging!"); } } //Kelas turunan class WildLion extends Big_Cat_NoOverload { // Kostruktor untuk kelas Lion public WildLion (String nameLion) { // Mengisi peubah yang diwarisi dari kelas abstrak WildLion.name = nameLion; } } //Kelas turunan class WildTiger extends Big_Cat_NoOverload { // Kostruktor untuk kelas Lion public WildTiger (String nameTiger) { 27
// Mengisi peubah yang diwarisi dari kelas abstrak WildTiger.name = nameTiger; } } //Kelas turunan class WildCat extends Big_Cat_NoOverload { // Kostruktor untuk kelas Lion public WildCat (String nameCat) { // Mengisi peubah yang diwarisi dari kelas abstrak WildCat.name = nameCat; } }
Percobaan 2b. package bigCatNoOverload class TestNoOverload package bigCatNoOverload;
public class Test_NoOverload { public static void main(String[] args) { // Memanfaatkan kelas Lion WildLion myLion = new WildLion("Simba"); System.out.println("My lion is " + WildLion.name); myLion.eat(); // Memanfaatkan kelas Tiger WildTiger myTiger = new WildTiger("Harimau"); System.out.println("My tiger is " + WildTiger.name); myTiger.eat(); // Memanfaatkan kelas Cat WildCat myCat = new WildCat("Kucingku manis"); System.out.println("My cat is " + WildCat.name); myCat.eat(); } }
Percobaan 3a. package KucingGarong class Coba_Akses1 28
package KucingGarong; class Coba_Akses1 { public static void main (String[] args) { Kucing kucingku = new Kucing(); // Mengisi peubah instan. kucingku.Isi_Identitas("Pussy", "Belang", 10); // Menampilkan nama kucing melalui metoda. System.out.println("Nama : " + kucingku.ambilNama()); // Menampilkan nama kucing lewat peubah. System.out.println("Nama : " + kucingku.Nama); } }
Percobaan 3b. package KucingGarong class Kucing
package KucingGarong; class Kucing { String Nama; String Warna; int Berat; // Metoda void Isi_Identitas (String namaKucing, String warnaKucing, int beratKucing) { Nama = namaKucing; Warna = warnaKucing; Berat = beratKucing; } String ambilNama() { return Nama; } String ambilWarna() { 29
return Warna; } int ambilBerat() { return Berat; } } Percobaan 4a. package MySweetyCat class Coba_Akses2 package MySweetyCat; class Coba_Akses2 { public static void main (String[] args) { Kucingku_Manis kucingku = new Kucingku_Manis(); // Mengisi peubah instan. kucingku.Isi_Identitas("Pussy", "Belang", 10); // Menampilkan nama kucing melalui metoda. System.out.println("Nama : " + kucingku.ambilNama()); // Menampilkan nama kucing lewat peubah. System.out.println("Nama : " + kucingku.Nama); } } Percobaan 4b. Package MySweetyCat class Kucingku_Manis package MySweetyCat; class Kucingku_Manis { String Nama; private String Warna; private int Berat; // Metoda void Isi_Identitas (String namaKucing, String warnaKucing, int beratKucing) { Nama = namaKucing; Warna = warnaKucing; Berat = beratKucing; } 30
String ambilNama() { return Nama; } String ambilWarna() { return Warna; } int ambilBerat() { return Berat; } } Percobaan 5a. package OrangIndonesia class OrangIndonesia package OrangIndonesia; public class OrangIndonesia { protected String Nama; protected String Alamat; protected String Pekerjaan; public OrangIndonesia (String nama, String alamat, String pekerjaan) { super(); Nama = nama; Alamat = alamat; Pekerjaan = pekerjaan; } public String getNama() { return Nama; } public String getAlamat() { return Alamat; } public String getPekerjaan() { return Pekerjaan; } } class OrangBatak extends OrangIndonesia { private double Gaji; 31
public OrangBatak (String nama, String alamat, String pekerjaan) { super(nama, alamat, pekerjaan); } public double getGaji() { return Gaji; } public void setGaji(double gaji) { Gaji = gaji; } } class OrangJawa extends OrangIndonesia { private double Gaji; public OrangJawa (String nama, String alamat, String pekerjaan) { super(nama, alamat, pekerjaan); } public double getGaji() { return Gaji; } public void setGaji(double gaji) { Gaji = gaji; } } class OrangSumba extends OrangIndonesia { private double Gaji; public OrangSumba (String nama, String alamat, String pekerjaan) { super(nama, alamat, pekerjaan); } public double getGaji() { return Gaji; } public void setGaji(double gaji) { Gaji = gaji; } // Overloading Metoda public String hitungTHR (double persen){ 32
if (persen > 0.5) return "THR terlalu besar!"; else return "THR tahun ini sebesar " + persen * Gaji; } public String hitungTHR (int persen){ if (persen > 50) return "THR terlalu besar!"; else return "THR tahun ini sebesar " + (persen * Gaji / 100); } }
Percobaan 6a. package rumahAna package rumahAna; public interface Alamat { public abstract void aturNama(); public abstract void aturJalan (); public abstract void aturKota (); }
package rumahAna; import rumahAna.Alamat;
public class Apartemen implements Alamat{ public void aturKota() { System.out.println("Pekalongan."); 34
} public void aturJalan() { System.out.println("Jln. Hasanudin No. 8."); } public void aturNama() { System.out.println("Namaku : Ana Mariana"); } }
package rumahAna; public class RumahAna { public static void main(String[] args) { Apartemen rmhAna = new Apartemen(); rmhAna.aturNama(); rmhAna.aturJalan(); rmhAna.aturKota(); } } 5.
Tugas Praktikum 1.
Definisikan dengan bahasa Anda sendiri , istilah-istilah berikut ini : • Class • Object • Instantiate • Instance Variable • Instance Method • Class Variables atau static member variables • Constructor
35
MODUL 6 ARRAY, VECTOR DAN MATRIX 1.
Tujuan • • •
2.
Dasar Teori • •
3.
Mendeklarasikan dan membuat array, vector, matrix Mengakses elemen-elemen di dalam array, vector, matrix Menentukan jumlah elemen dalam sebuah array, vector, matrix
Array(larik) adalah variabel yang dapat menyimpan sebuah data list, kemudian memanipulasinya dengan lebih efektif. Matrix merupakan array multidimensi
Tugas Pendahuluan 1.
Buatlah sebuah string array yang akan menginisialisasi 7 hari dalam seminggu . Sebagai contoh
String days [ ] = {“Monday”, “Tuesday”...}; Gunakan while-loop, kemudian print semua nilai dari array (Gunakan juga untuk do-while dan for-loop)
4.
Praktikum
Percobaan 1. Program class LARIK import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class LARIK { static int[] Larik = new int[25]; static int ukuranLarik; public static void main(String[] args) { System.out.print("Berapa ukuran larik? "); 36
ukuranLarik = inputData(); for (int j=0; j
} } private static void tambahkanMatriks() { for (int i=0; i
Percobaan 3. Program class TestVector import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Vector; public class TestVector { static int ukuranVector; static Vector vector; public static void main(String[] args) { System.out.print("Berapa ukuran vector yang Anda mau? "); ukuranVector = inputData(); buatVector(); bacaData(); tulisData(); } // Metoda/fungsi untuk melakukan pembacaan. private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } // Metoda/fungsi untuk membuat Vector. private static void buatVector() { vector = new Vector(ukuranVector); } // Metoda/fungsi untuk membaca data dan // memasukkannya ke Vector. private static void bacaData() { 40
for (int i = 0; i < ukuranVector; i++) { System.out.print("Masukkan data ke-" + (i + 1) + " "); int data = inputData(); vector.add(data); } } // Metoda/fungsi menulis isi vector secara terbalik. private static void tulisData() { for (int j = ukuranVector - 1; j >= 0; j--) { System.out.println("Data ke " + (j + 1) + " = " + vector.get(j)); } } }
5.
Tugas Praktikum
1.
Gunakanlah BufferedReader dan JOptionPane, Tanyakan pada user untuk 10 nomor. Kemudian gunakan array untuk menyimpan 10 nomor tersebut. Tampilkan kepada user, input terbesar yang telah diberikan user Berikut ini adalah array multidimensi yang menyatakan isi dari sebuah buku alamat :
2.
String entry = { {“Florence”, “735-1234”,”Manila”}, {“Joyce”, “983-3333”, “Quezon City”}, {“Becca”,”456-3322”, “Manila”}}; Cetak buku alamat tersebut dalam format berikut ini : Name : Florence Telp : 735-1234 Address : Manila Name : Joyce Telp : 983-3333 Address : Quezon City Name : Becca Telp : 456-3322 Address : Manila 41
MODUL 7 SORTING DAN SEARCHING 1.
Tujuan • •
2.
Dasar Teori •
•
3. 1. a. b. c. d. e.
4.
Mengorganisasikan data dengan cara mengurutkan Mencari data-data yang telah terurut (sorted)
Pengurutan data dapat dilakukan secara urut naik (ascending) atau urut turun (decending), keuntungan dari data terurut adalah kemudahan dalam mencari data tertentu serta kemudahannya untuk dilakukan perbaikan, disisipi data yang baru, dihapus dan digabungkan. Pengurutan data terdapat beeberapa metode yaitu Bubble Sort, Selection Sort, Insertion Sort, ShellSort, Quick Short Pencarian elemen tertentu pada suatu vector yang telah terurut akan menjadi lebih efektif dan cepat dibandingkan dengan melakukan pencarian dalam vector yang belum terurut.
Tugas Pendahuluan Jelaskan dan beri contoh pengurutan data menggunakan metode : Bubble Sort Selection Sort Insertion Sort ShellSort Quick Short
import java.util.Vector; public class Data { private static int ukuranVector; private static Vector vector; private static boolean ketemu; public static void main(String[] args) { System.out.print("Berapa ukuran vector yang Anda mau? "); ukuranVector = inputData(); buatVector(); bacaData(); pengurutan(); tulisData(); System.out.println("Apakah Anda mau melakukan pencarian? "); System.out.print("Jika ya, masukkan data yang Anda cari, jika tidak ketik -99 : "); int cari = inputData(); if (cari != -99) cariData(cari); else System.out.println("Anda tidak mencari apa-apa. Thanks."); } private static void cariData(int cari) { System.out.println("Metoda apa yang akan digunakan untuk pencarian? "); System.out.println("1. Array Search"); System.out.println("2. Binary Search"); System.out.print("3. Vector Search (Masukkan pilihan Anda) : "); int metoda = inputData(); if (metoda == 3) { VectorSearch cnv = new VectorSearch(); ketemu = cnv.Search(cari); if (ketemu) { System.out.println("Data yang Anda cari " + cari + " ada di index Vector " + cnv.getHasil()); } else { System.out.println("Data yang Anda cari " + cari 43
+ " tidak ada di Vector. "); } } else if (metoda == 2) { Binary bnr = new Binary(); ketemu = bnr.Search(cari); if (ketemu) { System.out.println("Data yang Anda cari " + cari + " ada di index Vector " + bnr.getHasil()); } else { System.out.println("Data yang Anda cari " + cari + " tidak ada di Vector. "); } } else { ArraySearch ars = new ArraySearch(); ketemu = ars.Search(cari); if (ketemu) { System.out.println("Data yang Anda cari " + cari + " ada di index Vector " + ars.getHasil()); } else { System.out.println("Data yang Anda cari " + cari + " tidak ada di Vector. "); } } } private static void pengurutan() { int pilihan; System.out.println("Metoda pengurutan apa yang akan digunakan? "); System.out.println("1. BUBBLE SORT"); System.out.println("2. SELECTION SORT"); System.out.println("3. INSERTION SORT"); System.out.println("4. SHELL SHORT"); System.out.print("5. QUICK SORT (Masukkan nilai pilihan) : "); pilihan = inputData(); if (pilihan == 1) vector.addAll(Bubble.Sort(vector)); else if (pilihan == 2) vector.addAll(Selection.Sort(vector)); else if (pilihan == 3) vector.addAll(Insertion.Sort(vector)); 44
else if (pilihan == 4) vector.addAll(Shell.shellSort(vector)); else if (pilihan==5) vector.addAll(Quick.quickSort(vector)); } // Metoda/fungsi untuk melakukan pembacaan. private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } // Metoda/fungsi untuk membuat Vector. private static void buatVector() { vector = new Vector(ukuranVector); } // Metoda/fungsi untuk membaca data dan // memasukkannya ke Vector. private static void bacaData() { int data; for (int i = 0; i < ukuranVector; i++) { System.out.print("Masukkan data ke-" + (i + 1) + " : "); data = inputData(); vector.add(data); } } // Metoda/fungsi menulis isi vector. private static void tulisData() { System.out.println("\nData setelah diurutkan : "); for (int j = 0; j < ukuranVector; j++) { System.out.println("Data ke " + (j + 1) + " = " + vector.get(j)); 45
} } public static int getUkuranVector() { return ukuranVector; } public static Vector getVector() { return vector; } } Percobaan 2. Pengurutan dengan metoda Bubble Sort import java.util.Vector; public class Bubble { static Vector vectorBubble; public static Vector Sort(Vector vectorBubble) { int n = 0; int ukuran = Data.getUkuranVector(); while (n < ukuran) { for (int i = 1; i < ukuran; i++) { if (vectorBubble.get(i - 1) > vectorBubble.get(i)) { int temp = vectorBubble.get(i); vectorBubble.set(i, vectorBubble.get(i - 1)); vectorBubble.set(i - 1, temp); } } n++; } return vectorBubble; } } Percobaan 3. Pengurutan dengan metoda Selection Sort import java.util.Vector; 46
public class Selection { public static Vector Sort(Vector vectorSelection) { int i; int ukuran = Data.getUkuranVector(); int max; while (ukuran > 0){ max = 0; for(i=1; i Sort(Vector vectorInsertion) { int i=1; int index; int ukuran = Data.getUkuranVector(); while (i0; index--){ if (temp < vectorInsertion.get(index-1)){ vectorInsertion.set(index, vectorInsertion.get(index-1)); } else break; } vectorInsertion.set(index, temp); 47
i++; } return vectorInsertion; } } Percobaan 5. Pengurutan dengan Metoda Shell Sort import java.util.Vector; public class Shell { static int N; static int distance; static int j; static int i; static Vector vectorShell; public static Vector shellSort(Vector vectorShell) { N = Data.getUkuranVector(); distance = N / 2; while (distance > 0) { for (i = 0; i < N - distance; i++) { j = i + distance; if (vectorShell.get(i) > vectorShell.get(j)) { int temp = vectorShell.get(i); vectorShell.set(i, vectorShell.get(j)); vectorShell.set(j, temp); } } distance = distance / 2; } return vectorShell; } } Percobaan 6. Pengurutan dengan Metode Quick Sort import java.util.Vector; public class Quick { private static void swap(Vector vectorQuick, int left, int right) { int temp = vectorQuick.get(left); 48
vectorQuick.set(left, vectorQuick.get(right)); vectorQuick.set(right, temp); } public static Vector quickSort(Vector vectorQuick) { int ukuran = Data.getUkuranVector() - 1; quickSortRecursive(vectorQuick, 0, ukuran); return vectorQuick; } private static void quickSortRecursive(Vector vectorQuick, int left, int right) { int pivot; if (left >= right) return; pivot = partition(vectorQuick, left, right); quickSortRecursive(vectorQuick, left, pivot - 1); quickSortRecursive(vectorQuick, pivot + 1, right); } public static int partition(Vector vectorQuick, int left, int right) { while (true) { while ((left < right) && (vectorQuick.get(left) < vectorQuick.get(right))) right--; if (left < right) swap(vectorQuick, left, right); else return left; while ((left < right) && (vectorQuick.get(left) < vectorQuick.get(right))) left++; if (left < right) swap(vectorQuick, left, right--); else return right; } } } 49
Percobaan 7. Pencarian dengan Array Search import java.util.Vector; public class ArraySearch { int hasil; boolean ketemu = false; private Vector vectorArs; public boolean Search(int cari) { new Data(); int batas = Data.getUkuranVector(); vectorArs = new Vector(batas); vectorArs.addAll(Data.getVector()); int[] ArySearch = new int[batas]; for (int i = 0; i < (batas - 1); i++) { ArySearch[i] = vectorArs.get(i); } int index = 0; int value; while ((!ketemu) && (index < batas)) { value = ArySearch[index]; if (cari == value) { ketemu = true; hasil = index; break; } index++; } return ketemu; } public int getHasil() { return hasil + 1; } } Percobaan 8. Pencarian Binary Search 50
import java.util.Vector; public class Binary { int hasil; boolean ketemu = false; private Vector vectorBnr; public boolean Search(int cari) { new Data(); int ukuran = Data.getUkuranVector(); vectorBnr = new Vector(ukuran); vectorBnr.addAll(Data.getVector()); int[] ArrayBinary = new int[ukuran]; for (int i = 0; i < (ukuran -1); i++) { ArrayBinary[i] = vectorBnr.get(i); } int low = 0; int high = Data.getUkuranVector()-1; int mid = (low + high) / 2; int midValue; while (low < high) { midValue = ArrayBinary[mid]; if (midValue == cari) { ketemu = true; hasil = mid; break; } else { if (cari > midValue) low = mid + 1; else high = mid; } mid = (low + high) / 2; } return ketemu; } public int getHasil() { return hasil + 1; } } 51
Percobaan 9. Pencarian Vector Search import java.util.Vector; public class VectorSearch { int hasil; boolean ketemu = false; private Vector vectorCv; public boolean Search(Integer cari) { new Data(); vectorCv = new Vector(Data.getUkuranVector()); vectorCv.addAll(Data.getVector()); if (vectorCv.contains(cari)) { hasil = vectorCv.indexOf(cari) + 1; } return ketemu = true; } public int getHasil() { return hasil; } } 5.
Tugas Praktikum
1.
2.
Buat program dengan inputan NIM (empat digit terakhir), nama, dan fakultas untuk beberapa mahasiswa, kemudian lakukan sorting terhadap inputan berdasarkan NIMnya! Buat sebuah program database pabrik, merk, CC dan harga sepeda motor kemudian hasil tersebut bisa diurutkan berdasarkan harga dan CCnya (secara ascending dan descending)! Misal: Yamaha >> Mio >> 135CC >> 12.000.000 Honda >> Revo >> 100CC >> 13.000.000 Viar >> ViarX >> 125CC >> 7.000.000
52
MODUL 8 STACK, QUEUE, COLLECTIONS,ARRAYLIST, SET
1. •
Tujuan Memahami Abstrak Data Type (ADT) Statis yaitu Stack, Queue, Collections, ArrayList dan Set
2.
Dasar Teori
•
Stack (Tumpukan) dapat dibayangkan sebagai suatu keranjang dimana hanya dat terakhir yang dapat diperoleh kembali dengan satu langkah. Data di bawah hanya dapat diambil jika data di sebelah atasnya telah diambil (dikeluarkan) terlebih dahulu, sehingga struktur data ini dapat dikatakan LIFO (Last In First out). Queue (antrian) apada kenyataannya misal dijumpai pada antrian karcis untuk membeli tiket, berlaku konsep FIFO (First In First Out).
•
3.
Tugas Pendahuluan
1.
Jelaskan apa yang dimaksud dengan a. Stack b. Queue c. Collection d. ArrayList e. Set
4.
Praktikum
Percobaan 1. Program Tumpukan (Stack) package myStack; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Stack; public class Tumpukan { 53
private static Stack stack; private static int ukuran; public static void main(String[] args) { System.out.print("Berapa ukuran STACK diinginkan? "); ukuran = inputData(); buatStack(); bacaData(); tulisData(); } private static void tulisData() { System.out.println("Isi Stack adalah (menggunakan prosedur POP) : " ); int dataStack; for (int i = 0; i < ukuran; i++) { dataStack = stack.pop(); System.out.println ("Nilainya = " + dataStack); } } private static Integer inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } private static void bacaData() { int data; System.out.println("Masukkan nilai-nilai STACK : "); for (int i = 0; i < ukuran; i++) { System.out.print("Data ke-" + (i + 1) + " : "); data = inputData(); 54
stack.push(data); } } private static void buatStack() { stack = new Stack(); } } Percobaan 2. Solusi Rekursif untuk Stack package myStack; // Parameter-parameter yang akan disimpan di stack. public class Params { int n; int codePart; int returnAddress; Params(int nn, int ra) { n=nn; returnAddress = ra; } } // end class Params package myStack; public class StackX { int maxSize; // Ukuran array stack. Params[] stackArray; int top; // Bagian atas (top) stack //------------------------------------------------------------public StackX(int s) { maxSize = s; // Mengatur ukuran array. stackArray = new Params[maxSize]; // Membuat array. top = -1; // Saat stack kosong. } //------------------------------------------------------------// Menaruh item di atas stack. public void push(Params p) { 55
// Melakukan penambahan top; menyisipkan item. stackArray[++top] = p; } //------------------------------------------------------------// Mengambil item dari bagian atas (top) stack. public Params pop() { // Mengakses item, mengurangi nilai top. return stackArray[top--]; } //------------------------------------------------------------// Melihat item di bagian atas stack. public Params peek() { return stackArray[top]; } //------------------------------------------------------------} // end class StackX package myStack; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class StackTriangleApp { static int theNumber; static int theAnswer; static StackX theStack; static int codePart; static Params theseParams; public static void main(String[] args) throws IOException { System.out.print ("Masukkan bilangan segitiga Phytagoras : "); 56
System.out.flush(); theNumber = getInt(); recTriangle(); System.out.println ("Bilangan segitiga Phytagoras = "+ theAnswer); } // Akhir metoda/fungsi main() // ------------------------------------------------------------public static void recTriangle() { theStack = new StackX(50); codePart = 1; // Memanggil metoda step() hingga bernilai true. while( step() == false) // Pernyataan kosong. ; } // ------------------------------------------------------------public static boolean step() { switch(codePart) { case 1: // Pemanggilan awal. theseParams = new Params(theNumber, 6); theStack.push(theseParams); codePart = 2; break; case 2: // Jalan masuk metoda. theseParams = theStack.peek(); if(theseParams.n == 1) // Pengujian. { theAnswer = 1; codePart = 5; // Keluar (exit). } else codePart = 3; // Pemanggilan rekursif. break; case 3: // Pemanggilan metoda. Params newParams = new Params(theseParams.n - 1, 4); theStack.push(newParams); 57
codePart = 2; // Masuk ke metoda. break; case 4: // Perhitungan. theseParams = theStack.peek(); theAnswer = theAnswer + theseParams.n; codePart = 5; break; case 5: // Keluar (exit) metoda. theseParams = theStack.peek(); codePart = theseParams.returnAddress; // (4 atau 6) theStack.pop(); break; case 6: // Titik kembali. return true; } // end switch return false; // Semua kecuali 7 } // end triangle // ------------------------------------------------------------public static String getString() throws IOException { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); String s = br.readLine(); return s; } // ------------------------------------------------------------public static int getInt() throws IOException { String s = getString(); return Integer.parseInt(s); } // ------------------------------------------------------------} // end class StackTriangleApp
// stackTriangle.java // Mengevaluasi segitiga Phytagoras, stack menggantikan rekursion. 58
Percobaan 3. Program simulasi Stack dengan teknik Rekursif package myStack; public class StackX2 { int maxSize; // Ukuran array stack. int[] stackArray; int top; // Bagian atas (top) stack StackX2(int s) // constructor { maxSize = s; stackArray = new int[maxSize]; top = -1; } // Meletakkan item ke bagian atas (top) stack. public void push(int p) { stackArray[++top] = p; } // Mengambil item dari bagian atas (top) stack. public int pop() { return stackArray[top--]; } // Melihat item dari bagian atas (top) stack. public int peek() // peek at top of stack { return stackArray[top]; } // Menguji apakah stack kosong. public boolean isEmpty() { return (top == -1); } } // end class StackX package myStack; import java.io.BufferedReader; import java.io.IOException; 59
import java.io.InputStreamReader; public class StackTriangleApp2 { static int theNumber; static int theAnswer; static StackX2 theStack; public static void main(String[] args) throws IOException { System.out.print("Masukkan bilangan : "); System.out.flush(); theNumber = getInt(); stackTriangle(); System.out.println("Bilangan segitiga Phytagoras = " + theAnswer); } // end main() // ------------------------------------------------------------public static void stackTriangle() { theStack = new StackX2(10000); // Membuat stack theAnswer = 0; // Menginisialisasi theAnswer while (theNumber > 0) // Hingga n bernilai 1, { theStack.push(theNumber); // Memasukkan nilai. --theNumber; // Mengurangi nilai. } while (!theStack.isEmpty()) // Hingga stack kosong, { int newN = theStack.pop(); // Mengeluarkan (pop) nilai, theAnswer += newN; // Menambah nilai theAnswer } } // ------------------------------------------------------------public static String getString() throws IOException { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); String s = br.readLine(); return s; } // ------------------------------------------------------------public static int getInt() throws IOException { 60
String s = getString(); return Integer.parseInt(s); } } Percobaan 4. Queue (Antrian) package queue; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.LinkedList; import java.util.Queue; public class Antrian { private static int ukuran; private static Queue queue; public static void main(String[] args) { System.out.print("Berapa ukuran QUEUE diinginkan? "); ukuran = inputData(); buatQueue(); bacaData(); tulisData(); } private static void buatQueue() { queue = new LinkedList(); } private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } 61
private static void tulisData() { Integer data; System.out.println("\nUrutan keluar elemen dari QUEUE : "); for (int i = 0; i < ukuran; i++) { data = queue.remove(); System.out.println("Data ke-" + (i + 1) + " : " + data); } data = queue.size(); System.out.println("Ukuran QUEUE sekarang adalah " + data); } private static void bacaData() { Integer data; for (int i = 0; i < ukuran; i++) { System.out.print("Data ke-" + (i + 1) + " : "); data = inputData(); queue.add(data); } data = queue.size(); System.out.println("Ukuran QUEUE sekarang adalah " + data); } } Percobaan 5. Sorting pada kelas Collection dan antarmuka comparable package collection; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class Koleksi { private static int ukuran; private static Collection cs; private static String stringInput; public static void main(String[] args) { cs = new LinkedList(); 62
System.out.print("Berapa ukuran COLLECTION diinginkan? "); ukuran = inputData(); for (int i=0; i) cs); Iterator it = cs.iterator(); System.out.println("\nDATA TERURUT DALAM COLLECTION : "); while(it.hasNext()) { System.out.println("Data : " + it.next()); } } private static int inputData() { BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } int Data = Integer.valueOf(angkaInput).intValue(); return Data; } private static String bacaData() { String data = null; BufferedReader bfr = new BufferedReader( new InputStreamReader(System.in)); String stringInput = null; try { stringInput = bfr.readLine(); } catch (IOException e) { 63
e.printStackTrace(); } data = String.valueOf(stringInput); return data; } } Percobaan 6. ArrayList package bynary_and_ArraySearchList; import java.util.*; public class Insert_ArrayList_LinkedList { static final int N = 50000; // Mencatat waktu yang diperlukan untuk menyisipkan // sejumlah N objek ke List. static long timeList(List
