Основы Java

Что было в блоке 1

Циклы

это такие конструкции, цель которых - повторить выполнение кода несколько раз

if else

??? (x = true) {
//код, если условие x
} 
??? (y = true) { //альтернативная инструкция 
}
??? { // код на случай, если ничего не подошло
} 

switch

??? (выражение) { // выражение обычно short, char, int, String и тд
    case значение1: // сравнивается с выражением (константой)
        // Код, который выполняется, если выражение == значение1
        break; // Обязателен, чтобы не выполнялся следующий case

    case значение2:
    case значение3: // несколько case могут вести к одному блоку кода
        // Код, который выполняется, если выражение == значение2 или выражение == значение3
        break;

    default: // (Необязательный) код, который выполняется по умолчанию
        break; 
}

for

??? (int i = 0; i < 10; i++) { //или number.length вместо 10 
//код цикла, что делать
} 

for (each)

В основном используется для доступа к элементам только для чтения

??? (Тип элемент : коллекцияИлиМассив) {
    // Код, который будет выполнен для каждого элемента
}

while

Для многократного выполнения блока кода, пока заданное условие остается истинным

??? условие {

// код выполняется, потом проверяется на правдивость относительно условия

}

do while

??? {

// Тело цикла - блок кода для выполнения }

??? (условие);

Отличается тем, что его тело (блок кода внутри {}) выполняется как минимум один раз, прежде чем будет проверено какое-либо условие.

Если условие ложно (false), цикл завершается.

Классы

каркасы для всех объектов, образец, по модели которого будет создан нужный объект в памяти; определяет свойства этих объектов

Конструктор

метод, который как раз дает возможность создавать новые объекты и инициализировать их свойства при создании

Метод

конструкция, которая находится внутри класса и дает возможность выполнить какие-то действия/вернуть значения в рамках этого класса

getX

public (или др уровень доступа) int ???X () { 
return x; 
} 

public ТипДанных ???ИмяПоля () {
    return имяПоля;
} 

setX

public void ???X(int x) { 
this.x = x; 
} 

public void ???ИмяПоля(ТипДанных имяПоля) {
this.имяПоля = имяПоля;
}

void обязательно, тк ничего не возвращает, а присваивает значение

Массивы

формат хранения одинаковых типовых данных, где к элементам обращаются по индексу

static 

показывает, что метод или переменная принадлежит классу, а не экземпляру → могут быть использованы без создания объекта

toString()

public String ???() {
 return super.to???(); } // возвращает строковое представление объекта 

Чаще всего переопределяется для предоставления более значимого описания

equals()

public boolean ???(Object obj) { 
return this == obj; 
} // сравнивает текущий объект с переданным 

hashCode()

public int ???() { 
return имяОбъекта.какойКод?(); 
} 

Хеш-код

целое число, представляющее уникальный идентификатор для объекта, используется в различных структурах данных

Класс

??? чего-тоИмя {
// тело - конструкторы и методы, а также переменные для объектов
}

Создание объектов

ClassName dog1 = new ClassName(); // создание нового  

ClassName dog1 = new ClassName("Псинка");// создает и одновременно инициализирует его свойства/значения

dog1.petDescription(); // вызов метода для получения описания питомца 

Создание массивов

int [] numbers = {1, 2, 3, 4, 5}; // с заданными элементами

String [] names = {"Иван", "Мария", "Петр"}; 

String [] names = new String [3]; // создание без инициализации элементов, пока что их значение null

names[0] = "Иван"; 
names[1] = "Мария"; 

Перебор массива

A) for (int i = 0; i < numbers.length; i++) { 

System.out.println(numbers[i]); // эта часть выведет все элементы массива

} 

B) for (int num : numbers) { // улучшенный цикл 
System.out.println(num); 
}

Конструктор

public class ClassName { 
// какие данные, переменные будет принимать
public ClassName(тут тоже эти данные через запятую) {
this.name = Name;
this.age = age; 
    }
} 

после этого в классе Main объекты создаются с переменными просто в скобочке

switch → (как выражение, возвращающее значение)

