Java 泛型

泛型类型必须是引用类型。不能用int、double或char等基本数据类型来替换泛型类型

1、定义泛型类和接口

例子：

public class TestStack<E> {
    
    private ArrayList<E> list = new ArrayList();
    
    public TestStack() {
        // TODO Auto-generated constructor stub
    }
    
    public int getSize() {
        return list.size();
    }
    
    public E peek() {
        E e = list.get(getSize() - 1);
        return e;
    }
    
    public E pop() {
        E e = peek();
        list.remove(getSize() - 1);
        return e;
    }
    
    public void push(E e) {
        list.add(e);
    }
    
    
    public boolean isEmpty() {
        return list.isEmpty();
    }
    
    public String toString() {
        return "stack: " + list.toString();
    }
    
    public static void main(String [] args) {
        TestStack<String> stack1 = new TestStack<>();
        stack1.push("London");
        stack1.push("Pairs");
        stack1.push("Berlin");
        System.out.println(stack1.toString());
        stack1.pop();
        System.out.println(stack1.toString());
    }
}

2、泛型方法

要声明方法的泛型类型，请为方法返回类型放置泛型类型，例如<E> void max（E o1，E o2）

3、对一个对象数组进行排序

例子：

public class GenericSort1 {
    public static void main(String [] args) {
        
        Integer [] intArray = {new Integer(2),new Integer(4),new Integer(3),new Integer(1)};
        
        Double [] doublesArrray = {new Double(3.4),new Double(1.3),new Double(-22.1)};
        
        String [] stringArray = {"zzzzz","ddddd","qqweasd"};
        
        
        printlist(intArray);
        sort(intArray);
        printlist(intArray);
        
        printlist(doublesArrray);
        sort(doublesArrray);
        printlist(doublesArrray);
        
        printlist(stringArray);    
        sort(stringArray);
        printlist(stringArray);    
    
    }

    public static <E extends Comparable<E>> void sort(E [] list) { //E是Comparable的子类型，其次还指定进行比较的元素是E类型
        E currentMin;
        int currentMinIndex;
        for(int i=0; i<list.length - 1; i++) {
            currentMin = list[i];
            currentMinIndex = i;
            for(int j=i+1; j<list.length; j++) {
                if(currentMin.compareTo(list[j]) > 0) {
                    currentMin = list[j];
                    currentMinIndex = j;
                }
            }
            if(currentMinIndex != i) {
                list[currentMinIndex] = list[i];
                list[i] = currentMin;
            }
        }
    }
    
    public static <E> void printlist(E [] list) {
        for(int i=0; i<list.length; i++) {
            System.out.print(list[i] + " ");
        }
        System.out.println();
    }
}

4、通配类型

通配类型有三种形式：

1、？  （非受限通配   跟 ？ extends Object 一样）

2、？ extends T （受限通配  表示T或T的一个子类型） 

3、？ super T   （下限通配 表示T或T的一个父类型）

5、消除泛型和对泛型的限制

泛型是使用一种称为类型消除的方法来实现的。

泛型存在编译时。一旦编译器确认泛型类型是安全使用的，就会将他转换为原始类型。

例子：

编译器会先检查a代码里泛型是否正确使用，然后将它翻译成b

6、泛型的限制

1、不能使用new E（）

不能使用泛型类型参数创建实例。列如：

E object = new E（）； 错误

2、不能使用new E  [ ]

不能使用泛型类型参数创建数组。列如：

E [ ] elements = new E[capcacity];

但可以通过创建一个Object类型的数组，然后将它的类型转换为E[ ] 来规避这个限制。 例如：

E [ ] elements = (E[ ]) new Object[dapcacity];

3、在静态上下文中不允许的参数是泛型类型

4、异常类不能是泛型的