Generics

class Box<T> {
    private T item;
    void put(T item) { this.item = item; }
    T get() { return item; }
}

public class Main {
    public static void main(String[] args) {
        Box<Double> price = new Box<>();
        price.put(100.0);
        System.out.println(price.get() * 1.18);
    }
}

import java.util.List;

public class Main {
    static <T> T first(List<T> xs) {
        return xs.get(0);
    }

    public static void main(String[] args) {
        String n = first(List.of("Riya", "Om"));
        Integer x = first(List.of(7, 3));
        System.out.println(n + " " + x);
    }
}

import java.util.List;

public class Main {
    static int count(List<?> xs) {
        return xs.size();
    }

    public static void main(String[] args) {
        System.out.println(count(List.of("a", "b")) + " " + count(List.of(1.5)));
    }
}

import java.util.List;

public class Main {
    static <T extends Number> double avg(List<T> xs) {
        double s = 0;
        for (T x : xs) s += x.doubleValue();
        return s / xs.size();
    }

    public static void main(String[] args) {
        System.out.println(avg(List.of(80, 90, 70)) + " " + avg(List.of(2.5, 3.5)));
    }
}

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addRange(List<? super Integer> dest, int from, int to) {
        for (int i = from; i <= to; i++) dest.add(i);
    }

    public static void main(String[] args) {
        List<Number> nums = new ArrayList<>();
        List<Object> objs = new ArrayList<>();
        addRange(nums, 1, 3);
        addRange(objs, 1, 3);
        System.out.println(nums + " " + objs);
    }
}

import java.util.List;

public class Main {
    static <T> List<T> page(List<T> all, int pageNo, int size) {
        int from = (pageNo - 1) * size;
        int to = Math.min(from + size, all.size());
        return from >= all.size() ? List.of() : all.subList(from, to);
    }

    public static void main(String[] args) {
        List<String> products = List.of("P1", "P2", "P3", "P4", "P5");
        System.out.println(page(products, 2, 2));
        System.out.println(page(products, 3, 2));
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

class Cache<K, V> {
    private final int max;
    private final LinkedHashMap<K, V> map = new LinkedHashMap<>();

    Cache(int max) { this.max = max; }

    void put(K key, V value) {
        map.put(key, value);
        if (map.size() > max) {
            K oldest = map.keySet().iterator().next();
            map.remove(oldest);
        }
    }

    V get(K key) { return map.get(key); }

    @Override
    public String toString() { return map.toString(); }
}

public class Main {
    public static void main(String[] args) {
        Cache<String, Double> rates = new Cache<>(2);
        rates.put("USD", 83.2);
        rates.put("EUR", 90.1);
        rates.put("GBP", 105.4);
        System.out.println(rates + " USD=" + rates.get("USD"));
    }
}

class Validated<T> {
    final T value;
    final String error;

    private Validated(T value, String error) { this.value = value; this.error = error; }

    static <T> Validated<T> ok(T v) { return new Validated<>(v, null); }
    static <T> Validated<T> bad(String e) { return new Validated<>(null, e); }

    @Override
    public String toString() { return error == null ? "OK " + value : "ERROR " + error; }
}

public class Main {
    static Validated<Integer> age(String text) {
        try {
            int a = Integer.parseInt(text);
            return a > 0 && a < 120 ? Validated.ok(a) : Validated.bad("out of range");
        } catch (NumberFormatException e) {
            return Validated.bad("not a number: " + text);
        }
    }

    public static void main(String[] args) {
        System.out.println(age("25"));
        System.out.println(age("abc"));
    }
}