Pair<String, Integer> pair = new Pair<>("John", 30);
В этом примере создается пара, где ключом (или первым элементом) является строка "John", а значением (или вторым элементом) — целое число 30.

String name = pair.getKey();  // "John"
Integer age = pair.getValue(); // 30
Эти методы позволяют извлекать значения из объекта Pair, что удобно при работе с парными данными.

Pair<String, Integer> pair1 = new Pair<>("John", 30);
Pair<String, Integer> pair2 = new Pair<>("John", 30);

boolean areEqual = pair1.equals(pair2); // true
Метод equals() сравнивает два объекта Pair на предмет их равенства, основываясь на значениях ключа и значения. hashCode() возвращает хэш-код объекта, что важно для корректной работы с хешированными коллекциями.

System.out.println(pair.toString()); // (John, 30)
Этот метод полезен для вывода информации о паре в читаемом формате.

Pair<String, Integer> pair1 = new Pair<>("John", 30);
Pair<String, Integer> pair2 = new Pair<>("Alice", 25);

int comparisonResult = pair1.compareTo(pair2); // результат зависит от реализации Comparable
Этот метод особенно полезен, когда нужно отсортировать список объектов Pair по ключам или значениям.

public class MinMaxExample {
    public static Pair<Integer, Integer> findMinMax(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("Array cannot be null or empty");
        }

        int min = array[0];
        int max = array[0];

        for (int num : array) {
            if (num < min) {
                min = num;
            }
            if (num > max) {
                max = num;
            }
        }

        return new Pair<>(min, max);
    }

    public static void main(String[] args) {
        int[] numbers = {3, 5, 1, 8, -2, 7};
        Pair<Integer, Integer> result = findMinMax(numbers);
        System.out.println("Min: " + result.getKey());
        System.out.println("Max: " + result.getValue());
    }
}
Этот пример показывает, как метод findMinMax возвращает объект Pair, содержащий минимальное и максимальное значения массива. Это более элегантный способ возврата двух связанных значений по сравнению с использованием массивов или пользовательских классов.

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

public class StudentGradesExample {
    public static void main(String[] args) {
        List<Pair<String, Integer>> studentGrades = new ArrayList<>();

        studentGrades.add(new Pair<>("Alice", 85));
        studentGrades.add(new Pair<>("Bob", 90));
        studentGrades.add(new Pair<>("Charlie", 78));

        for (Pair<String, Integer> pair : studentGrades) {
            System.out.println("Student: " + pair.getKey() + ", Grade: " + pair.getValue());
        }
    }
}
В этом примере мы создаем список студентов и их оценок, используя класс Pair. Это позволяет легко хранить и обрабатывать пары данных, связанных логически.

import java.util.HashMap;
import java.util.Map;

public class GraphExample {
    public static void main(String[] args) {
        Map<Pair<String, String>, Integer> graph = new HashMap<>();

        graph.put(new Pair<>("A", "B"), 5);
        graph.put(new Pair<>("A", "C"), 10);
        graph.put(new Pair<>("B", "C"), 3);

        for (Map.Entry<Pair<String, String>, Integer> entry : graph.entrySet()) {
            Pair<String, String> edge = entry.getKey();
            Integer weight = entry.getValue();
            System.out.println("Edge from " + edge.getKey() + " to " + edge.getValue() + " has weight " + weight);
        }
    }
}
Этот пример показывает, как Pair может быть использован в качестве ключа в HashMap, чтобы хранить ребра графа и их веса. Это полезно для представления связей между узлами в графе.

public class CombineArraysExample {
    public static List<Pair<String, Integer>> combine(String[] names, int[] grades) {
        List<Pair<String, Integer>> result = new ArrayList<>();
        for (int i = 0; i < names.length; i++) {
            result.add(new Pair<>(names[i], grades[i]));
        }
        return result;
    }

    public static void main(String[] args) {
        String[] students = {"Alice", "Bob", "Charlie"};
        int[] grades = {85, 90, 78};

        List<Pair<String, Integer>> studentGrades = combine(students, grades);

        for (Pair<String, Integer> pair : studentGrades) {
            System.out.println(pair.getKey() + ": " + pair.getValue());
        }
    }
}
Этот код объединяет два массива в список объектов Pair, где каждый объект представляет пару "имя-оценка". Это упрощает доступ к связанной информации и её обработку.

