Java SE Generics

// 编译器报错：Erasure of method method(List<String>) is the same as another method in type Main
public class Main {
    public void method(List<String> list) { ... }
    public void method(List<Integer> list) { ... }
}

// 1. Constructor
Map<String, List<String>> myMap = new HashMap<String, List<String>>();
// You can substitute the parameterized type of the constructor with an empty set of type parameters (<>):
Map<String, List<String>> myMap = new HashMap<>();


// 2. Method invocation
// 代码引用自@pdai: https://pdai.tech/md/java/basic/java-basic-x-generic.html
public class Test {
	public static void main(String[] args) {

		/** 不指定泛型的时候 */
		int i = Test.add(1, 2); // 这两个参数都是Integer，所以T为Integer类型
		Number f = Test.add(1, 1.2); // 这两个参数一个是Integer，一个是Float，所以取同一父类的最小级，为Number
		Object o = Test.add(1, "asd"); // 这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object

		/** 指定泛型的时候 */
		int a = Test.<Integer>add(1, 2); // 指定了Integer，所以只能为Integer类型或者其子类
		int b = Test.<Integer>add(1, 2.2); // 编译错误，指定了Integer，不能为Float
		Number c = Test.<Number>add(1, 2.2); // 指定为Number，所以可以为Integer和Float
	}

	// 这是一个简单的泛型方法
	public static <T> T add(T x, T y) {
		return y;
	}
}

// Warning: List is a raw type. References to generic type List<E> should be parameterized
List list = new ArrayList();
list.add("Hello");

// Recommended: Use generic type List<String>
List<String> list = new ArrayList<>();

/**
 * @param dest 被拿来写入数据,作为consumer，使用super通配符
 * @param src 被拿来读取数据,作为producer，使用extends通配符
*/
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");

    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i=0; i<srcSize; i++)
            dest.set(i, src.get(i));
    } else {
        ListIterator<? super T> di=dest.listIterator();
        ListIterator<? extends T> si=src.listIterator();
        for (int i=0; i<srcSize; i++) {
            di.next();
            di.set(si.next());
        }
    }
}

public class Pair<T> {
    private T key;
    private T value;
    public Pair(T key, T last) {
        this.key = value;
        this.value = valuet;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // a. 使用泛型方法
    // 将泛型类型参数定义在方法级别，而不是类级别。
    public static <K> Pair<K> create(K first, K last) {
        return new Pair<K>(first, last);
    }
    // b. 使用通配符或具体类型
    // 在静态方法中使用通配符或具体类型参数，而不是类的泛型类型参数
    public static void staticMethod(List<?> list) {...}
    // 使用具体类型
    public static void staticMethod(List<String> list) {...}
}

import java.util.HashMap;
import java.util.Map;

interface Repository<T> {
    void add(T item);

    T getById(String id);

    void delete(String id);
}

class Computer {
    private String id;
    private String name;
    private double price;

    public Computer(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    // getter
    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Computer{id='" + id + "', name='" + name + "', price=" + price + '}';
    }
}

class ComputerRepository implements Repository<Computer> {
    private Map<String, Computer> computers = new HashMap<>();

    @Override
    public void add(Computer computer) {
        computers.put(computer.getId(), computer);
    }

    @Override
    public Computer getById(String id) {
        return computers.get(id);
    }

    @Override
    public void delete(String id) {
        computers.remove(id);
    }
}

public class Main {
    public static void main(String[] args) {
        Repository<Computer> computerRepository = new ComputerRepository();

        // Add computers to the repository
        computerRepository.add(new Computer("1", "RedMi", 999.99));
        computerRepository.add(new Computer("2", "Lenovo", 499.99));

        // Retrieve and display a computer
        Computer laptop = computerRepository.getById("1");
        System.out.println("Retrieved: " + laptop);

        // Delete a computer
        computerRepository.delete("1");
        System.out.println("computer with ID 1 deleted.");

        // Attempt to retrieve the deleted computer
        Computer deletedcomputer = computerRepository.getById("1");
        System.out.println("After deletion, retrieved: " + deletedcomputer);
    }
}

[OUTPUT]
Retrieved: Computer{id='1', name='RedMi', price=999.99}
computer with ID 1 deleted.
After deletion, retrieved: null

public class Collections {
    public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
    }

    public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
    }
}

public class Arrays {
    @SafeVarargs
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }
}

// usage example
public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Banana", "Apple", "Cherry");
        Collections.sort(list);
        System.out.println(list); // 输出: [Apple, Banana, Cherry]
    }
}

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    <R, A> R collect(Collector<? super T, A, R> collector);
}