Java基础-泛型的使用及泛型实现原理

在泛型出现以前，类和方法只能接受具体的类型。假设我们自己实现一个简单的ArrayList，用来持有类A的实例，它可能是这样子的：

class A {}

class ArrayListA {
    private int size = 0;

    private A[] array = new A[100];
    
    public void add(A a) {
        array[size++] = a;
    }
    
    public A get(int index) {
        return array[index];
    }
}

现在如果需要一个ArrayList来持有类B的实例，由于没有泛型，那只能把同样的代码再写一遍，并将其中的A全部换成B。难道我们要为每一个类都写一个ArrayList吗，显然是不可能的。在泛型出现以前，jdk的ArrayList使用的方法是用Object作为类型参数，这样使用者需要自己做转型，就像下面这样：

public class GenericLearn {

    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("aaa");
        String str = (String) arrayList.get(0);
    }

}

这样的向下转型，既不方便，也不安全。有没有一种办法，能让类型作为一种可选参数，使得一套代码能复用于多个类，且不需要自己做转型等动作，这便是泛型要解决的问题。

泛型的使用

1. 泛型类

class Holder<T> {
    
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    
    public void print() {
        System.out.println(t);
    }
}

上面是一个简单的泛型类，用一个<>来指明参数化类型。现在我们在使用Holder类时就可以指明类型，一旦类型被确定，它就不能用于其他类：

Holder<String> holder = new Holder<>();
// 编译错误
holder.setT(1);

2. 泛型接口

interface Handler<T> {

   void handle(T t);
}

class StringHandler implements Handler<String> {

   @Override
   public void handle(String s) {
       // doNothing
   }
}

泛型用于接口和用于类的方式差不多。

3. 泛型方法

泛型也可以直接用于方法：

class BatchUtil {
    
    public static <T> void batchExec(List<T> list, int batchSize, Consumer<List<T>> action) {
        for (int i = 0; i < list.size(); i += batchSize) {
            int endIndex = i + batchSize > list.size() ? list.size() : i + batchSize;
            List<T> tempList = list.subList(i, endIndex);
            action.accept(tempList);
        }
    }
}

以上方法定义了一个批量操作的工具类，你可以像这样使用它：

public class GenericLearn {

    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
        BatchUtil.batchExec(list, 3, System.out::println);
    }
}

输出：

[1, 2, 3]
[4, 5, 6]
[7]

4. 泛型边界

利用extends关键字，可以为泛型参数限定上边界。

public class GenericLearn {

    public static void main(String[] args) {
        Holder<A> holder1 = new Holder<>();
        Holder<B> holder2 = new Holder<>();
        // 编译错误
        Holder<String> holder3 = new Holder<>();
    }
}

class Holder<T extends A> {
    
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

class A {}

class B extends A{}

限定了边界后，泛型的类型就只能是指定类型及其子类。

5. 通配符

上面介绍的泛型类、接口、方法等都是如何定义泛型，至于使用泛型，最通常的就是指定泛型参数，如List<String>，指定了泛型参数为String。但是有时候我们会碰到这样的情况：

public class GenericLearn {

    public static void main(String[] args) {
        List<A> listA = new ArrayList<>();
        List<B> listB = new ArrayList<>();
        print(listA);
        // 编译错误
        print(listB);
    }
    
    public static void print(List<A> list) {
        for (A a : list) {
            System.out.println(a);
        }
    }
}

class A {}

class B extends A{}

方法接受参数List<A>，却无法将List<B>作为入参，这是因为虽然B可以向上转型为A，List<B>却无法向上转型为List<A>，为了解决这一问题，引入了通配符。

    public static void print(List<? extends A> list) {
        for (A a : list) {
            System.out.println(a);
        }
    }

将方法改写为这样后，可以编译运行。但是由此也会带来一个副作用：

public static void print(List<? extends A> list) {
        for (A a : list) {
            System.out.println(a);
        }
        // 编译错误
        list.add(new A());
        list.add(new B());
        list.add(new Object());
}

用了通配符后，无法对List进行add操作，这是因为List的add方法，其参数是泛型类，而通配符仅仅指定了泛型类的上界，因此任何以泛型类为入参的方法都无法使用。这是可以理解的，因为假如我们传入的是List<B>，那就不能往其中加入A的实例。

这是用通配符指定上界的情况，通配符也可以指定下界，还是以List为例：

public static void main(String[] args) {
        List<? super B> list = new ArrayList<>();
        list.add(new B());
        Object obj = list.get(0);
        // 编译错误
        list.add(new A());
        list.add(new Object());
        B b = list.get(0);
        A a = list.get(0);
}

用通配符指定下界后，可以执行add操作，但是只可以add类B的实例，因为我们不知道List持有的具体类型是什么，只知道它是B或其超类，在这样的条件下，只有往其中加入类B的实例是安全的，并且从其中拿到的对象只能当作Object来使用。

通配符也可以不指定边界，称为无界通配符，以List为例，对List<?>，不能执行add操作，从中取出的对象只能当作Object来使用。

对于通配符的使用有一个PECS原则(Producer Extends, Consumer Super)，即如果将泛型类作为生产者使用，例如使用List的get方法，则用上界通配符；如果将泛型类作为消费者使用，例如使用List的add方法，则用下界通配符。

泛型的实现原理

很多人把Java的泛型称为伪泛型，因为Java的泛型只是编译期的泛型，一旦编译成字节码，泛型就被擦除了，即在Java中使用泛型，我们无法在运行期知道泛型的类型，因此像下面这样的操作是不行的。

class Holder<T> {
    // 编译错误
    private T t = new T();
    private T[] array = new T[0];
    private Class<T> clazz = T.class;
}

因为在jvm运行程序时，类Holder是不带有泛型类T的具体类型的，所以任何需要具体类型的操作，比如实例化对象等，都无法进行。

为了直观的理解泛型擦除，我们可以看一下Holder的字节码：

class Holder {