int x = 10;
В этом примере переменной x присваивается значение 10. Оператор присваивания не возвращает никаких значений, его задача — изменить состояние переменной.

int a = 5;
a += 3; // теперь a равно 8

int b = 10;
b -= 4; // теперь b равно 6

int c = 2;
c *= 3; // теперь c равно 6

int e = 7;
e %= 3; // теперь e равно 1 (остаток от деления 7 на 3)

int x = 5;
int y = ++x; // сначала x увеличивается до 6, потом присваивается y, так что y равно 6

int x = 5;
int y = x++; // сначала y присваивается значение x (5), затем x увеличивается до 6

int x = 5;
int y = --x; // сначала x уменьшается до 4, потом присваивается y, так что y равно 4

int x = 5;
int y = x--; // сначала y присваивается значение x (5), затем x уменьшается до 4

public class Main {
    public static void main(String[] args) {
        int x = 5;
        int y = x++ + ++x + --x + x--;
        System.out.println(y);
    }
}

public class AssignmentExample {
    public static void main(String[] args) {
        int x = 10;  // присваивание 10 переменной x
        System.out.println("x = " + x);
    }
}
Здесь переменной x присваивается значение 10. Это базовый пример присваивания, где переменная получает конкретное значение, которое позже может быть использовано в программе. Данный оператор является основой для дальнейших операций с переменными.

public class ExpressionAssignmentExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c = a + b;  // c присваивается результат сложения a и b
        System.out.println("c = " + c); // c равно 15
    }
}
В этом примере переменной c присваивается результат сложения переменных a и b. Это демонстрирует, что оператор присваивания может работать с выражениями и вычислениями, упрощая процесс программирования.

public class CompoundAssignmentExample {
    public static void main(String[] args) {
        int x = 10;
        x += 5;  // эквивалентно x = x + 5
        System.out.println("x = " + x); // теперь x равно 15
    }
}
Здесь используется оператор +=, который одновременно добавляет значение к переменной x и присваивает результат. Это сокращает запись x = x + 5 до более компактной формы.

public class CompoundAssignmentExample2 {
    public static void main(String[] args) {
        int a = 6;
        a *= 3;  // эквивалентно a = a * 3
        System.out.println("a = " + a); // a равно 18

        int b = 18;
        b /= 6;  // эквивалентно b = b / 6
        System.out.println("b = " + b); // b равно 3
    }
}
Операторы *= и /= работают аналогично: они выполняют умножение и деление соответственно, а затем присваивают результат переменной.

public class IncrementExample {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {  // инкремент i после каждой итерации
            System.out.println("i = " + i);
        }
    }
}
В этом примере цикл for использует постфиксный инкремент i++ для увеличения счётчика на 1 после каждой итерации. Это классический случай использования оператора инкремента в циклах.

public class DecrementExample {
    public static void main(String[] args) {
        int count = 5;
        while (count > 0) {
            System.out.println("Count = " + count);
            count--;  // декремент после каждой итерации
        }
    }
}
Здесь оператор декремента count-- уменьшает значение переменной count на единицу после каждой итерации цикла. Цикл продолжается до тех пор, пока значение переменной не станет меньше или равно нулю.

public class PrefixPostfixExample {
    public static void main(String[] args) {
        int x = 5;
        
        // Постфиксный инкремент
        int y = x++;  // сначала y присваивается 5, затем x увеличивается до 6
        System.out.println("x = " + x); // x равно 6
        System.out.println("y = " + y); // y равно 5
        
        // Префиксный инкремент
        int z = ++x;  // сначала x увеличивается до 7, затем z присваивается 7
        System.out.println("x = " + x); // x равно 7
        System.out.println("z = " + z); // z равно 7
    }
}
В этом примере видно, как постфиксная форма x++ возвращает текущее значение переменной, а затем увеличивает его, в то время как префиксная форма ++x сначала увеличивает значение, а затем возвращает его. Это может быть важно при работе с выражениями, где последовательность вычислений имеет значение.

