Mengurutkan (Sorting) pada Kelas Arrays Java

Salah satu dari banyak hal terkait bidang pemrograman adalah sorting! Pasti!! Bukannya kenapa2, tapi algoritma sorting tuh pelajaran wajib pas gw kuliah dulu. Dari semester 2 sampe semester 6, algoritma sorting pasti diajarin ama dosen pemrograman. Mulai dari yang sorting-nya naïve semacam bubble sort (fyi, bubble sort ternyata gak boleh digunain lagi abis semester 2 itu ama dosen pemrograman gw) sampe yang butuh algoritma rekursif semacam merge sort atau quick sort.

Tapi… bukan itu yang kita bahas di sini. Berhubung blog balita cuma berisi hal2 gak penting dan gak jelas, gw mau nulisin cara ngurutin suatu hal di java pake kelas arrays! Yap, we’re gonna do this using array (class Arrays), not the class Collections. Walopun mirip c yah, sama2 pake method “sort” dari masing2 kelas (Collections.sort dan Arrays.sort).

Okeh, langsung mulai… Kalo array itu isinya integer, contoh ngurutinnya gini:

import java.util.Arrays;

/**
 *
 * @author arby
 */
public class UrutArray {

    public static void main(String[] args) {

        int[] intArray = {1, 3, 81, 2, 22, 47};
        System.out.println("\n****** Unsorted Integer Array *******");
        for(int x: intArray){
            System.out.print(x+" ");
        }
        Arrays.sort(intArray);

        System.out.println("\n****** Sorted Integer Array *******");
        for(int x: intArray){
            System.out.print(x+" ");
        }
    }
}

Method sort dari kelas Arrays sendiri merupakan method static… Jadi, dipanggilnya dari kelasnya langsung, dan bukan objek. Masukan dari method ini bisa macam2, bisa array of integer, array of double, array of String dan bisa jugak array of Object. Penggunaannya mirip. Contohnya ajah kalo pengurutan array of String, jadinya gini:

import java.util.Arrays;

/**
 *
 * @author arby
 */
public class UrutArray {

    public static void main(String[] args) {
        String[] stringArray = {"ab", "aB", "c", "0", "2", "1Ad", "a10"};
        System.out.println("****** Unsorted String Array *******");
        for (String x: stringArray) {
            System.out.print(x+" ");
        }
        Arrays.sort(stringArray);

        System.out.println("\n****** Sorted String Array *******");
        for (String x: stringArray) {
            System.out.print(x+" ");
        }
    }
}

Dua program di atas, kalo digabung dan dijalanin, jadi hasilnya gini:

Itu kalo array-nya punya tipe bentuk primitif. Kalo yang array of object, beda penangan c yak. Contohnya ajah kamu punya kelas orang gini:

Orang.java

public class Orang {
    int berat; String nama;

    @Override
    public String toString() {
        return nama+" punya berat "+berat;
    }

    public Orang(int berat, String nama) {
        this.berat = berat;
        this.nama = nama;
    }
}

Kamu mau ngurutin pake Arrays.sort di kelas “UrutOrang.java” gini:

import java.util.Arrays;

/**
 *
 * @author arby
 */
public class UrutOrang {
    public static void main(String[] args) {
        Orang[] nOrang = { new Orang(43, "Rifqi"),
            new Orang(73, "Sony"),
            new Orang(32, "Alit")
        };
        System.out.println("Daftar Nama Anggota:");
        for(Orang x: nOrang){
            System.out.println(x.toString());
        }

        //urutkan dan tampilkan kembali
        Arrays.sort(nOrang);
        System.out.println("\nDaftar Nama Anggota:");
        for(Orang x: nOrang){
            System.out.println(x.toString());
        }
    }
}

Pasti nampilnya gini:

