import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "cherry", "apple", "date"));
        Collections.sort(list);
        list.removeIf(s -> s.startsWith("a"));
        System.out.println(list);
    }
}

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 на единицу после каждой итерации цикла. Цикл продолжается до тех пор, пока значение переменной не станет меньше или равно нулю.