Object result = ??? (выражение) { 
    case значение1 -> { 
        // Код, который выполняется
        System.out.println("Выбран вариант 1");
        yield "Результат 1"; // 'yield' возвращает значение
    }
    case значение2, значение3 -> { // Несколько значений можно указывать через запятую
        System.out.println("Выбран вариант 2 или 3");
        yield "Результат 2/3";
    }
    default -> { // Если ни один case не совпал с выражением, по умолчанию
        yield "Результат по умолчанию";
    }
};

switch → (как оператор (не возвращает значение))

??? (выражение) {
    case значение A -> System.out.println("Короткое действие A"); // Для одной строки можно без {} и yield
    case значение B -> {
        System.out.println("Действие B, часть 1");
        System.out.println("Действие B, часть 2");
    }
    default -> System.out.println("Действие по умолчанию");
}

Отличие кода от алгоритма

Первое это более конкретная запись, второе - последовательность шагов для решения задачи. Задача второго решить задачу с минимальным аратами ресурсов.

Бинарный поиск

алгоритм для поиска числа в отсортированном массиве, делит числа в массиве пополам и дальше работает с тем, что находится в соответствующей половине до нахождения искомого числа

Имеет отличную асимптотическую сложность, то есть количество операций растёт очень медленно. Это делает его крайне эффективным для больших данных, несмотря на то, что для очень маленьких наборов данных простой (линейный) поиск может быть быстрее из-за более "лёгких" операций.

Бинарный поиск 

private static int ???(int[] sortedArray, int valueToFind, int low, int high) {
        int index = -1;




        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (sortedArray[mid] < valueToFind) {
                low = mid + 1;
            } else if (sortedArray[mid] > valueToFind) {
                high = mid - 1;
            } else if (sortedArray[mid] == valueToFind) {
                index = mid;
                break;
            }
        }
        return index;
    }

О-нотация (асимптотическая сложность)

Способ измерить, насколько "быстрым" или "ресурсоемким" будет алгоритм, когда количество данных, которые он обрабатывает, становится очень большим.; показывает, как время работы (или оперативная память) алгоритма растет в зависимости от размера входных данных – игнорируя то, насколько быстрый у вас компьютер или как хорошо написан код

Random Access Memory

Оперативное Запоминающее Устройство

Кэш-память

Самая быстрая память (рядом с ЦПУ) и очень маленькая. Процессор обращается к ней в первую очередь. Данные здесь обрабатываются мгновенно, что сильно ускоряет алгоритмы, когда данные помещаются в нее.

RAM

Вид памяти, гораздо больше кэша, но медленнее. Это основной "склад" данных для всех программ, с которыми работает компьютер в данный момент. Скорость критична для большинства алгоритмов, когда данные не помещаются в кэш.

Виртуальная память

Вид памяти, который располагается на жестком диске (или SSD) и в тысячи раз медленнее RAM. Используется операционной системой как "расширение" физической RAM, когда ее не хватает. Активное использование сильно замедляет выполнение алгоритмов.

Логарифмическая сложность

Если алгоритм на каждом шаге отбрасывает большую часть (например, половину) N элементов, то его сложность будет O(\log N). С увеличением N алгоритм замедляется крайне незначительно, что делает его очень быстрым для больших объемов данных.

Линейная сложность

Если алгоритм содержит один основной цикл, который полностью перебирает массив из N элементов, то его сложность будет O(N). Чем больше N, тем пропорционально медленнее алгоритм для больших входных данных.

Если алгоритм содержит k вложенных циклов, каждый из которых полностью (или почти полностью) перебирает массив из N элементов, то его сложность будет O(N^k).

Очереди по принципу FIFO (структура данных)

Полезны для задач, в которых важно соблюдение порядка обработки данных: например, в системах печати документов или для обработки запросов к серверу. Принцип напоминает очередь в магазине: кто пришёл первым, будет первым и обслужен.

Очереди по принципу LIFO

Удобны для работы с задачами, требующими обратного порядка выполнения операций: например, при решении выражений. Принцип напоминает работу со стопкой бумаг на столе: бумага, попавшая в стопку последней, будет обработана первой, поскольку находится в стопке выше всех.