Java SE Generics

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

// 1. ConstructorMap<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.htmlpublic 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 parameterizedList 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 examplepublic 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);}