  // access flags 0x2
  // signature TT;
  // declaration: T
  private Ljava/lang/Object; t

  @groovyx.ast.bytecode.Bytecode
  void <init>() {
    aload 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    return
  }

  @groovyx.ast.bytecode.Bytecode
  public Object getT() {
    aload 0
    getfield 'Holder.t','Ljava/lang/Object;'
    areturn
  }

  @groovyx.ast.bytecode.Bytecode
  public void setT(Object a) {
    aload 0
    aload 1
    putfield 'Holder.t','Ljava/lang/Object;'
    return
  }
}

可以看到一旦编译成字节码，泛型将被取代为Object。比较一下直接使用Object类和使用泛型的区别：

public class GenericLearn {

    public static void main(String[] args) {
        Holder holder = new Holder();
        holder.setT("abc");
        String str = (String) holder.getT();
    }

}

class Holder {

    private Object t;

    public Object getT() {
        return t;
    }

    public void setT(String t) {
        this.t = t;
    }
}

@groovyx.ast.bytecode.Bytecode
  public static void main(String[] a) {
    _new 'Holder'
    dup
    INVOKESPECIAL Holder.<init> ()V
    astore 1
    aload 1
    ldc "abc"
    INVOKEVIRTUAL Holder.setT (Ljava/lang/String;)V
    aload 1
    INVOKEVIRTUAL Holder.getT ()Ljava/lang/Object;
    checkcast 'java/lang/String'
    astore 2
    return
  }

下面将Holder加入泛型：

public class GenericLearn {

    public static void main(String[] args) {
        Holder<String> holder = new Holder<>();
        holder.setT("abc");
        String str =  holder.getT();
    }

}

class Holder<T> {

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

@groovyx.ast.bytecode.Bytecode
  public static void main(String[] a) {
    _new 'Holder'
    dup
    INVOKESPECIAL Holder.<init> ()V
    astore 1
    aload 1
    ldc "abc"
    INVOKEVIRTUAL Holder.setT (Ljava/lang/Object;)V
    aload 1
    INVOKEVIRTUAL Holder.getT ()Ljava/lang/Object;
    checkcast 'java/lang/String'
    astore 2
    return
  }

可以看到，两段代码的字节码基本是完全一样的，注意字节码中的checkcast，在不使用泛型时，我们需要将Object手动转型成String，而在使用泛型后，我们不需要自己转型，但实际上我们get到的对象仍然是Object类型的，只不过编译器会自动帮我们加入这个转型动作。

再来看一下使用泛型上界的情况：

class Holder<T extends A> {

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

class A {}

class Holder {


  // access flags 0x2
  // signature TT;
  // declaration: T
  private LA; t

  @groovyx.ast.bytecode.Bytecode
  void <init>() {
    aload 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    return
  }

  @groovyx.ast.bytecode.Bytecode
  public A getT() {
    aload 0
    getfield 'Holder.t','LA;'
    areturn
  }

  @groovyx.ast.bytecode.Bytecode
  public void setT(A a) {
    aload 0
    aload 1
    putfield 'Holder.t','LA;'
    return
  }
}

在有了泛型上界后，泛型将被擦除成定义的上界。

现在可以对Java的泛型做一个总结：Java的泛型只存在于编译期，一旦编译成字节码，泛型将被擦除。泛型的作用在于在编译阶段保证我们使用了正确的类型，并且由编译器帮我们加入转型动作，使得转型是不需要关心且安全的。

Java之所以用擦除来实现泛型，是因为Java是在1.5引入的泛型，为了兼容性，即以前没有泛型的程序能运行在新一代的jvm上，且让开发者可以以自己的进度将代码加入泛型特性，而选择了擦除这一办法。具体可以参考《Java编程思想》的泛型章节或知乎上的这篇回答：https://www.zhihu.com/question/28665443/answer/118148143

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容