コンテンツへスキップ
科目
  • 1 Javaの基礎
    1.1

    クラス、メイン & 出力

    このサイトはJava 8言語規則でJavaをコンパイルします。これらの単独例では、エントリメソッドである main をクラス内に配置しています。ヘルパークラスやメソッドのみ回答には独自の main は必要ありません。 System.out.println(...) は行を出力し、 System.out.print(...) は改行なしで出力します。

    public class Main {
        public static void main(String[] args) {
            System.out.println("Hello, world!");
            System.out.println("I am learning Java.");
        }
    }
    
    • Javaはコンパイルされる: コンパイラーが整個プログラムをチェックしてから実行する。
    • 宣言、代入、メソッド呼び出し、return 文はセミコロン ; で終わります。if 、for 、またはwhile ブロックは中括号を使用しますが、閉じる中括号があるからといってセミコロンを追加しないでください。
    この単独Java 8 例はクラス内でmainを定義しています
    この単独Java 8 例はクラス内でmainを定義しています
    1.2

    変数 & プリミティブ型

    変数は型を宣言する必要があります。一般的なプリミティブ型: int (整数), double (小数点付き数値), boolean (true/false), char (1つのUTF-16 コード単位; 一部の文字は2つ必要)。

    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

    コメント & スタイリング

    コメントは // (1行) または /* ... */ (ブロック) である。波括弧 { } の中のコードはインデントする。クラス名は大文字で始め、変数とメソッドはキャメルケース(小文字開始)を使用する。

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

    ** 一般的なミス **

    • 宣言、代入、メソッド呼び出しおよび return 文は ; で終わります; コントロールフローブロックには追加のセミコロンは不要です。
    • 標準的なJavaの 8 エントリーポイント public static void main(String[] args) を使用してください; パラメータ名は異なり、 String... args も有効です。
    • println は新しいラインを追加します; print は追加しません。
  • 2 演算子と式
    2.1

    演算 & 代入

    Javaの演算では + - * / と % (剰余) を使う。2つの int に対して、 / は整数除法であり、小数点以下を切り捨てる。 +=, -=, ++ はショートカットである。

    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 truncates; involve a double for a real quotient
    int/int truncates; involve a double for a real quotient
    2.2

    オブジェクトの使用: String, Math, ラッパー

    いくつかの値はメソッドを持つオブジェクトである。 String には .length(), .substring(), .toUpperCase() がある。 Math には Math.max, Math.sqrt, Math.pow がある。ラッパークラス (Integer, Double) はプリミティブをラップする — 例として 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() は 0.0 から (1.0 は含まない) までのランダムな double を返す。スケールしてキャストすると整数になる — これは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) と Integer.MIN_VALUE は int の限界であり、それを超えるとオーバーフローして値が巻き戻る。
    • どのオブジェクトも指していないオブジェクト変数は null を持ち、それに対してメソッドを呼び出すと NullPointerException がスローされる。
    2.3

    キャスト & タイプ変換

    キャストは値の型を変える。 (int) は小数点以下を切り捨て、精确な結果が必要な場合に (double) は整数除法を避ける。

    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
        }
    }
    

    ** 一般的なミス **

    • 整数除法: 5 / 2 は 2 であり、 2.5 ではない。先にキャストする: (double) 5 / 2。
    • String(および他のオブジェクト)を比較する際は、.equals() を使い、== を使わないでください。
    • 2つのオブジェクトに対する == は、それらが同じオブジェクトかどうかをテストし、見た目上等価かどうかをテストするものではない。
  • 3 ブール値と選択構造
    3.1

    if / else

    if は条件が真のときにブロックを実行し、 else if と else はより多くのケースを追加する。条件は ( ) に、ブロックは { } に置く。

    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は真の分支を選択し、elseは偽の分支を選択
    ifは真の分支を選択し、elseは偽の分支を選択
    3.2

    論理演算子 & 比較

    ==, !=, <, >, <=, >= で比較する — 比較は boolean を返す。 && (and)、 || (or)、 ! (not) で組み合わせる — これらは論理演算子である。 String については、 == ではなく .equals(...) を使用すること。

    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

    スイッチ

    switch は多数の固定値の中から一つを選びます。 break を使用してケースを抜けます; それがない場合、実行は次のケースに続くことがあります。 default はフォールバックです。

    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");
            }
        }
    }
    

    ** 一般的なミス **

    • 条件は必ず boolean でなければならず、 if (x = 5) はコンパイルできない ( == を使用する)。
    • switch , break , return または throw のいずれかではfall-throughを停止できます。それなしで次のケースに到達すると、そこで実行が続きます。
    • && と || はショートcircuitsします。 & と | は整数に対してビット演算を行います; ブーリアンの場合、両方の演算子を評価します。
  • 4 ループ
    4.1

    while ループ

    while ループは条件が真の間繰り返される。内部で何かを変化させない限り、無限ループとなる。

    public class Main {
        public static void main(String[] args) {
            int n = 1;
            while (n <= 3) {
                System.out.println(n);
                n++;
            }
        }
    }
    
    while ループは本体の各反復の前に条件をチェックします
    while ループは本体の各反復の前に条件をチェックします
    4.2

    for ループ

    for ループは初期化、条件、ステップを1行にまとめる。回数がわかっている場合に最適である。

    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

    蓄積

    アクセムレーターパターン: ループの前に変数を初期化し、毎回更新する。

    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

    ネストループ

    ループ内のループはネストループである。外側のループの各反復ごとに内側のループが完全に実行される。

    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();
            }
        }
    }
    

    ** 一般的なミス **

    • for (int i = 0; i < n; i++) は n 回実行する (0 から n - 1); <= を使うと1回多く回る。
    • for (...) または while (...) の直後に半角カンマを置かない — 空のループになってしまう。
    • カウンターを for ヘッダー内で宣言し、そのスコープがループと一致するようにする。
  • 5 文字列
    5.1

    String メソッド

    String はテキストです。便利なメソッド: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...) 。文字列は不変です: 内容を変更することはできません。メソッドは数値、ブーリアンまたは文字列を返すことができ、返されたStringは既存のオブジェクトを再利用することがあります。

    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
        }
    }
    

    毎日使うメソッド:

    メソッド 意味 例 → 結果
    .length() 文字数 "Hi".length() → 2
    .charAt(i) 1文字目 "Hi".charAt(0) → H
    .substring(a, b) 部分、 b より前に停止 "Python".substring(0, 3) → Pyt
    .substring(a) a から末尾まで "Python".substring(3) → hon
    .indexOf(x) 最初の位置、存在しない場合は -1 "banana".indexOf("na") → 2
    .equals(s) 同じテキスト? "hi".equals("hi") → true
    .compareTo(s) 順序: 負 / 0 / 正 "apple".compareTo("banana") → 負

    compareTo はUTF-16 コード単位を辞書順で比較し、大文字小文字を区別します(例: "Z" は "a" より前に来ます)— AP試験では並べ替えの質問にこれを使用します:

    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

    文字列の構築 & 走査

    + (連結) で文字列をつなぐ。ループで各文字を訪問し .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
        }
    }
    

    ループで長いStringを構築する場合、 StringBuilder は遥かに速い: パーツをoonし、最後に .toString() を一度だけ呼び出す。

    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
        }
    }
    

    ** 一般的なミス **

    • 文字列は不変です: s.toUpperCase() は大文字の結果を返しますが s は変更しないため、結果を保存してください。
    • s.charAt(i) で文字を読み取り、長さは s.length() (メソッドであり、 () を持つ)。
    • 大きなループで += を使って文字列を構築するのは遅い; StringBuilder を使うこと。
  • 6 配列
    6.1

    1次元配列

    配列は1つの型の固定個数の値を保持する。インデックスは 0 から始まり、 .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
        }
    }
    
    プリミティブは値そのものを持ち、配列変数は配列オブジェクトへの参照を持ちます
    プリミティブは値そのものを持ち、配列変数は配列オブジェクトへの参照を持ちます
    6.2

    配列アルゴリズム

    ループで配列を巡回して最大値、合計、カウント、または検索を行います。for-eachループ(for (int x : a))は順に各値を読み取ります。

    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

    2次元配列

    2次元配列は行と列のグリッドです: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
        }
    }
    

    ** 一般的なミス **

    • 配列のサイズは a.length です(角括弧や () は含みません)、作成時に固定されます。
    • 有効なインデックスは 0 から a.length - 1 で、a[a.length] を使用すると ArrayIndexOutOfBoundsException が発生します。
    • 新規の int[5] は空ではなくゼロで埋められます。
  • 7 ArrayList
    7.1

    ArrayListの基礎

    ArrayList は可変長リストであり、要素を追加または削除するたびに伸縮します。オブジェクトを格納するため、Integer (int ではない)のようなラッパー型を使用します。<Integer> の部分はジェネリックタイプです。主要なメソッド:.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
    ArrayList: 可変長リストにおける add, get, size
    7.2

    ArrayListのアルゴリズムとremoveのバグ

    .remove(i) はそれ以降のすべての要素を1つ左へシフトします。i で上向きにカウントしながら削除すると、次の要素をスキップしてしまいます。修正法:ループを逆方向に行うか、remove後に i を増減させないこと。

    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]
        }
    }
    

    ** 一般的なミス **

    • ArrayList は .size(), .get(i), .add(...) を使用し、配列で行う [] を使用しません。
    • インデックスによる前向きループ中に要素を削除すると、次の要素がスキップされます(removeのバグ)。ループを逆方向にするか、イテレータを使用してください。
    • プリミティブではなくオブジェクトを格納します:ArrayList<Integer> を使用し、Javaは int の値を自動ボックス化します。
  • 8 クラスの記述
    8.1

    フィールド、コンストラクタ、メソッド

    クラスはオブジェクトのための設計図です。フィールドはデータを格納し、コンストラクタは新しいオブジェクトを初期化し、メソッドは動作を表します。this.name は「このオブジェクトの name 」を意味します。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++;
        }
    }
    

    static メンバーは特定のオブジェクトではなくクラス自体に属します。クラス名に対してスタティックメソッドを呼び出します — Math.max のように — スティックフィールドはすべてのオブジェクト間で共有されます:

    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;
        }
    }
    
    フィールドは状態を格納;コンストラクタは構築;メソッドは実行
    フィールドは状態を格納;コンストラクタは構築;メソッドは実行
    8.2

    カプセル化

    カプセル化はオブジェクトの状態へのアクセスを制御します。関連する他のクラスからの直接アクセスをブロックするために、フィールドを private にマークします。アクセサ(ゲッター)は状態を読み取り、ミューテータは変更します。セットメソッドはミューテータの一種です。 private は値を検証しません:コンストラクタとミューティングメソッドは独自のチェックや明示された前条件を持つ必要があります。この例は非負の start と、int に収まる加算を前提としています;そのdepositメソッドは正でない amounts を拒否します。

    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;
        }
    }
    

    ** 一般的なミス **

    • コンストラクタにはクラス名があり、返り値の型はありません(void でさえありません)。
    • 同名のパラメータと区別するために this.field を使用します。
    • フィールドを private にして、getter/setterメソッドを通じてアクセスします(カプセル化)。
  • 9 継承と多様性(ポリモフィズム)
    9.1

    継承

    継承によりサブクラスはスーパークラスの機能を再利用できます。 class Cat extends Animal を書き、 Cat は Animal から適切なフィールドとメソッドを継承します。privateメンバーは継承されず、コンストラクタも継承されません。親コンストラクタを 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とDogがAnimalを拡張:メンバーを継承して独自のものを追加
    CatとDogがAnimalを拡張:メンバーを継承して独自のものを追加
    9.2

    ポリモーフィズムとtoString

    サブクラスはメソッドをオーバーライドして親のバージョンを置き換えることができます。ポリモーフィズムとは、Shape 変数がどのサブタイプでも保持でき、Javaが実行時に適切な toString を選択することです。System.out.println(obj) は自動的に 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
    }
    

    ** 一般的なミス **

    • オーバーライドされたメソッドは签名を正確に一致させる必要があり、@Override を追加してコンパイラがミスに気づくようにします。
    • super(...) はサブクラスのコンストラクタの最初の行でなければなりません。
    • サブクラスのオブジェクトはスーパークラスのオブジェクトですが、その逆ではありません。
  • 10 再帰
    10.1

    再帰

    再帰とは、メソッドが自身を呼び出すことです。すべての再帰には、停止すべきタイミングを示すベースケースと、それに近づくための再帰呼び出しが必要です。ベースケースがない場合、止まらず スタックオーバーフロー でクラッシュします。

    factorial(3)のコールスタック:各呼び出しは待機し、逆順で戻ります
    factorial(3)のコールスタック:各呼び出しは待機し、逆順で戻ります
    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)!
        }
    }
    

    Trace it: factorial(5) waits for factorial(4), which waits for factorial(3)… down to factorial(1) returning 1. Then the answers multiply back up: 1 → 2 → 6 → 24 → 120.

    再帰は文字列にも適用可能 — 各呼び出しで1文字ずつ取り除きます:

    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);
        }
    }
    

    マージソートはAP試験で扱われる再帰ソートです:配列を半分に分割し、それぞれを再帰的にソートした上で、2つのソート済み部分合并します。O(n log n)で動作し、大規模な配列における O(n²) ソートよりもはるかに高速です。

    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];
        }
    }
    

    ** 一般的なミス **

    • 再帰にはベースケースが必要であり、そうでなければ StackOverflowError が発生する。
    • 各再帰呼び出しは必ずベースケースに近づける必要があります。
    • 再帰が正しい値を返すかどうか確認するために、小さな例を手動でトレースしてください。
    • マージソートにおいて、マージステップが実際の処理を行い、再帰は単に配列を分割するだけです。
  • 11 検索とソート
    11.1

    線形探索と二分探索

    線形探索はすべての要素を確認するため、どんな配列でも機能します。二分探索は遥かに高速ですが、ソート済みの配列が必要です:中央を見ることで、各ステップで半分を破棄します。両方ともインデックスを返しますが、見つけられない場合は -1 を返します。

    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;
        }
    }
    
    二分探索は各ステップで範囲を半分にするため、ソート済み配列の探索は O(log n)
    二分探索は各ステップで範囲を半分にするため、ソート済み配列の探索は O(log n)
    11.2

    セレクションソートと挿入ソート

    セレクションソートは残りの最小値を繰り返し見つけて先頭に交換します。挿入ソートは各値を取り出して、既にソート済みの値の間で正しい位置にスライドさせて挿入します。

    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]
        }
    }
    

    速度比較:

    アルゴリズム 時間
    線形探索 O(n)
    二分探索 O(log n)、ソート済み配列のみ
    セレクション/挿入ソート O(n²)
    マージソート (トピック10) O(n log n)

    ** 一般的なミス **

    • 二分探索はソート済みの配列でのみ機能します。
    • 線形探索は O(n)、二分探索は O(log n) ですが、事前にソートする必要があります。
    • セレクションソートと挿入ソートは O(n²) で、理解しやすいものの、大規模データでは遅いです。
  • 12 ファイルとFRQ(自由回答問題)
    12.1

    Scannerを用いたテキストファイル

    A Scanner reads text one line at a time. For a real file you write new Scanner(new File("scores.txt")); here we wrap a String so the example runs anywhere. Use .split(" ") to split a line into parts and Integer.parseInt(...) to parse a number from text.

    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 reads lines while hasNextLine is true
    Scanner reads lines while hasNextLine is true
    12.2

    AP FRQの問題タイプ

    AP CS A試験には4つの自由記述問題があり、それぞれ固定された形式です:

    • Q1 — メソッドと制御: 指定された仕様に基づいてメソッドを記述します。ループ、if、String/Math。
    • Q2 — クラス設計: 説明に基づき、完全なクラス(フィールド、コンストラクタ、メソッド)を記述します。
    • Q3 — アレイ / ArrayList: 1次元アレイまたはArrayListを処理する(検索、カウント、新しいリストの構築)。
    • Q4 — 2次元アレイ: グリッドを行と列で遍历する。

    技能は常に同じです:仕様を読み取り、指示通りに正確にメソッドを記述し、正しい型を返すこと。

    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;
        }
    }
    

    ** 一般的なミス **

    • nextInt()は改行コードを残すため、続くnextLine()は空の行として読み取ります—先にそれを読み取って消去してください。
    • ファイルの末尾を超えないよう、読み取る前にhasNext()をチェックしてください。
    • FRQではメソッドヘッダーを注意深く読みます:返り値の型とパラメータが完全に一致しているか確認してください。

ログインまたはアカウント作成

IGCSE, A-Level & AP