Category: Java

Memeriksa Bilangan Palindrom
Palindrom adalah kata, rangkaian kata, atau bilangan yang terbaca sama, baik dari depan maupun dari belakang. Beberapa contoh palindrom adalah radar, kasur rusak, 1001.

Pada bahasa pemrograman Java kita dapat dengan mudah memastikan bahwa suatu string adalah palindrom atau bukan.
```
boolean isPalindrom (String str) {
  
  return str.equals(new StringBuffer().append(str).reverse().toString());
}
```
Kode di atas mengembalikan nilai true jika argumennya adalah palindrom. Namun untuk memeriksa palindrom dari argumen berupa bilangan, kita membutuhkan type casting. Type casting berguna untuk mengkonversi suatu tipe data ke tipe data yang lain. Dalam kasus ini kita membutuhkan konversi dari tipe data int ke String. Caranya mudah saja, tinggal tambahkan saja bilangan tersebut dengan sebuah string kosong.
```
boolean isPalindrom (int bilangan) {
  
  String str = "" + bilangan;
  return str.equals(new StringBuffer().append(str).reverse().toString());
}
```
Dengan kode di atas kita bisa memeriksa apakah sebuah bilangan termasuk palindrom atau bukan.

Untuk Anda yang malas menghafal kode yang panjang di atas, kita bisa menggunakan pemeriksaan palindrom secara manual. Pada dasarnya algoritma palindrom yaitu membandingkan karakter pertama dengan karakter terakhir, lalu karakter kedua dengan karakter kedua dari belakang, dan seterusnya. Jika jumlah karakternya ganjil, misalnya “radar” (5 karakter), karakter yang berada tepat di tengah-tengah, yaitu karakter ketiga (“d”) tidak perlu diperiksa.
```
boolean isPalindrom (int bilangan) {

  String str = "" + bilangan;    // konversi dari int ke Str
  char [] c = str.toCharArray(); // konversi dari String ke array char
  int i1 = 0,        // indeks pertama
  i2 = c.length - 1; // indeks terakhir

  while (i2 > i1) {

    if (c[i1 ++] != c[i2 --])
      return false;
  }

  return true;
}
```
Pada baris keempat kita konversikan tipe data String ke bentuk dasarnya yaitu sekumpulan karakter dengan method toCharArray(). Pada baris kesepuluh, kita akan membandingkan sekaligus menambah indeks i1 dan mengurangi indeks i2. Perhatikan bahwa operator unary ditulis setelah variable berarti bahwa pembadingan dilakukan terlebih dahulu kemudian baru menambah/mengurangi indeksnya.
October 2, 2012
Menukar Nilai Dua Variable Tanpa Perantara
Menukar nilai dua buah variable adalah salah satu algoritma dasar dalam struktur data. Biasanya untuk menulis fungsi swap ini, kita membutuhkan tambahan satu variable sebagai perantara. Berikut ini adalah algoritma untuk menukar nilai dua buah variable dengan perantara.
```
tmp = x;
x = y;
y = tmp;
```
Pada contoh di atas nilai variable x dan y bertukar melalui perantara tmp. Berikut ini adalah algoritma untuk menukar nilai dua buah variable tanpa perantara.
```
x = x ^ y;
y = x ^ y;
x = x ^ y;
```
Singkat dan sederhana, nilai variable x dan y sudah bertukar. Tanda caret ^ dalam bahasa pemrograman Java dan C adalah operator bitwise (logika) XOR (Eksklusif Or). Pada eksklusif or berlaku hukum alternatif, yaitu hanya salah satu saja yang boleh bernilai true. Perbedaannya dengan inklusif or (OR) adalah berlaku hukum kumulatif, yaitu boleh salah satu atau keduanya bernilai true.
```
x  y   OR  XOR
--------------
0  0    0   0
0  1    1   1
1  0    1   1
1  1    1   0
```
Penjelasan dari keajaiban pertukaran di atas adalah karena operator XOR memiliki dua sifat. Pertama, menggabungkan/mencampurkan informasi, dan kedua, mampu memisahkannya kembali (sekaligus menghapus jejak penggabungannya) dengan cara melakukan lagi operasi XOR kepadanya.

Pada baris pertama, nilai x dan y digabungkan sehingga membentuk suatu nilai hybrid di antara keduanya (sifat 1). Simpan nilai hybrid tersebut di x. Pada baris kedua nilai hybrid di-XOR-kan lagi dengan y yang akan memunculkan lagi nilai x semula (sifat 2). Simpan nilai x semula di y. Terakhir nilai hybrid di-XOR-kan dengan y (ingat y sekarang bernilai x semula) sehingga memunculkan lagi nilai y semula (sifat 2). Simpan nilai y semula di x.

