интересная задача с массивами

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;
 
public class Main {
    public static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }
 
    public static <T extends Comparable<? super T>> void sort(T[] array) {
        for (int i = 0; i < array.length - 1; ++i) {
            int minPos = i;
            for (int j = i + 1; j < array.length; ++j) {
                if (array[j].compareTo(array[minPos]) < 0) {
                    minPos = j;
                }
            }
            swap(array, minPos, i);
        }
    }
 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        AtomicInteger i = new AtomicInteger(0);
        var arr = Stream.generate(() -> new Node<>(in.nextInt(), i.getAndIncrement()))
                .limit(in.nextInt()).toArray(s -> (Node<Integer>[]) Array.newInstance(Node.class, s));
        System.out.println(Arrays.toString(arr));
        var maxN = Arrays.stream(arr).max(Comparator.comparing(n -> n)).orElseThrow();
        var minN = Arrays.stream(arr).min(Comparator.comparing(n -> n)).get();
        swap(arr, minN.index, maxN.index);
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}
 
class Node<T extends Comparable<T>> implements Comparable<Node<T>> {
    int index;
    T val;
 
    Node(T val, int index) {
        this.val = val;
        this.index = index;
    }
 
    @Override
    public String toString() {
        return val.toString();
    }
 
    @Override
    public int compareTo(Node<T> n) {
        return val.compareTo(n.val);
    }
}