Lompat ke konten
Materi
  • 1 Dasar-dasar Java
    1.1

    Kelas, main & output

    Situs ini kompilasi Java menggunakan aturan bahasa Java 8. Contoh mandiri ini menempatkan metode masuk, main, di dalam kelas. Kelas pembantu dan jawaban berbasis metode tidak memerlukan main mereka sendiri. System.out.println(...) mencetak baris; System.out.print(...) mencetak tanpa baris baru.

    public class Main {
        public static void main(String[] args) {
            System.out.println("Hello, world!");
            System.out.println("I am learning Java.");
        }
    }
    
    • Java dikompilasi: komiler memeriksa seluruh program, lalu ia dijalankan.
    • Deklarasi, penugasan, pemanggilan method, dan pernyataan return diakhiri dengan titik koma ;. Blok if, for, atau while menggunakan kurung kurawal; jangan tambahkan titik koma hanya karena tanda kurung kurawal penutupnya muncul.
    Contoh mandiri Java 8 ini mendefinisikan main di dalam kelas
    Contoh mandiri Java 8 ini mendefinisikan main di dalam kelas
    1.2

    Variabel & tipe primitif

    Variabel harus mendeklarasikan tipenya. Tipe primitif umum: int (bilangan bulat), double (desimal), boolean (true/false), char (satu unit kode UTF-16; beberapa karakter memerlukan dua).

    public class Main {
        public static void main(String[] args) {
            int age = 17;
            double price = 9.99;
            boolean passed = true;
            System.out.println(age + " " + price + " " + passed);
        }
    }
    
    1.3

    Komentar & gaya

    Komentar adalah // (satu baris) atau /* ... */ (blok). Indentasi kode di dalam kurung kurawal { }. Nama kelas dimulai dengan Huruf Besar; variabel dan method menggunakan camelCase (huruf kecil pertama).

    public class Main {
        public static void main(String[] args) {
            // greet the user
            String firstName = "Mei";
            System.out.println("Hi, " + firstName);
        }
    }
    

    Kesalahan umum

    • Deklarasi, assignment, pemanggilan method, dan pernyataan return diakhiri dengan ;; blok alur kontrol tidak perlu semicolon tambahan.
    • Gunakan titik masuk standar Java 8 public static void main(String[] args); nama parameter mungkin berbeda, dan String... args juga valid.
    • println menambahkan baris baru; print tidak.
  • 2 Operator & ekspresi
    2.1

    Aritmatika & penugasan

    Aritmatika Java menggunakan + - * / dan % (sisa bagi). Dengan dua ints, / adalah pembagian integer — ini membuang desimal. +=, -=, dan ++ adalah jalan pintas.

    public class Main {
        public static void main(String[] args) {
            int a = 7, b = 2;
            System.out.println(a / b);    // 3 (integer division)
            System.out.println(a % b);    // 1
            double x = 7.0 / 2;           // 3.5 (one side is double)
            System.out.println(x);
        }
    }
    
    int/int memotong; melibatkan double untuk hasil bagi sebenarnya
    int/int memotong; melibatkan double untuk hasil bagi sebenarnya
    2.2

    Menggunakan objek: String, Math, wrapper

    Beberapa nilai adalah objek dengan method. String memiliki .length(), .substring(), .toUpperCase(). Math memiliki Math.max, Math.sqrt, Math.pow. Kelas wrapper (Integer, Double) membungkus primitif — mis. Integer.parseInt("42").

    public class Main {
        public static void main(String[] args) {
            String s = "Hello";
            System.out.println(s.length());                  // 5
            System.out.println(s.toUpperCase());             // HELLO
            System.out.println(Math.max(3, 9));              // 9
            System.out.println(Integer.parseInt("42") + 1);  // 43
        }
    }
    

    Math.random() mengembalikan random double dari 0.0 hingga (tetapi tidak termasuk) 1.0. Skala dan cast untuk mendapatkan bilangan bulat — ini adalah idiom AP:

    public class Main {
        public static void main(String[] args) {
            // a random whole number from 1 to 6 (a dice roll)
            int roll = (int) (Math.random() * 6) + 1;
            System.out.println(roll >= 1 && roll <= 6);   // true
        }
    }
    
    • Integer.MAX_VALUE (2147483647) dan Integer.MIN_VALUE adalah batas dari int; melampauinya akan melingkar kembali (overflow).
    • Variabel objek yang menunjuk ke objek apa pun memegang null; memanggil method padanya melempar NullPointerException.
    2.3

    Casting & konversi tipe

    Casting mengubah tipe nilai. (int) membuang desimal; (double) menghindari pembagian integer ketika Anda membutuhkan hasil yang presisi.

    public class Main {
        public static void main(String[] args) {
            double pi = 3.99;
            System.out.println((int) pi);            // 3
            int total = 7, n = 2;
            System.out.println((double) total / n);  // 3.5
        }
    }
    

    Kesalahan umum

    • Pembagian integer: 5 / 2 adalah 2, bukan 2.5. Cast terlebih dahulu: (double) 5 / 2.
    • Bandingkan String (dan objek lainnya) dengan .equals(), bukan ==.
    • == pada dua objek menguji apakah mereka adalah OBJEK YANG SAMA, bukan apakah mereka terlihat sama.
  • 3 Boolean & seleksi
    3.1

    if / else

    if menjalankan blok ketika kondisi true; else if dan else menambah kasus lebih lanjut. Kondisi masuk ke ( ), blok ke { }.

    public class Main {
        public static void main(String[] args) {
            int score = 72;
            if (score >= 80) {
                System.out.println("A");
            } else if (score >= 60) {
                System.out.println("B");
            } else {
                System.out.println("fail");
            }
        }
    }
    
    if memilih cabang yang benar; else memilih cabang yang salah
    if memilih cabang yang benar; else memilih cabang yang salah
    3.2

    Operator logika & perbandingan

    Bandingkan dengan ==, !=, <, >, <=, >= — perbandingan menghasilkan boolean. Gabungkan dengan && (dan), || (atau), ! (tidak) — operator logika. Untuk Strings, gunakan .equals(...), bukan ==.

    public class Main {
        public static void main(String[] args) {
            int age = 16;
            boolean member = true;
            System.out.println(age >= 18 && member);   // false
            String a = "hi";
            System.out.println(a.equals("hi"));        // true
        }
    }
    
    3.3

    saklar

    switch memilih di antara banyak nilai tetap. Gunakan break untuk meninggalkan case; tanpa itu, eksekusi dapat berlanjut ke case berikutnya. default adalah fallback.

    public class Main {
        public static void main(String[] args) {
            int day = 3;
            switch (day) {
                case 1: System.out.println("Mon"); break;
                case 3: System.out.println("Wed"); break;
                default: System.out.println("other");
            }
        }
    }
    

    Kesalahan umum

    • Kondisi harus berupa boolean; if (x = 5) tidak bisa dikompilasi (gunakan ==).
    • Dalam switch, break, return atau throw dapat menghentikan fall-through. Mencapai case berikutnya tanpa salah satunya melanjutkan eksekusi di sana.
    • && dan || short-circuit. & dan | beroperasi bitwise pada integer; dengan boolean mereka mengevaluasi kedua operand.
  • 4 Perulangan
    4.1

    loop while

    Siklus while berulang selama kondisi true. Ubah sesuatu di dalamnya, atau ia akan berulang selamanya.

    public class Main {
        public static void main(String[] args) {
            int n = 1;
            while (n <= 3) {
                System.out.println(n);
                n++;
            }
        }
    }
    
    while memeriksa kondisi sebelum setiap putaran body
    while memeriksa kondisi sebelum setiap putaran body
    4.2

    loop for

    Siklus for menggabungkan awal, kondisi, dan langkah ke dalam satu baris. Terbaik ketika Anda mengetahui jumlahnya.

    public class Main {
        public static void main(String[] args) {
            for (int i = 0; i < 5; i++) {
                System.out.print(i + " ");
            }
            System.out.println();   // 0 1 2 3 4
        }
    }
    
    4.3

    Akumulasi

    Pola akumulator: mulai variabel sebelum loop, lalu update setiap giliran.

    public class Main {
        public static void main(String[] args) {
            int total = 0;
            for (int i = 1; i <= 5; i++) {
                total += i;
            }
            System.out.println(total);   // 15
        }
    }
    
    4.4

    Perulangan bersarang

    Loop di dalam loop adalah loop bersarang. Loop dalam berjalan penuh pada setiap giliran luar.

    public class Main {
        public static void main(String[] args) {
            for (int r = 0; r < 3; r++) {
                for (int c = 0; c < 3; c++) {
                    System.out.print("*");
                }
                System.out.println();
            }
        }
    }
    

    Kesalahan umum

    • for (int i = 0; i < n; i++) berjalan n kali (0 hingga n - 1); menggunakan <= berjalan satu kali ekstra.
    • Jangan letakkan titik koma tepat setelah for (...) atau while (...) — itu membuat loop kosong.
    • Deklarasikan counter di header for agar scope-nya berakhir dengan loop.
  • 5 String
    5.1

    Method String

    St String adalah teks. Method berguna: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). String bersifat immutable: isinya tidak dapat diubah. Method dapat mengembalikan angka, boolean, atau string; String yang dikembalikan dapat menggunakan kembali objek yang sudah ada.

    public class Main {
        public static void main(String[] args) {
            String s = "Python";
            System.out.println(s.length());          // 6
            System.out.println(s.charAt(0));         // P
            System.out.println(s.substring(0, 3));   // Pyt
            System.out.println(s.toUpperCase());     // PYTHON
        }
    }
    

    Method yang akan Anda gunakan setiap hari:

    Method Makna Contoh → hasil
    .length() berapa banyak karakter "Hi".length() → 2
    .charAt(i) satu karakter "Hi".charAt(0) → H
    .substring(a, b) bagian, berhenti sebelum b "Python".substring(0, 3) → Pyt
    .substring(a) dari a hingga akhir "Python".substring(3) → hon
    .indexOf(x) posisi pertama, -1 jika tidak ada "banana".indexOf("na") → 2
    .equals(s) teks yang sama? "hi".equals("hi") → true
    .compareTo(s) urutan: negatif / 0 / positif "apple".compareTo("banana") → negatif

    compareTo membandingkan unit kode UTF-16 secara leksikografis, dengan sensitif huruf besar/kecil (misalnya, "Z" muncul sebelum "a") — ujian AP menggunakannya untuk pertanyaan pengurutan:

    public class Main {
        public static void main(String[] args) {
            String a = "apple", b = "banana";
            System.out.println(a.compareTo(b) < 0);    // true (apple comes first)
            System.out.println(a.compareTo("apple"));  // 0 (equal)
        }
    }
    
    Key String methods: length, charAt, substring, equals
    Key String methods: length, charAt, substring, equals
    5.2

    Membangun & menelusuri strings

    Gabungkan strings dengan + (konkatenasi). Kunjungi setiap karakter dengan loop dan .charAt(i).

    public class Main {
        public static void main(String[] args) {
            String word = "banana";
            int count = 0;
            for (int i = 0; i < word.length(); i++) {
                if (word.charAt(i) == 'a') count++;
            }
            System.out.println(count);   // 3
        }
    }
    

    Ketika Anda membangun String panjang dalam loop, StringBuilder jauh lebih cepat: append potongan-potongan, lalu panggil .toString() sekali.

    public class Main {
        public static void main(String[] args) {
            StringBuilder sb = new StringBuilder();
            for (int i = 1; i <= 5; i++) {
                sb.append(i).append(" ");
            }
            System.out.println(sb.toString().trim());   // 1 2 3 4 5
        }
    }
    

    Kesalahan umum

    • String bersifat tidak dapat diubah: s.toUpperCase() menghasilkan hasil huruf kapital tanpa mengubah s, sehingga simpan hasilnya.
    • Baca karakter dengan s.charAt(i); panjangnya adalah s.length() (sebuah method, dengan ()).
    • Membangun String dengan += dalam loop besar lambat; gunakan StringBuilder.
  • 6 Array
    6.1

    Array 1-D

    Array menyimpan jumlah nilai tetap dari satu tipe. Index dari 0, dan dapatkan ukuran dengan .length.

    public class Main {
        public static void main(String[] args) {
            int[] scores = {88, 71, 95};
            System.out.println(scores[0]);       // 88
            System.out.println(scores.length);   // 3
            scores[1] = 100;
            System.out.println(scores[1]);       // 100
        }
    }
    
    Primitif memegang nilainya; variabel array memegang referensi ke objek array
    Primitif memegang nilainya; variabel array memegang referensi ke objek array
    6.2

    Algoritma array

    Jelajahi array dengan loop untuk menemukan nilai maksimum, total, jumlah, atau melakukan pencarian. Loop for-each (for (int x : a)) membaca setiap nilai secara berurutan.

    public class Main {
        public static void main(String[] args) {
            int[] a = {3, 9, 2, 7};
            int max = a[0], total = 0;
            for (int x : a) {
                if (x > max) max = x;
                total += x;
            }
            System.out.println(max + " " + total);   // 9 21
        }
    }
    
    6.3

    Array 2-D

    Array 2-D adalah grid baris dan kolom: grid[row][col].

    public class Main {
        public static void main(String[] args) {
            int[][] grid = {{1, 2, 3}, {4, 5, 6}};
            System.out.println(grid[1][2]);   // 6
            for (int[] row : grid) {
                for (int v : row) System.out.print(v + " ");
            }
            System.out.println();             // 1 2 3 4 5 6
        }
    }
    

    Kesalahan umum

    • Ukuran array adalah a.length (tanpa kurung siku, tanpa ()), dan bersifat tetap saat dibuat.
    • Indeks yang valid adalah 0 hingga a.length - 1; a[a.length] akan menyebabkan ArrayIndexOutOfBoundsException.
    • Array baru (int[5]) diisi dengan angka nol, bukan dibiarkan kosong.
  • 7 ArrayList
    7.1

    Dasar-dasar ArrayList

    Sebuah ArrayList adalah daftar yang dapat diperluas — ia membesar dan mengecil saat Anda menambah atau menghapus item. Menyimpan objek, jadi gunakan tipe pembungkus seperti Integer (bukan int). Bagian <Integer> adalah tipe generik. Metode utama: .add(x), .get(i), .set(i, x), .size(), .remove(i).

    import java.util.ArrayList;
    
    public class Main {
        public static void main(String[] args) {
            ArrayList<Integer> nums = new ArrayList<Integer>();
            nums.add(10);
            nums.add(20);
            nums.add(30);
            System.out.println(nums.size());   // 3
            System.out.println(nums.get(1));   // 20
            nums.set(0, 99);
            System.out.println(nums);          // [99, 20, 30]
        }
    }
    
    ArrayList: add, get, size pada daftar dinamis
    ArrayList: add, get, size pada daftar dinamis
    7.2

    Algoritma ArrayList & bug remove

    remove (.remove(i)) menggeser setiap elemen berikutnya satu posisi ke kiri. Jika Anda menghapus sambil menghitung i naik, Anda akan melewatkan elemen berikutnya. Perbaikan: loop mundur, atau jangan increment i setelah operasi remove.

    import java.util.ArrayList;
    
    public class Main {
        public static void main(String[] args) {
            ArrayList<Integer> nums = new ArrayList<Integer>();
            for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
            // Remove every 4 — loop backwards so removals don't skip items.
            for (int i = nums.size() - 1; i >= 0; i--) {
                if (nums.get(i) == 4) nums.remove(i);
            }
            System.out.println(nums);   // [7, 9]
        }
    }
    

    Kesalahan umum

    • ArrayList menggunakan .size(), .get(i) dan .add(...) — bukan [] yang Anda gunakan pada array.
    • Menghapus item sambil looping maju berdasarkan indeks akan melewatkan item berikutnya (bug remove). Loop mundur, atau gunakan iterator.
    • Simpan objek, bukan primitif: gunakan Integer (ArrayList<Integer>), dan Java melakukan auto-boxing pada nilai int (int).
  • 8 Menulis kelas
    8.1

    Field, constructor & method

    Kelas adalah cetak biru untuk objek. Medan menyimpan data, konstruktor mengatur objek baru, dan metodenya adalah tindakan. this.name berarti "name dari objek ini". Buatlah sebuah objek dengan new.

    public class Main {
        public static void main(String[] args) {
            Dog d = new Dog("Rex", 3);
            System.out.println(d.describe());   // Rex is 3 years old
            d.haveBirthday();
            System.out.println(d.describe());   // Rex is 4 years old
        }
    }
    
    class Dog {
        private String name;
        private int age;
    
        public Dog(String name, int age) {   // constructor
            this.name = name;
            this.age = age;
        }
    
        public String describe() {
            return name + " is " + age + " years old";
        }
    
        public void haveBirthday() {
            age++;
        }
    }
    

    Anggota static (static) milik class itu sendiri, bukan salah satu objek. Panggil method static pada nama class—seperti Math.random() (Math.max)—dan field static dibagikan oleh setiap objek:

    public class Main {
        public static void main(String[] args) {
            System.out.println(Counter.made());   // 0
            new Counter();
            new Counter();
            System.out.println(Counter.made());   // 2
        }
    }
    
    class Counter {
        private static int count = 0;      // shared by ALL Counter objects
    
        public Counter() { count++; }
    
        public static int made() {         // called on the class: Counter.made()
            return count;
        }
    }
    
    Field menyimpan state; constructor membangun; method bertindak
    Field menyimpan state; constructor membangun; method bertindak
    8.2

    Enkapsulasi

    Enkapsulasi mengontrol akses ke keadaan objek. Tandai bidang private untuk memblokir akses langsung dari kelas tidak terkait; aksesor (getter) membaca keadaan dan mutator mengubahnya. Setter adalah satu jenis mutator. private tidak memvalidasi nilai: konstruktor dan metode pemutasi memerlukan pengecekan sendiri atau pra-kondisi yang dinyatakan. Contoh ini mengasumsikan start nonnegatif dan penambahan yang muat dalam int; metode depositnya menolak jumlah yang tidak positif.

    public class Main {
        public static void main(String[] args) {
            Account a = new Account(100);
            a.deposit(50);
            a.deposit(-999);                       // rejected by the guard
            System.out.println(a.getBalance());    // 150
        }
    }
    
    class Account {
        private int balance;                       // hidden from outside
    
        public Account(int start) {
            balance = start;
        }
    
        public void deposit(int amount) {
            if (amount > 0) balance += amount;     // this guard checks the deposit amount
        }
    
        public int getBalance() {                  // accessor (getter)
            return balance;
        }
    }
    

    Kesalahan umum

    • Constructor memiliki nama class dan tanpa tipe pengembalian (bahkan bukan void/void).
    • Gunakan this. (this.field) untuk membedakan field dari parameter dengan nama yang sama.
    • Buat field menjadi private (private) dan akses melalui method getter/setter (enkapsulasi).
  • 9 Inheritance & polimorfisme
    9.1

    Pewarisan (Inheritance)

    Pewarisan memungkinkan subclass menggunakan superclass. Tulis class Cat extends Animal dan Cat mewarisi bidang dan metode yang layak dari Animal. Anggota privat tidak diwarisi; konstruktor juga tidak diwarisi. Panggil konstruktor induk dengan super(...).

    public class Main {
        public static void main(String[] args) {
            Cat c = new Cat("Milo");
            c.eat();      // Milo is eating  (inherited from Animal)
            c.speak();    // Meow            (Cat's own method)
        }
    }
    
    class Animal {
        protected String name;
        public Animal(String name) { this.name = name; }
        public void eat() { System.out.println(name + " is eating"); }
    }
    
    class Cat extends Animal {
        public Cat(String name) { super(name); }     // call Animal's constructor
        public void speak() { System.out.println("Meow"); }
    }
    
    Cat dan Dog mewarisi Animal: mereka mewarisi anggotanya dan menambahkan miliknya sendiri
    Cat dan Dog mewarisi Animal: mereka mewarisi anggotanya dan menambahkan miliknya sendiri
    9.2

    Polimorfisme & toString

    Subclass dapat menimpa (override) method untuk menggantikan versi orang tuanya. Polimorfisme berarti variabel bertipe parent (Shape) dapat menyimpan subtype mana pun, dan Java memilih method yang tepat (toString) saat waktu eksekusi. @Override (System.out.println(obj)) secara otomatis memanggil method yang ditimpa (obj.toString()).

    public class Main {
        public static void main(String[] args) {
            Shape[] shapes = { new Circle(2), new Square(3) };
            for (Shape s : shapes) {
                System.out.println(s);          // each calls its own toString
            }
        }
    }
    
    class Shape {
        public String toString() { return "a shape"; }
    }
    
    class Circle extends Shape {
        private int r;
        public Circle(int r) { this.r = r; }
        public String toString() { return "Circle r=" + r; }     // override
    }
    
    class Square extends Shape {
        private int side;
        public Square(int side) { this.side = side; }
        public String toString() { return "Square side=" + side; }   // override
    }
    

    Kesalahan umum

    • Method yang ditimpa harus mencocokkan tanda tangannya persis; tambahkan @Override (@Override) agar compiler menangkap kesalahan.
    • super(...) harus menjadi baris pertama dari constructor subclass.
    • Objek subclass IS-A objek superclass, tetapi sebaliknya tidak.
  • 10 Recursion
    10.1

    Rekursi

    Rekursi adalah method yang memanggil dirinya sendiri. Setiap rekursi memerlukan kasus dasar (kapan berhenti) dan pemanggilan rekursif yang mendekatinya. Tanpa kasus dasar, ia tidak akan pernah berhenti dan menyebabkan stack overflow.

    Stack pemanggilan untuk factorial(3): setiap pemanggilan menunggu, lalu mengembalikan dalam urutan terbalik
    Stack pemanggilan untuk factorial(3): setiap pemanggilan menunggu, lalu mengembalikan dalam urutan terbalik
    public class Main {
        public static void main(String[] args) {
            System.out.println(factorial(5));   // 120
        }
    
        public static int factorial(int n) {
            if (n <= 1) return 1;            // base case
            return n * factorial(n - 1);     // recursive call: n * (n-1)!
        }
    }
    

    Jejakkan: factorial(5) menunggu factorial(4), yang menunggu factorial(3)… hingga factorial(1) mengembalikan 1. Kemudian jawaban dikalikan kembali ke atas: 1 → 2 → 6 → 24 → 120.

    Rekursi juga bekerja pada String—lepas satu karakter setiap pemanggilan:

    public class Main {
        public static void main(String[] args) {
            System.out.println(reverse("PYTHON"));   // NOHTYP
        }
    
        static String reverse(String s) {
            if (s.length() <= 1) return s;               // base case
            return reverse(s.substring(1)) + s.charAt(0);
        }
    }
    

    Merge sort adalah sorting rekursif pada ujian AP: belah array menjadi dua, urutkan masing-masing bagian secara rekursif, lalu gabungkan kedua bagian yang sudah terurut. Berjalan dalam O(n log n)—jauh lebih cepat daripada sorting O(n²) pada array besar.

    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            int[] a = {5, 2, 9, 1, 7, 3};
            mergeSort(a, 0, a.length - 1);
            System.out.println(Arrays.toString(a));   // [1, 2, 3, 5, 7, 9]
        }
    
        static void mergeSort(int[] a, int lo, int hi) {
            if (lo >= hi) return;                 // base case: one element
            int mid = (lo + hi) / 2;
            mergeSort(a, lo, mid);                // sort the left half
            mergeSort(a, mid + 1, hi);            // sort the right half
            merge(a, lo, mid, hi);                // merge the two halves
        }
    
        static void merge(int[] a, int lo, int mid, int hi) {
            int[] tmp = new int[hi - lo + 1];
            int i = lo, j = mid + 1, k = 0;
            while (i <= mid && j <= hi) {
                if (a[i] <= a[j]) tmp[k++] = a[i++];
                else              tmp[k++] = a[j++];
            }
            while (i <= mid) tmp[k++] = a[i++];
            while (j <= hi)  tmp[k++] = a[j++];
            for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
        }
    }
    

    Kesalahan umum

    • Rekursi memerlukan kasus dasar, atau akan menyebabkan StackOverflowError.
    • Setiap pemanggilan rekursif harus bergerak LEBIH DEKAT ke kasus dasar.
    • Jejakkan contoh kecil secara manual untuk memeriksa apakah rekursi mengembalikan nilai yang benar.
    • Dalam merge sort, langkah merge melakukan pekerjaan nyata; rekursi hanya membelah array.
  • 11 Pencarian & pengurutan
    11.1

    Pencarian linear & biner

    Pencarian linear memeriksa setiap elemen — bekerja pada array apa pun. Pencarian biner jauh lebih cepat tetapi memerlukan array terurut: ia melihat nilai tengah, lalu membuang separuh setiap langkah. Keduanya mengembalikan indeks, atau -1 jika tidak ditemukan.

    public class Main {
        public static void main(String[] args) {
            int[] a = {2, 5, 8, 12, 16, 23};      // sorted, so binary search works
            System.out.println(linear(a, 12));    // 3
            System.out.println(binary(a, 12));    // 3
            System.out.println(binary(a, 9));     // -1 (not found)
        }
    
        static int linear(int[] a, int target) {
            for (int i = 0; i < a.length; i++)
                if (a[i] == target) return i;
            return -1;
        }
    
        static int binary(int[] a, int target) {
            int lo = 0, hi = a.length - 1;
            while (lo <= hi) {
                int mid = (lo + hi) / 2;
                if (a[mid] == target) return mid;
                else if (a[mid] < target) lo = mid + 1;
                else hi = mid - 1;
            }
            return -1;
        }
    }
    
    Pencarian biner membagi dua jangkauan setiap langkah, sehingga array terurut dicari dalam O(log n)
    Pencarian biner membagi dua jangkauan setiap langkah, sehingga array terurut dicari dalam O(log n)
    11.2

    Selection & insertion sort

    Selection sort berulang kali menemukan nilai tersisa terkecil dan menukarnya ke depan. Insertion sort mengambil setiap nilai dan menggesernya kembali ke tempatnya di antara nilai-nilai yang sudah terurut.

    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            int[] a = {5, 2, 9, 1, 7};
            for (int i = 0; i < a.length - 1; i++) {
                int min = i;
                for (int j = i + 1; j < a.length; j++)
                    if (a[j] < a[min]) min = j;
                int t = a[min]; a[min] = a[i]; a[i] = t;   // swap into place
            }
            System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
        }
    }
    
    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            int[] a = {5, 2, 9, 1, 7};
            for (int i = 1; i < a.length; i++) {
                int key = a[i], j = i - 1;
                while (j >= 0 && a[j] > key) {    // shift bigger values right
                    a[j + 1] = a[j];
                    j--;
                }
                a[j + 1] = key;                  // drop key into the gap
            }
            System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
        }
    }
    

    Bagaimana kecepatan membandingkan:

    Algorithm Time
    linear search O(n)
    binary search O(log n), hanya array terurut
    selection / insertion sort O(n²)
    merge sort (topik 10) O(n log n)

    Kesalahan umum

    • Pencarian biner hanya berfungsi pada array yang terurut.
    • Pencarian linear adalah O(n); pencarian biner adalah O(log n) tetapi memerlukan pengurutan terlebih dahulu.
    • Selection dan insertion sort adalah O(n²)—mudah dipelajari, lambat pada data besar.
  • 12 File & FRQ
    12.1

    File teks dengan Scanner

    Scanner (Scanner) membaca teks satu baris per baris. Untuk file sungguhan Anda menulis new FileReader(...); (new Scanner(new File("scores.txt"))) di sini kita membungkus Scanner (String) agar contoh berjalan di mana saja. Gunakan nextLine().split() (.split(" ")) untuk memecah baris menjadi bagian-bagian dan Integer.parseInt() (Integer.parseInt(...)) untuk parsing angka dari teks.

    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            // Real file:  Scanner in = new Scanner(new File("scores.txt"));
            String data = "Alice 80\nBob 95\nCara 72";
            Scanner in = new Scanner(data);
            int total = 0, count = 0;
            while (in.hasNextLine()) {
                String line = in.nextLine();
                String[] parts = line.split(" ");      // break the line on the space
                total += Integer.parseInt(parts[1]);
                count++;
            }
            System.out.println("average = " + (total / count));   // average = 82
        }
    }
    
    Scanner membaca baris selama hasNextLine() bernilai true
    Scanner membaca baris selama hasNextLine() bernilai true
    12.2

    Jenis soal FRQ AP

    Ujian AP CS A memiliki empat pertanyaan respons bebas, masing-masing dengan bentuk tetap:

    • Q1 — Metode & kontrol: tulis metode sesuai spesifikasi yang diberikan; perulangan, if, String/Math.
    • Q2 — Desain kelas: tulis satu kelas lengkap (bidang, konstruktor, metode) berdasarkan deskripsi.
    • Q3 — Array / ArrayList: proses array 1-D atau ArrayList (pencarian, penghitungan, membuat daftar baru).
    • Q4 — Array 2-D: jelajahi grid berdasarkan baris dan kolom.

    Keterampilan yang selalu sama: baca spesifikasi, tulis metode tepat seperti yang dijelaskan, kembalikan tipe yang benar.

    public class Main {
        public static void main(String[] args) {
            // Q1 style: implement a method to a spec, then it is tested.
            System.out.println(countEven(new int[]{4, 7, 10, 3, 6}));   // 3
        }
    
        /** Returns how many values in arr are even. */
        public static int countEven(int[] arr) {
            int count = 0;
            for (int x : arr)
                if (x % 2 == 0) count++;
            return count;
        }
    }
    

    Kesalahan umum

    • nextInt() meninggalkan baris baru di belakang, sehingga nextLine() berikutnya membaca baris kosong — bacalah itu terlebih dahulu.
    • Periksa hasNext() sebelum membaca, untuk menghindari keluar dari akhir file.
    • Dalam FRQ, baca header metode dengan teliti: cocokkan tipe kembalian dan parameter secara eksak.

Masuk atau buat akun

IGCSE, A-Level & AP