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:

Selection_023

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:
Selection_024

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:

Selection_027

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:

Selection_025

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

Advertisements

7 thoughts on “Mengurutkan (Sorting) pada Kelas Arrays Java

  1. gan ane mau tanya. kalo mau ngurutin manual caranya gimana.
    misal angka dirandom dulu..
    terus diurutkan bake bubble sort gitu..
    ane beginner banget nih. makasih ya infonya

    • bubble sort? itu tugas kuliah ya, Bro?
      kalo gitu pake 3 method aja dalam 1 class:

      1. buat ngerandom isi array
      2. buat nampilin isi array
      3. buat ngurutin array

      Kalo method pertama pake class Random aja, adanya di java.util.Random.
      contohnya gini: bikin objek Random di baris 3 sama panggil method di baris 5

          public int[] randomArray(int jumlah) {
              int[] arr = new int[jumlah];
              Random r = new Random();
              for (int i = 0; i < arr.length; i++) {
                  arr[i] = r.nextInt(10);
              }
              return arr;
          }

      Terus buat ngurutin array bisa liat di
      http://mathbits.com/MathBits/Java/arrays/Bubble.htm atau
      https://www.udemy.com/blog/bubble-sort-java/
      contoh:

          public int[] urut(int[] arr) {
              int j, temp;
              boolean flag = true;   
              
              while (flag) {
                  flag = false;
                  for (j = 0; j < arr.length - 1; j++) {
                      if (arr[ j] < arr[j + 1]){
                          temp = arr[ j];                
                          arr[ j] = arr[ j + 1];
                          arr[ j + 1] = temp;
                          flag = true;              
                      }
                  }
              }
              return arr;
          }
  2. Lengkapnya gini:

    import java.util.Random;
    
    public class NewClass {
    
        public int[] randomArray(int jumlah) {
            int[] arr = new int[jumlah];
            Random r = new Random();
            for (int i = 0; i < arr.length; i++) {
                arr[i] = r.nextInt(10);
            }
            return arr;
        }
    
        public int[] urut(int[] arr) {
            int j, temp;
            boolean flag = true;   
            
            while (flag) {
                flag = false;
                for (j = 0; j < arr.length - 1; j++) {
                    if (arr[ j] < arr[j + 1]){
                        temp = arr[ j];                
                        arr[ j] = arr[ j + 1];
                        arr[ j + 1] = temp;
                        flag = true;              
                    }
                }
            }
            return arr;
        }
        public void tampilArray(int[] arr){
            for (int i:arr) {
                System.out.print(i+" ");
            }
        }
        public static void main(String[] args) {
            NewClass nc = new NewClass();
            int[] array = nc.randomArray(6);
            System.out.println("Array: ");
            nc.tampilArray(array);
            System.out.println("\n\nArray Terurut: ");
            int[] arrayUrut = nc.urut(array);
            nc.tampilArray(arrayUrut);
        }
    }
    

    Hasilnya:

    Sorting di atas, kayak yang kamu liat, terurutnya menurun. Kalo mau diurutin terurut menaik, ganti aja kondisi if-nya dari “<” jadi “>”.

    tapi itu tumben banget pake bubble sort. Tugas praktikum yak? Setau gw dosen jaman sekarang dah gak ada yang mau ngajarin bubble sort lagi. Apalagi buat dijadiin tugas. Palingan asisten yang masih ngasi tugas tipe beginian. Itupun asisten jaman gw dulu banget…

  3. kak mau nanyak kalo bentuk program dari list penambahan itu gimana ya? soalnya saya gak faham sama sekali
    mohon bantuannya ya kak
    terima kasih

  4. kak, kalau misalnya nih kita disuruh milih 1-100 (pakai match random), trus dari situ kita pakai 20 angka random. Nah cara sortir/memilih 5 angka ganjil dan menyimpannya kembali di array baru bagaimana ya kak?

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s