Java – Menggunakan Collection Framework

Mengumpulkan banyak variable dengan tipe sama dalam sebuah array adalah hal yang mutlak dibutuhkan dalam bahasa pemrograman apa pun. Seiring dengan kebutuhan tersebut, banyak juga dibuat fungsi-fungsi untuk memanipulasi array. Dalam Java, Anda bisa memanfaatkan seluruh framework Collection yang akan bertindak seperti array dengan fungsi-fungsi powerful yang tersedia sesuai kebutuhan.

Diagram collection - klik untuk melihat versi besar

Sebuah collection adalah sebuah object yang merepresentasikan kumpulan object-object. Collection digunakan untuk menyimpan, mengambil, dan memanipulasi data-data. Salah satu collection paling sederhana adalah Array. Namun dalam Collection Framework, Java menawarkan berbagai bentuk lain dari Collection.

Karena Collection adalah interface, maka harus dibuat class yang mengimplementasikannya. Dalam Java API, sudah tersedia beberapa class yang sangat berguna untuk memanage object-object dalam Collection, sesuai sifat dan kebutuhannya. Beberapa kelebihan utama menggunakan collection framework antara lain:

• Mengurangi effort dalam membuat program, karena sudah tersedia struktur data dan algoritma tanpa harus menulis sendiri.
• Meningkatkan performa, karena setiap implementasi dapat berfungsi maksimal sesuai kasus yang ada.
• Mudah dipelajari, sehingga mengurangi effort untuk mempelajari cara menggunakan API.
• Dapat dikembangkan dan fleksibel terhadap tipe object yang ada dalam Collection.

Ada banyak class yang mengimplementasikan Collection yang sudah tersedia dalam JDK. Pada dasarnya ada 3 Interface yang digunakan, yaitu Set, List, dan Map. Kemudian ada 5 implementasi dasar yang digunakan pula, yaitu Hash Table, Resizable Array, Balanced Tree, Linked List, dan Hash Table + Linked List. Masing-masing memiliki kelebihan dan kekurangan tersendiri, tergantung penggunaannya.

		Implementations
		Hash Table	Resizable Array	Balanced Tree	Linked List	Hash Table + Linked List
Interfaces	Set	HashSet		TreeSet		LinkedHashSet
	List		ArrayList		LinkedList
	Map	HashMap		TreeMap		LinkedHashMap

Berikut ini beberapa contoh cara menggunakan Collection Framework yang cukup sering dipakai.

1. ArrayList digunakan untuk membuat array yang ukurannya dinamis. Berbeda dengan array biasa yang ukurannya harus ditentukan di awal deklarasi array, dengan ArrayList, ukurannya akan fleksibel tergantung banyaknya elemen yang dimasukkan. Pendeklarasian object ArrayList sebaiknya diikuti dengan nama class yang akan dimasukkan dalam List tersebut. Tujuannya agar method dan property dari setiap object dalam ArrayList dapat diakses secara langsung. Namun jika tidak mencantumkan nama class pun tidak masalah selama proses parsing class benar.
   
   

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   import java.util.ArrayList; public class ArrayListDemo {   public static void main(String[] args) {     ArrayList<Human> list1 = new ArrayList<Human>();     for(int i = 0; i < 10; i++) {       list1.add(new Human("Human " + i));     }     for(int i = 0; i < list1.size(); i++) {       System.out.println(list1.get(i).name);     }   } } class Human {   public String name;   public Human(String name) {     this.name = name;   } }

   Kelebihan lain collection framework ini adalah kemampuannya untuk membuat perulangan dirinya sendiri, sebab Collection framework mengimplementasikan interface Iterable. Sehingga untuk membuat perulangan “for” sebenarnya cukup dengan:
   
   
   

   1 2 3

   for(Human h : list1) {   System.out.println(h.name); }

