[NP] Генеричка тројка

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

class Triple<T extends Number> {
    List<T> numbers;

    public Triple(T... numbers) {
        this.numbers = new ArrayList<>(Arrays.asList(numbers));
    }

    /*
    public double max(){
        if (a.compareTo(b) > 0 && a.compareTo(c) > 0){
            return (double) a;
        } else if (b.compareTo(a) > 0 && b.compareTo(c) > 0){
            return (double) b;
        } else {
            return (double) c;
        }
    }
    */

    /*
        public double max() {
            return Math.max(Math.max(.doubleValue(), b.doubleValue()), c.doubleValue());
        }
    */

    public double max() {
        /*T max = numbers.get(0);
        for (int i = 0; i < numbers.size(); i++) {
            if (max.doubleValue() < numbers.get(i).doubleValue()) {
                max = numbers.get(i);
            }
        }
        return max.doubleValue();*/
        return numbers.stream()
                .mapToDouble(Number::doubleValue)
                .max()
                .getAsDouble();
    }

    /*
        public double average() {
            return (a.doubleValue() + b.doubleValue() + c.doubleValue()) / 3;
        }
    */

    /*
    public double sum() {
        double sum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            sum = numbers.get(i).doubleValue();
        }
        return sum;
    }
    */

    public double sum() {
        /* return numbers.stream().mapToDouble(numbers -> numbers.doubleValue()).sum(); */
        return numbers.stream().mapToDouble(Number::doubleValue).sum();
    }

    public double average() {
        /*return sum() / numbers.size();*/
        return numbers.stream()
                .mapToDouble(Number::doubleValue)
                .average()
                .getAsDouble();
    }

    public void swap(T left, T right) {
        T temp = left;
        left = right;
        right = temp;
    }

    public static Comparator<? super Number> comparator = (Comparator<Number>) (a, b) -> {
        if (a.doubleValue() > b.doubleValue()) {
            return 1;
        } else if (a.doubleValue() < b.doubleValue()) {
            return -1;
        }
        return 0;
    };

    public void sort() {
        /*        Using collections
        Collections.sort(numbers, comparator);         */

        /* Using ArrayList's sort */
        numbers.sort(comparator);
    }

    public String toString() {
        return String.format("%.2f %.2f %.2f",
                numbers.get(0).doubleValue(),
                numbers.get(1).doubleValue(),
                numbers.get(2).doubleValue());
    }
}

public class TripleTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();
        Triple<Integer> tInt = new Triple<Integer>(a, b, c);
        System.out.printf("%.2f\n", tInt.max());
        System.out.printf("%.2f\n", tInt.average());
        tInt.sort();
        System.out.println(tInt);
        float fa = scanner.nextFloat();
        float fb = scanner.nextFloat();
        float fc = scanner.nextFloat();
        Triple<Float> tFloat = new Triple<Float>(fa, fb, fc);
        System.out.printf("%.2f\n", tFloat.max());
        System.out.printf("%.2f\n", tFloat.average());
        tFloat.sort();
        System.out.println(tFloat);
        double da = scanner.nextDouble();
        double db = scanner.nextDouble();
        double dc = scanner.nextDouble();
        Triple<Double> tDouble = new Triple<Double>(da, db, dc);
        System.out.printf("%.2f\n", tDouble.max());
        System.out.printf("%.2f\n", tDouble.average());
        tDouble.sort();
        System.out.println(tDouble);

        /*
        System.out.print("\n My Code \n");
        int zero = 0;
        int one = 1;
        System.out.println(String.format("zero = %d \t one = %d", zero, one));
        swapPrimitives(zero, one);
        int temp = zero;
        zero = one;
        one = temp;
        swapIntegers(zero, one);
        System.out.println(String.format("zero = %d \t one = %d", zero, one));*/

    }

    public static void swapPrimitives(int left, int right) {
        int temp = left;
        left = right;
        right = temp;
    }

    public static void swapIntegers(AtomicInteger left, AtomicInteger right) {
        left.set(right.getAndSet(left.get()));
    }

}