import java.util.*;

public class Method {

    // Slide 17
    static class Utils {
        static double sumList(ArrayList<Number> lst) {
            double result = 0.0;
            for (Number n : lst) {
                result += n.doubleValue();
            }
            return result;
        }

        static Number choose(ArrayList<Number> lst) {
            int i = (int) (Math.random() * lst.size()); // random number < lst.size
            return lst.get(i);
        }
    }

    // Slide 19
    static class UtilsGenerified {
        static <T extends Number> double sumList(List<T> lst) {
            double result = 0.0;
            for (T n : lst) { // T also works
                result += n.doubleValue();
            }
            return result;
        }

        static <T> T choose(List<T> lst) {
            int i = (int) (Math.random() * lst.size()); // random number < lst.size
            return lst.get(i);
        }
    }

    // Slide 21
    static <T extends Comparable<T>> T max(Collection<T> c) {

        T max = (T)c.toArray()[0];
        for (T element : c) {
            if (element.compareTo(max) > 0) {
                max = element;
            }
        }
        return max;
    }


    static <T extends Comparable<T>> void sort(List<T> list) {
        Collections.sort(list);
    }


    static <T> void copyTo(List<T> dst, List<T> src) {
        dst.addAll(src);
    }


    public static void main(String[] args) {

// Slide 17
        ArrayList<Number> numberNumbersToSum = new ArrayList<>(Arrays.asList(2, 1, 3));
        ArrayList<Double> doubleNumbersToSum = new ArrayList<>(Arrays.asList(2.0, 1.0, 3.0));
        ArrayList<Integer> intNumbersToSum = new ArrayList<>(Arrays.asList(2, 1, 3));

//        System.out.println("Utils.sumList(numberNumbersToSum): " + Utils.sumList(numberNumbersToSum));
//        Utils.sumList(doubleNumbersToSum);
//        Utils.sumList(intNumbersToSum);

//        System.out.println("Utils.choose(numberNumbersToSum): " + Utils.choose(numberNumbersToSum));
//        Utils.choose(doubleNumbersToSum);
//        Utils.choose(intNumbersToSum);

// Slide 19
        UtilsGenerified.sumList(numberNumbersToSum);
        UtilsGenerified.sumList(doubleNumbersToSum);
        UtilsGenerified.sumList(intNumbersToSum);

        UtilsGenerified.choose(numberNumbersToSum);
        UtilsGenerified.choose(doubleNumbersToSum);
        UtilsGenerified.choose(intNumbersToSum);


// Slide 21
        Collection<Integer> collectionIntNumbersToSum = intNumbersToSum;
//        System.out.println("max(collectionIntNumbersToSum): " + max(collectionIntNumbersToSum));
        Collection<Double> collectionDoubleNumbersToSum = doubleNumbersToSum;
//        System.out.println("max(collectionDoubleNumbersToSum): "+max(collectionDoubleNumbersToSum));
        Collection<String> collectionString = new ArrayList<>(Arrays.asList("a","c","b"));
//        System.out.println("max(collectionString): "+max(collectionString));

        System.out.println("before sort for ints: " + intNumbersToSum);
        sort(intNumbersToSum);
        System.out.println("before sort for ints: " + intNumbersToSum);

        System.out.println("before sort for double: " + doubleNumbersToSum);
        sort(doubleNumbersToSum);
        System.out.println("before sort for double: " + doubleNumbersToSum);


        ArrayList<String> listString = new ArrayList<>(Arrays.asList("a","c","b"));
        System.out.println("before sort for string: " + listString);
        sort(listString);
        System.out.println("before sort for string: " + listString);

        ArrayList<String> dst = new ArrayList<>();
        System.out.println("before copy for dst: " + dst);

        copyTo(dst, listString);
        System.out.println("after copy for dst: " + dst);
    }

}