ArrayList Java: Membuat, Menambah, Menghapus, Loop, dan Sort

List yang Ukurannya Menyesuaikan Sendiri

Array biasa di Java punya panjang tetap: kalau kamu memutuskan sepuluh slot, selamanya kamu punya sepuluh slot. ArrayList adalah alternatif dari java.util yang ukurannya bisa berubah. Ia membesar saat kamu menambah elemen dan mengecil saat kamu menghapusnya, dan punya method praktis untuk hal-hal yang memang biasa kamu lakukan dengan sebuah list.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Perhatikan tipe di dalam kurung sudut, List<String>, yang memberi tahu compiler bahwa list ini berisi nilai String. Tanda <> (disebut "diamond") di sebelah kanan membuat Java menyimpulkan tipe yang sama tanpa perlu ditulis ulang. Perhatikan juga bahwa kamu meng-import java.util.ArrayList; class ini tidak tersedia secara default.

Deklarasikan sebagai List, Buat sebagai ArrayList

Kamu hampir selalu akan melihat variabelnya diberi tipe interface List, bukan class konkret ArrayList:

List<String> names = new ArrayList<>();

Ini kebiasaan yang baik, bukan aturan. Menulis kode berdasarkan interface List berarti bagian lain dari kodemu tidak peduli implementasi list mana yang kamu pakai, sehingga kamu bisa menggantinya nanti tanpa menyentuh kode itu. Untuk penggunaan sehari-hari, keduanya berperilaku sama.

Menambah, Mengambil, dan Mengubah Elemen

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // append to the end
        fruits.add("banana");
        fruits.add(1, "cherry");  // insert at index 1

        System.out.println(fruits.get(0));   // read by index
        fruits.set(0, "apricot");            // overwrite index 0

        System.out.println(fruits);
    }
}

• add(value) menambahkan elemen di akhir.
• add(index, value) menyisipkan elemen di sebuah posisi dan menggeser elemen setelahnya ke kanan.
• get(index) membaca elemen di sebuah posisi (dimulai dari nol).
• set(index, value) menimpa elemen yang sudah ada.

Index dimulai dari nol, dan get pada index di luar jangkauan akan melempar IndexOutOfBoundsException.

Menghapus Elemen

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // remove by value (first match)
        fruits.remove(0);         // remove by index

        System.out.println(fruits);
    }
}

Ada jebakan klasik saat list berisi Integer. remove(int) berarti "hapus berdasarkan index", sedangkan remove(Object) berarti "hapus berdasarkan nilai", jadi:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // removes index 1 -> the value 20
nums.remove(Integer.valueOf(20));    // removes the value 20

Bungkus nilainya dengan Integer.valueOf(...) kalau maksudmu "hapus nilai ini", bukan "hapus index ini".

Size, Contains, dan Mencari Index

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) membuat list immutable dengan cepat; kalau kamu memberikannya ke constructor ArrayList, kamu mendapat salinan yang bisa diubah dan sudah berisi nilai-nilai tersebut.

Perulangan pada ArrayList

Loop yang paling rapi adalah for versi enhanced (for-each loop):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Kalau kamu juga butuh index-nya, pakai loop dengan penghitung menggunakan size() dan get(i):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Satu aturan: jangan menambah atau menghapus elemen dari list saat for-each loop sedang menelusurinya, karena itu akan melempar ConcurrentModificationException. Untuk menghapus elemen yang cocok dengan aman, pakai removeIf:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // drop the even numbers
        System.out.println(nums);
    }
}

Mengurutkan

Collections.sort mengurutkan list di tempatnya (in place) berdasarkan urutan alaminya (alfabetis untuk string, numerik untuk angka):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // descending
        System.out.println(nums);
    }
}

Untuk urutan khusus, berikan Comparator ke list.sort(...), misalnya names.sort(Comparator.comparingInt(String::length)) untuk mengurutkan berdasarkan panjangnya.

ArrayList Menyimpan Objek, Bukan Primitif

Kamu tidak bisa menulis ArrayList<int>. Generics hanya bekerja dengan tipe objek, jadi pakai wrapper class Integer, Double, Boolean, dan seterusnya:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // int 95 is auto-boxed to Integer
        scores.add(88);

        int first = scores.get(0);  // auto-unboxed back to int
        System.out.println(first + scores.get(1));
    }
}

Autoboxing di Java mengonversi antara int dan Integer untukmu, jadi kodenya tetap enak dibaca. Ingat saja bahwa list itu sendiri menyimpan objek Integer.

Berikutnya: HashMap

ArrayList adalah alat yang tepat kalau kamu peduli pada urutan dan posisi. Kalau kamu perlu mencari sesuatu berdasarkan sebuah key, misalnya username ke data user atau kode produk ke harga, yang kamu butuhkan adalah HashMap, dan itu topik halaman berikutnya.