Перейти к содержанию
Предметы
  • 1 Основы Java
    1.1

    Классы, main и output

    Этот сайт компилирует Java, используя правила языка Java 8. Эти автономные примеры помещают метод входа, 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 (одна буква).

    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

    Комментарии и стиль

    Комментарий — это // (одна строка) или /* ... */ (блок). Отступайте код внутри фигурных скобок { }. Имена классов пишутся с заглавной буквы; переменные и методы используют camelCase (первая буква строчная).

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

    Распространенные ошибки

    • Каждая инструкция заканчивается точкой с запятой ;.
    • Значение main должно точно соответствовать public static void main(String[] args).
    • println добавляет новую строку; print нет.
  • 2 Операторы и выражения
    2.1

    Арифметика и присваивание

    Арифметика Java использует + - * / и % (остаток от деления). При двух ints, / — целочисленное деление — оно отбрасывает десятичную часть. +=, -= и ++ — это сокращения.

    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 усечено; используйте double для точного результата
    int/int усечено; используйте double для точного результата
    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() возвращает случайное double от 0.0 до (но не включая) 1.0. Масштабируйте его и приведите к типу, чтобы получить целые числа — это идиома 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.
    • Сравнивайте строки (и другие объекты) с помощью .equals(), а не ==.
    • == на двух объектах проверяет, являются ли они ОДНИМ и ТЕМ ЖЕ объектом, а не то, выглядят ли они одинаково.
  • 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. Объединяйте с && (и), || (или), ! (не) — логическими операторами. Для Strings используйте .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 (продолжение выполнения). Достижение следующей ветки без одного из них продолжает выполнение там.
    • && и || используют short-circuit (короткое замыкание). & и | выполняют побитовые операции над целыми числами; с логическими типами они вычисляют оба операнда.
  • 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 упаковывает начало, условие и шаг в одну строку. Лучше всего, когда вы знаете количество.

    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); использование <= выполнится на один раз больше.
    • Не ставьте точку с запятой сразу после for (...) или while (...) — это создаст пустой цикл.
    • Объявляйте счетчик в заголовке for, чтобы его область действия закончилась вместе с циклом.
  • 5 Строки
    5.1

    Методы String

    Строка String — это текст. Полезные методы: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). Строки неизменяемы — каждый метод возвращает новую строку.

    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) один символ "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 сортирует строки в лексикографическом порядке — на экзамене 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)
        }
    }
    
    Ключевые методы String: length, charAt, substring, equals
    Ключевые методы String: 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
        }
    }
    

    Когда вы строите длинную строку в цикле, StringBuilder работает намного быстрее: добавляйте части, затем вызывайте .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.charAt(i); длина равна s.length() (метод, с ()).
    • Построение строки с помощью += в большом цикле медленнее; используйте StringBuilder.
  • 6 Массивы
    6.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-мерные

    A 2-D array is a grid of rows and columns: 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> является параметром типа (generic type). Ключевые методы: .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) сдвигает все последующие элементы на одну позицию влево. Если удалять элемент, двигаясь по индексу i вверх, вы пропустите следующий элемент. Исправление: итерироваться с конца или не увеличивать счетчик 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 автоматически выполняет автоупаковку (auto-boxing) значений 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, чтобы запретить прямой доступ из несвязанных классов; аксессор (getter) читает состояние, а мутатор изменяет его. Сеттер является одним из видов мутаторов. private не проверяет корректность значений: конструкторы и мутающие методы требуют собственных проверок или заявленных предусловий. Данный пример предполагает неотрицательное значение start и сложения, укладывающиеся в диапазон int; его метод deposit отклоняет неположительные суммы.

    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. Приватные члены не наследуются; конструкторы также не наследуются. Вызовите конструктор родителя с помощью 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(...) должно быть первой строкой конструктора подкласса.
    • Объект подкласса IS-A объекту родительского класса, но не наоборот.
  • 10 Рекурсия
    10.1

    Рекурсия

    Рекурсия — это метод, вызывающий сам себя. Каждая рекурсия требует базового случая (когда остановиться) и рекурсивного вызова, который приближает решение к базовому случаю. Без базового случая она никогда не остановится и завершится ошибкой переполнения стека (stack overflow).

    Стек вызовов для 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)!
        }
    }
    

    Отслеживайте выполнение: factorial(5) ждет результата от factorial(4), который ждет от factorial(3)… вплоть до того, как factorial(1) вернет значение 1. Затем ответы перемножаются обратно вверх: 1 → 2 → 6 → 24 → 120.

    Рекурсия также работает со строками — отрезайте по одному символу при каждом вызове:

    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) — тема экзамена AP: разделите массив пополам, отсортируйте каждую половину рекурсивно, затем объедините две отсортированные половины. Он работает за 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.
    • Каждый рекурсивный вызов должен приближаться К базовому случаю.
    • Отследите небольшой пример вручную, чтобы убедиться, что рекурсия возвращает правильное значение.
    • В алгоритме слияния именно шаг объединения (merge) выполняет основную работу; рекурсия лишь делит массив.
  • 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;
        }
    }
    
    Бинарный поиск уменьшает диапазон вдвое на каждом шаге, поэтому отсортированный массив searched за O(log n)
    Бинарный поиск уменьшает диапазон вдвое на каждом шаге, поэтому отсортированный массив searched за O(log n)
    11.2

    Выборочная и сортировка вставками

    Сортировка выбором (selection sort) многократно находит наименьшее оставшееся значение и меняет его местами с первым элементом. Сортировка вставками (insertion sort) берет каждое значение и перемещает его назад на нужное место среди уже отсортированных элементов.

    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

    Объект Scanner читает текст построчно. Для работы с реальным файлом вы пишете new Scanner(new File("scores.txt")); здесь мы оборачиваем String, чтобы пример работал в любой среде. Используйте .split(" ") для разделения строки на части и Integer.parseInt(...) для преобразования текста в число.

    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 читает строки, пока hasNextLine возвращает true
    Scanner читает строки, пока hasNextLine возвращает true
    12.2

    Типы вопросов FRQ экзамена AP

    Экзамен AP CS A включает четыре вопроса с развернутым ответом, каждый из которых имеет фиксированную форму:

    • 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