Supaya lebih jelas lagi, kita coba dengan contoh. Misalnya int x bernilai 5 (0101) dan int y bernilai 9 (1001).
```
x = 5 = 0101;
y = 9 = 1001;

x = x ^ y; // x = 0101 ^ 1001 = 1100 = hybrid
y = x ^ y; // y = 1100 ^ 1001 = 0101 = 5
x = x ^ y; // x = 1100 ^ 0101 = 1001 = 9
```
Implementasi pertukaran nilai dengan operator logika XOR dalam bahasa pemrograman Java adalah sebagai berikut.
```
int x = 5, y = 9;

x ^= y; // x = hybrid
y ^= x; // y = 5
x ^= y; // x = 9
```
Begitulah cerita dibalik dua nilai variable yang tertukar :D. Pembahasan lebih mendalam tentang XOR Swap Algorithm bisa dibaca di Wikipedia.
September 7, 2012
Bagaimana Mencari Bilangan Prima?
Salah satu pertanyaan paling penting dalam dunia Matematika adalah menentukan apakah suatu angka merupakan bilangan prima atau tidak. Topik bilangan prima ini juga menjadi salah satu dari tujuh masalah utama dalam bidang Matematika (Millennium Prize Problems), yaitu Riemann hypothesis. Orang pertama yang sanggup memecahkan salah satunya akan mendapat hadiah US$1,000,000 dari Clay Mathematics Institute. Sampai sekarang masih tersisa enam soal yang belum terpecahkan termasuk Riemann hypothesis yang bila dapat dipecahkan dapat menguak pola distribusi bilangan prima.

Bilangan prima adalah bilangan asli yang lebih besar dari 1 dan hanya memiliki dua faktor (pembagi) yaitu 1 dan bilangan itu sendiri. Contoh bilangan prima adalah 7, yang hanya memiliki dua faktor yaitu 1 dan 7. Sebaliknya, 6 bukan merupakan bilangan prima karena memiliki faktor-faktor 1, 2, 3, dan 6. Bilangan selain bilangan prima disebut bilangan komposit.

Bilangan prima sangat menarik karena aturan untuk menentukan bilangan prima sudah sangat jelas dan mudah dipahami, namun belum ada rumus atau persamaan yang mudah untuk menentukan apakah sebuah angka merupakan bilangan prima atau bukan.

Dalam tutorial kali ini akan dibahas bagaimana menentukan sebuah angka adalah prima atau bukan dengan menggunakan bahasa pemrograman Java. Cara yang paling sederhana adalah dengan mencoba membagi sebuah bilangan dengan setiap bilangan dari 2 sampai ke bilangan n – 1. Jika ada satu bilangan saja yang dapat habis membagi berarti bilangan tersebut bukan prima.
```
boolean isPrime (int n) {

  for (int i=2; i<n; i++)
    if (n % i == 0)
      return false;

  return true;
}
```
Angka 2 adalah satu-satunya bilangan prima genap, jadi tidak perlu dipusingkan dengan mencobanya. Kode di atas mungkin cukup untuk mencari bilangan kecil, tapi kita butuh algoritma yang lebih cepat/mangkus untuk mencari bilangan besar. Kita tidak perlu mencari dari 2 sampai bilangan n, tapi cukup sampai n/2. Karena jika angka 2 habis membagi n, dapat dipastikan n/2 juga akan habis membagi n.
```
boolean isPrime (int n) {

  for (int i=2; i*2<n; i++)
    if (n % i == 0)
      return false;

  return true;
}
```
Masih belum cukup cepat? Algoritma di atas bisa dioptimalkan lagi, yaitu dengan hanya memeriksa bilangan ganjil saja, karena semua bilangan genap pasti habis dibagi 2. Kemudian kita bisa efisienkan percobaan di atas dengan hanya memeriksa pembaginya sampai ke akar kuadrat dari bilangan n (dengan pembulatan ke bawah). Karena jika kita menderetkan semua faktor dari sebuah bilangan, akar kuadratnya pasti selalu berada di tengah-tengah deret tersebut. Misal faktor dari 81 adalah 1, 3, 9, 27, 81. Akar kuadrat dari 81 adalah 9, terletak tepat di tengah-tengah deret tersebut. Tidak perlu diperiksa setengah bagian setelah akar kuadrat karena pasti sudah ketahuan prima atau bukan.
```
boolean isPrime (long n) {

  if (n % 2 == 0) return false;
    
    for (long i=3; i*i<=n; i+=2)
      if (n % i == 0)
        return false;
    
    return true;
}
```
Seperti terlihat pada potongan kode di atas, kita hanya memeriksa sampai ke akar kuadrat dari bilangan n dan hanya memproses bilangan ganjil. Dengan algoritma ini, program kita pasti mengalami peningkatan yang signifikan. Terutama ketika bekerja dengan angka yang sangat besar, itulah kenapa digunakan tipe data long.