Itu karena dia gak tau musti ngurutin apa, trus berdasarkan apa…. Yap, dia tau harus ngurusin objek dari class “Orang”, tapi dia gak tau kan musti ngurutin berdasarkan apa… nama kah atau berat kah?? Trus gimana?! Yang harus dilakukan sekarang, meng-implements interface “Comparable” di kelas pembentuk objek yang mau diurutin. Dan dalam kasus kita, kelas itu adalah kelas “Orang”!

Jadi, ubah Orang.java jadi gini:

/**
 *
 * @author arby
 */
public class Orang implements Comparable<Orang>{
    int berat; String nama;

    @Override
    public String toString() {
        return nama+" punya berat "+berat;
    }

    public Orang(int berat, String nama) {
        this.berat = berat;
        this.nama = nama;
    }

    @Override
    public int compareTo(Orang o) {
        return 0;
    }
}

Karena kebetulan parameter pengurut ada di kelas “Orang”, jadinya tipe dari interface Comparable itu jugak “Orang”. Ditandai bentuk Comparable<Orang>. Dan karena interface tersebut punya 1 method, jadi method itu harus di-override… yaitu method compareTo(). Di method inilah ditentukan mana yang mau diurutin. Kalo gw nulisnya gini:

    @Override
    public int compareTo(Orang o) {
        if (this.berat < o.berat) {
            return -1;
        } else if (this.berat == o.berat) {
            return 0;
        } else {
            return 1;
        }
    }

Asumsikan kayak gambar ini:

Jadi, semuanya disesuaikan sama bentuk keterurutan. Kalau menurut descending (dari besar ke kecil), ada parameter yang disesuaikan antara objek internal (“this”) dan objek eksternal (“o”). Kalo this lebih kecil dari o, artinya urutannya masih belum benar, jadi kembalikan nilai “1” untuk melakukan pengurutan. Kalo 0 dibiarin, kalo -1 sama ajah c ama 0, coz setau gw, dia di-swap kalo >0. Tapi bedanya, kalo kasi -1, dia bakal dibandingin lagi sama elemen lain… Kan basic sort-nya pake merge sort, jadi dibagi2 per area gitu. Jadi mungkin dibandingin antara 1 area ke area lain. Mungkin lhoh yah.

Jadi, lengkapnya kelas Orang.java tadi isinya gini:

/**
 *
 * @author arby
 */
public class Orang implements Comparable $lt;Orang>{

    int berat;
    String nama;

    @Override
    public String toString() {
        return nama + " punya berat " + berat;
    }

    public Orang(int berat, String nama) {
        this.berat = berat;
        this.nama = nama;
    }

    @Override
    public int compareTo(Orang o) {
        if (this.berat < o.berat) {
            return -1;
        } else if (this.berat == o.berat) {
            return 0;
        } else {
            return 1;
        }
    }
}

Okeh, dengan adanya kondisi di atas, pas manggil “UrutOrang.java” (gak ada lagi yang diubah dari kelas ini), jadinya bakal gini:

Begitulaaaaahhh~~~

Dan oh iya, penggunaan sort di kelas Arrays java ini, biasa jadi contoh dari design pattern template method coz ada semacam algoritma penangguhan, berupa method “compareTo” ke kelas anak-nya. Emang gak terlalu mirip c yak… coz method tipe “template method” ada di method “sort” kelas Arrays, trus sub-class adanya dari interface “Comparable”. Agak gak sejalan ama penjelasan dari design pattern template method. Kan kalo dari penjelasannya, template method itu adanya di kelas induk yang dipanggil sama anaknya. Di kasus kita sekarang, Orang bukan kelas turunan dari “Arrays” kan… cuma dari interface Comparable ajah.

Trus, tambahannya kenapa agak gak cocok ama design pattern template method, karena method dengan tipe “template method” itu kan tipenya “final”, sedangkan kalo sekarang c enggak. Method yang berperan jadi “template method” ituh kan method “sort”, dan tipe-nya cuma static, gak final… Jadi yaaaa… gitu deh. Yang penting, sekarang kita udah bisa ngurutin array of object pake method Arrays.sort…

–acung jempol plus kedip mata ala Rock Lee–