2. Implementasi kedua yang cukup sering dipakai adalah Set. Sama seperti ArrayList, Set ini akan berukuran dinamis. Hanya saja, Set tidak akan memperbolehkan duplikasi object yang diketahui dari method equals() yang ada di setiap object dalam Java. Anda bisa meng-override method tersebut untuk membuat kriteria Anda sendiri, seperti pada contoh di bawah ini.
   
   

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

   import java.util.ArrayList; import java.util.HashSet; public class HashSetDemo {   public static void main(String[] args) {     HashSet<Human> set = new HashSet<Human>();     ArrayList<Human> list = new ArrayList<Human>();     Human a = new Human("A");     Human b = new Human("B");     Human c = new Human("A");     set.add(a);     set.add(b);     set.add(c);     list.add(a);     list.add(b);     list.add(c);     System.out.println("Print Set");     for(Human h : set) {       System.out.println(h.name);     }     System.out.println("Print List");     for(Human h : list) {       System.out.println(h.name);     }   } } class Human {   public String name;   public Human(String name) {     this.name = name;   }   @Override   public boolean equals(Object obj) {     if(!(obj instanceof Human)) {       return super.equals(obj);     } else {       Human comp = (Human)obj;       return comp.hashCode() == obj.hashCode();     }   }   @Override   public int hashCode() {     int hash = 7;     hash = 53 * hash + (this.name != null ? this.name.hashCode() : 0);     return hash;   } }

3. Implementasi ketiga adalah dari Interface Map. Map berfungsi sebagai collection yang memetakan setiap value dengan key tertentu. Jika mencoba menambahkan elemen dengan key yang sama, maka elemen sebelumnya pada key tersebut akan ditindih sehingga hilang. Deklarasi HashMaps juga harus diikuti nama class yang akan menjadi key dan value-nya.
   
   

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   import java.util.HashMap; import java.util.Iterator; public class HashMapDemo {   public static void main(String[] args) {     HashMap<String, String> map = new HashMap<String, String>();     map.put("rumah", "Tipe 45");     map.put("mobil", "BMW");     map.put("bunga", "Mawar");     System.out.println("Sebelum diubah");     Iterator<String> ite = map.keySet().iterator();     while(ite.hasNext()) {       System.out.println(map.get(ite.next()));     }     System.out.println("Setelah diubah");     map.put("mobil", "Ferrari");     for(String key : map.keySet()) {       System.out.println(map.get(key));     }   } }

4. Contoh lainnya implementasi yang sering dipakai adalah Stack. Stack merupakan sebuah collection sederhana yang menerapkan aturan LIFO (Last in First out). Artinya, elemen yang masuk terakhir akan dikeluarkan terlebih dahulu. Meskipun terdapat method add, get, dan remove karena Stack tetap inherit ke interface collection, namun method yang umum dipakai dalam Stack adalah push() untuk memasukkan elemen, pop() untuk mengeluarkan elemen, empy() untuk mengecek apakah stack kosong, dan peek() untuk melihat elemen teratas. Semua dilakukan sesuai urutan LIFO.
   ?

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   import java.util.Stack; public class StackDemo {   public static void main(String[] args) {     Stack<String> stack = new Stack<String>();     stack.push("A");     stack.push("B");     stack.push("C");     System.out.println("Print stack awal berurutan biasa");     for(String s : stack) {       System.out.println(s);     }     System.out.println("Keluarkan satu");     System.out.println(stack.pop());     System.out.println("Tambahkan dua");     stack.push("D");     stack.push("E");     System.out.println("Print stack sesuai urutan keluar");     while(!stack.empty()) {       System.out.println(stack.pop());     }     System.out.println("Selesai");   } }

   Untuk memanipulasi elemen-elemen stack seperti pengurutan dan pengacakan, bisa menggunakan static method pada class java.util.Collections. Dengan demikian akan mempermudah proses pembuatan program Anda. Masih banyak lagi implementasi Collections yang siap Anda gunakan langsung.