Sebenarnya ada satu lagi metode yang lebih mangkus yang disebut The Sieve of Eratosthenes. Namun kurang cocok dengan kebutuhan karena metode ini digunakan untuk mencari semua bilangan prima dari 2 sampai ke bilangan n.
September 4, 2012
Belajar Java – Array
Array adalah kumpulan data yang memiliki tipe data dan jumlah elemen yang tetap (tidak bisa ditambah/dikurangi). Array pada Java adalah sebuah object, maka harus dideklarasikan menggunakan kata kunci new. Tiap data pada array disebut element, dan masing-masing element dapat diakses menggunakan index yang berupa angka. Index dimulai dari 0 sampai jumlah element – 1.

Contoh untuk mendeklarasikan array sesuai gambar di atas adalah
```
char [] arrayHuruf = new char[10];
```
Sedangkan cara untuk menginisialisasinya adalah sebagai berikut
```
arrayHuruf[0] = 'A';
arrayHuruf[1] = 'B';
//dst
```
Bisa menggunakan perulangan untuk menginisialisasi array
```
for (int i = 0; i < 10; i ++) {

  arrayHuruf[i] = (char) ('A' + i);
}
```
Array arrayHuruf akan berisi 10 karakter, yaitu ‘A’ sampai ‘J’ secara berurutan. Alternatif lain untuk menginisialisasi array, dapat menggunakan syntax sebagai berikut
```
char[] arrayHuruf = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };
```
Jumlah element diketahui dari banyaknya nilai di antara tanda ‘{‘ dan ‘}’.

Kita juga dapat mendeklarasikan array dari array atau lebih dikenal sebagai array multidimensi dengan cara seperti berikut char[][] namaArray = new char[10][2] atau char[][] namaArray = new char[10][], tapi tidak boleh seperti ini char[][] namaArray = new char[][2]. Dalam bahasa Java, pengertian array lebih sederhana daripada pada bahasa C, jadi jumlah element pada baris berikutnya jumlahnya boleh bervariasi (tidak harus sama dengan baris pertama).
```
char[][] hurufAngka = new char[2][];
hurufAngka[0] = new char[2]; // array index [0][0] sampai [0][1]
hurufAngka[1] = new char[1]; // hanya ada array index [1][0]
```
Array multidimensi juga dapat langsung dideklarasikan dan diinisialisasi seperti berikut
```
char[][] hurufAngka = {
  { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' },
  { '1', '2', '3', '4', '5'}
};
```
Pada contoh untuk menginisialisasi di atas, kita menggunakan bentuk perulangan for (nilai_awal; nilai_akhir; penambahan/pengurangan), jadi jumlah element-nya harus diketahui. Bagaimana jika jumlah element tidak diketahui? Misalkan kita ingin mencetak array yang berisi huruf-huruf yang tidak diketahui secara pasti jumlahnya. Gunakan enhanced for yang penggunaannya mirip dengan foreach pada PHP.
```
char[] arrayHuruf = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };

for ( char huruf : arrayHuruf ) {
  System.out.println( huruf );
}
```
Kita juga bisa menggunakan built-in property length untuk mengetahui jumlah element-nya.
```
for (int i=0; i<arrayHuruf.length; i++)
  System.out.println( arrayHuruf[i] );
```
Untuk menyalin array yang satu ke yang lainnya, bisa menggunakan method arraycopy yang ada pada class System.
```
public static void arraycopy(Object arraySumber, int indexSumber, Object arraytujuan, int indexTujuan, int panjangElement)
```
Contoh penggunaannya adalah seperti berikut
```
int[] arraySumber = { 1, 2, 3, 4, 5 };
int[] arrayTujuan = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

System.arraycopy (arraySumber, 0, arrayTujuan, 0, arraySumber.length);
		
for (int item : arrayTujuan)
  System.out.println ( item );
```
Tambahan:
Meskipun jumlah element pada array tidak bisa ditambah/dikurangi, kita bisa menciptakan array baru dari array yang sudah ada. Namun tentu saja, nilai yang sudah ada akan hilang.
```
int [] array = new int[5];
array = new int[10];
```
August 19, 2012
Belajar Tipe Data Primitif pada Java
Tipe data adalah salah satu konsep dasar pemrograman. Sebagai seorang programer, seharusnya menguasai hal ini dengan baik. Untuk mempelajari tipe data, sebaiknya menggunakan bahasa pemrograman yang strongly typed, misalnya Java.