public class ComplexExpressionExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int result = a++ + ++b;  // a увеличивается после вычисления, b - до
        System.out.println("a = " + a); // a теперь равно 6
        System.out.println("b = " + b); // b теперь равно 11
        System.out.println("result = " + result); // результат равен 16 (5 + 11)
    }
}
Этот пример показывает, как операторы инкремента могут взаимодействовать с другими операторами в сложных выражениях. Здесь постфиксный инкремент a++ использует старое значение a в выражении, а префиксный инкремент ++b сразу увеличивает значение b.

public class MethodAssignmentExample {
    public static void main(String[] args) {
        int x = 10;
        int y = increment(x);  // вызов метода increment
        System.out.println("x = " + x); // x не изменилось, так как примитивы передаются по значению
        System.out.println("y = " + y); // результат работы метода y равно 11
    }

    public static int increment(int num) {
        return ++num;  // префиксный инкремент увеличивает значение num
    }
}
В этом примере метод increment() использует префиксный инкремент для увеличения значения аргумента. Однако важно отметить, что изменения, произведенные внутри метода, не влияют на исходное значение переменной x, так как примитивные типы в Java передаются по значению.

public class ArrayAssignmentExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] += 1;  // увеличиваем каждый элемент массива на 1
        }
        
        for (int num : numbers) {
            System.out.println(num);  // вывод обновленных значений
        }
    }
}
Здесь оператор присваивания += используется для изменения значений элементов массива. Каждый элемент увеличивается на 1, и результат выводится на экран.

public class ImplicitCastingExample {
    public static void main(String[] args) {
        int intValue = 100;
        double doubleValue = intValue;  // неявное приведение от int к double
        System.out.println("int value: " + intValue);
        System.out.println("double value: " + doubleValue);  // выводится 100.0
    }
}
В этом примере значение переменной intValue типа int автоматически преобразуется в doubleValue типа double без потери данных.

public class ExplicitCastingExample {
    public static void main(String[] args) {
        double doubleValue = 9.78;
        int intValue = (int) doubleValue;  // явное приведение от double к int
        System.out.println("double value: " + doubleValue);
        System.out.println("int value: " + intValue);  // выводится 9 (часть дроби теряется)
    }
}
Здесь мы явно привели тип double к типу int. В результате теряется дробная часть, и остаётся только целое значение.

public class PrimitiveCastingExample {
    public static void main(String[] args) {
        byte byteValue = 10;
        int intValue = byteValue;  // неявное приведение от byte к int
        System.out.println("int value: " + intValue);

        int anotherIntValue = 100;
        byte anotherByteValue = (byte) anotherIntValue;  // явное приведение от int к byte
        System.out.println("byte value: " + anotherByteValue);
    }
}
В первом случае происходит автоматическое расширение типа, так как int больше, чем byte. Во втором случае требуется явное приведение, поскольку возможна потеря данных при сужении типа int до byte.

class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class UpcastingExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog;  // неявное приведение Dog к Animal (upcasting)
        animal.makeSound();  // выводится "Bark", так как объект на самом деле Dog
    }
}
В данном случае объект Dog приводится к типу Animal. Это возможно, так как Dog является наследником Animal, и вызов метода makeSound() все равно приведет к выполнению метода класса Dog.

class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Bark");
    }
}

public class DowncastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog();  // upcasting
        Dog dog = (Dog) animal;  // downcasting
        dog.bark();  // теперь можно вызвать методы класса Dog
    }
}
Здесь объект типа Animal приводится к Dog. Такое приведение должно быть явным, потому что не каждый объект Animal может быть приведен к Dog. Если бы объект на самом деле не был экземпляром Dog, это вызвало бы ошибку во время выполнения.

interface Walkable {
    void walk();
}

class Human implements Walkable {
    @Override
    public void walk() {
        System.out.println("Human walking");
    }
}

public class InterfaceCastingExample {
    public static void main(String[] args) {
        Human human = new Human();
        Walkable walkable = human;  // неявное приведение к интерфейсу
        walkable.walk();  // вызов метода интерфейса
    }
}
В этом примере объект класса Human приводится к интерфейсу Walkable, что позволяет вызвать методы интерфейса, реализованные в классе.