public class Pair<K, V> {
    private final K key;
    private final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "(" + key + ", " + value + ")";
    }
}

Pair<String, Integer> person = new Pair<>("John", 30);
System.out.println(person.getKey());   // Выводит: John
System.out.println(person.getValue()); // Выводит: 30

public class Pair<L, R> implements Map.Entry<L, R>, Comparable<Pair<L, R>>, Serializable {
    private static final long serialVersionUID = 1L;
    private final L left;
    private final R right;

    public Pair(L left, R right) {
        this.left = left;
        this.right = right;
    }

    public L getLeft() {
        return left;
    }

    public R getRight() {
        return right;
    }

    @Override
    public int hashCode() {
        return left.hashCode() ^ right.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> pair = (Pair<?, ?>) o;
        return Objects.equals(left, pair.left) &&
               Objects.equals(right, pair.right);
    }

    @Override
    public String toString() {
        return "(" + left + ", " + right + ")";
    }

    @Override
    public int compareTo(Pair<L, R> other) {
        int cmp = ((Comparable<L>) this.left).compareTo(other.left);
        if (cmp != 0) {
            return cmp;
        }
        return ((Comparable<R>) this.right).compareTo(other.right);
    }
}

Object[] pairArray = {"John", 30};
String name = (String) pairArray[0];
Integer age = (Integer) pairArray[1];
В отличие от массива, Pair предоставляет более очевидный и безопасный способ работы с парными значениями.

public class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Методы get, equals, hashCode и другие
}
Если же пара значений не требует дополнительных методов и логики, то Pair — идеальное решение.

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, где каждый объект представляет пару "имя-оценка". Это упрощает доступ к связанной информации и её обработку.