Tidak seperti pada bahasa PHP, Java adalah bahasa pemrograman yang strongly typed. Kita tidak bisa tidak acuh terhadap tipe data. Kita harus mengetahui data seperti apa yang disimpan ke dalam variabel. Misalnya untuk menyimpan umur kita gunakan variabel yang bertipe Integral, karena umur hanya berupa angka bulat tanpa pecahan.

Selain itu, Java juga bersifat statically typed. Maksudnya adalah setiap variabel harus dideklarasikan sebelum digunakan. Java akan mengecek tipe data pada compile-time.
```
int i = 0;
```
Tipe data primitif adalah tipe data standar yang tidak diturunkan dari objek manapun. Java memiliki 8 tipe data primitif, yaitu: byte, short, int, long, float, double, boolean, char. Berikut ini adalah pembahasan untuk masing-masing tipe data.

1. boolean. Tipe data boolean adalah tipe data Logical, yang hanya memiliki 2 nilai literal, yaitu true dan false.
```
boolean nilai = true;
```
2. char. Tipe data char adalah tipe data Textual, yang merepresentasikan karakter unicode 16-bit. Nilai literalnya harus diapit dengan tanda petik tunggal (‘).
```
char huruf = 'a';
```
3. byte. Tipe data byte adalah tipe data Integral 8-bit. Memiliki rentang nilai antara -2⁷ sampai 2⁷ – 1 atau dari -128 sampai 127.
```
byte angka = 100;
```
4. short. Tipe data short adalah tipe data Integral 16-bit. Memiliki rentang nilai antara -2¹⁵ sampai 2¹⁵ – 1 atau dari -32768 sampai 32768.
```
short angka = 1000;
```
5. int. Tipe data int adalah tipe data Integral 32-bit. Memiliki rentang nilai antara -2³¹ sampai 2³¹ – 1 atau dari -2,147,483,648 sampai 2,147,483,647.
```
int angka = 1000000;
```
6. long. Tipe data long adalah tipe data Integral 64-bit. Memiliki rentang nilai antara -2⁶³ sampai 2⁶³ – 1 atau dari -9,223,372,036,854,775,808 sampai 9,223,372,036,854,775,807.
Tipe data Integral (byte, short, int, long) memiliki default nilai literal int, kecuali diberi akhiran L yang berarti bertipe long. Tipe data Integral dapat menggunakan sistem bilangan desimal, oktal, atau heksadesimal.
```
int desimal = 26; // angka 26 dalam desimal
int oktal = 032; // angka 26 dalam oktal (diberi awalan 0)
int heksa = 0x1a; // angka 26 dalam heksadesimal (diberi awalan 0x)
long angkaBesar = 1000000000000L; // angka desimal bertipe long
```
7. float. Tipe data float adalah tipe data Floating Point 32-bit. Nilai literalnya mengandung pecahan (dipisahkan dengan tanda titik ‘.’)
```
float pi = 3.14F;
```
8. double. Tipe data double adalah tipe data Floating Point 64-bit. Nilai literal default untuk float dan double adalah double, kecuali diberi akhiran F seperti pada contoh nomor 7 di atas.
```
float pecahan = 7.65F;
double pecahanDouble = 1.2345;
```
Jika variabel float yang diinisialisasi dengan suatu nilai tanpa akhiran F, akan muncul pesan kesalahan: “possible loss of precision“.

Nilai literal untuk Floating Point juga bisa menggunakan notasi E (10ⁿ).
```
// ketiga variabel di bawah ini memiliki nilai yang sama 123.4
float f1 = 123.4F;
double d1 = 123.4;
double d2 = 1.234E2;
```
Sebenarnya tipe data primitif sudah memiliki nilai default pada saat dideklarasikan (meskipun tanpa inisialisasi), kecuali untuk variabel lokal. Nilai default untuk masing-masing tipe data adalah sebagai berikut:
```
Tipe Data   Nilai Default
--------------------------------------------------
boolean     false
char        '\u0000' (merepresentasikan ASCII null)
byte        0
short       0
int         0
long        0L
float       0.0F
double      0.0
```
Pada variabel lokal, deklarasi tipe data harus disertai dengan inisialisasi. Jika tidak, pastikan untuk memberikan nilai kepada variabel tersebut sebelum digunakan. Mengakses lokal variabel tanpa inisialisasi akan menghasilkan pesan kesalahan pada saat meng-compile (compile-time error).
August 11, 2012