java基础：14.1 泛型

最新推荐文章于 2021-07-06 22:44:45 发布

桃子味的梨

最新推荐文章于 2021-07-06 22:44:45 发布

阅读量408

点赞数

分类专栏： Java 基础

本文链接：https://blog.csdn.net/L20902/article/details/88878731

版权

本文详细介绍了Java中的泛型，包括泛型的概念、泛型通配符的三种形式，以及泛型在虚拟机中的表现。泛型允许在编译时检查类型安全性，提供更好的性能。通过示例展示了泛型类的使用，如ArrayList，以及泛型方法，如泛型通配符在存储和取出元素时的应用。同时，文章还强调了泛型的注意事项，如类型擦除、静态上下文的限制等。

摘要由CSDN通过智能技术生成

1、回顾ArrayList类

ArrayList是一种泛型类，具有一个泛型类型<E>，创建一个ArrayList 时，可以指定一个具体的类型来替换E。Java 提供ArrayList 类来存储不限定个数的对象。位于java.util 包中。存储在ArrayList中的元素必须是一种对象，不能使用int的基本数据类型来代替一个泛型类.

ArrayList<T> cities = new ArrayList<>() ; T可以是引用类型 例如，string，Integer，Double 或Characterr…；不能使用int 、double 或char 这样的基本类型

数组和ArrayList的区别
— 旦创建了一个数组，它的大小就确定下来了。可以使用方括号访问数组元素（例如：a[index]). 当创建ArrayList 后，它的大小为0。如果元索不在数组列表中，就不能使用get(index)和set(index.element)方法。向数组列表中添加、插人和删除元素是比较容易的，而向数组中添加、插人和删除元素是比较复杂的。为了实现这些操作，必须编写代码操纵这个数组。注意，可以使用;java.util.Arrays.sortUrray)方法来对一个数组排序。如果要对一个数组列表排序，使用java.util.Collections.sort(arrayList)方法。

自动拆箱
如果元素是包装类型，例如， Integer , Double 或Character ，那么可以直接将这个元素赋给一个基本类型的变量。这个过程称为自动拆箱。

ArrayList<Double> list = new ArrayList<>();
list.add(5.5);   // 5.5 is automatlcally converted to new Double(5.5)
list. add (3.0);  // 3. 0 i s automati ca 11 y converted to new Ooub 1 e (3 .0)
Double doubleObject = list.get(O); // No casting is needed
double d = list.get(l); // Automatically converted to double

2、泛型的概念

我们用<E>表示泛型，不同于以往的( )类型。

泛型的优点：可以在编译时检测出错误。泛型类或方法允许用户指定可以和这些类或方法一起工作的对象类型。如果试图使用一个不相容的对象，编译器就会检测出这个错误。

E - Element (在集合中使用，因为集合中存放的是元素) T - Type（Java 类） K - Key（键） V - Value（值） N - Number（数值类型）？ - 表示不确定的java类型`

2.1) 泛型类

public class Pair<T>
{
   
    private T first;
    private T second;

    public Pair() {
    first = null; second = null; }
    public Pair(T first, T second) {
    this.first = first;  this.second = second; }

    public T getFirst() {
    return first; }
    public T getSecond() {
    return second; }

    public void setFirst(T newValue) {
    first = newValue; }
    public void setSecond(T newValue) {
    second = newValue; }
}

2.2) 泛型方法：

class ArrayAlg2   // 普通类中定义泛型方法
{
   
    public static <T extends Comparable> Pair<T> minmax(T[] a)   //返回类型Pair<T>
    {
   
        if (a == null || a.length == 0) return null;
        T min = a[0];
        T max = a[0];
        for (int i = 1; i < a.length; i++)
        {
   
            if (min.compareTo(a[i]) > 0) min = a[i];
            if (max.compareTo(a[i]) < 0) max = a[i];
        }
        return new Pair<>(min, max);
    }
}

类型变量放在修饰符(下例中是public static)的后面，返回类型的前面。例如：

class ArrayAlg
{
   
    public static T Pair<T> minmax(T[] a)  //Pair后面的<T>
    {
   ..}
}

调用一个泛型方法时，在方法名前的尖括号中放入具体的类型：

String middle = ArrayAlg.<String>getMiddle("jo","Q","pub");

但大多数情况下，方法调用中可以省略类型参数：

String middle = ArrayAlg.getMiddle("jo","Q","pub");

类型变量的限定：
下面的代码中使用了comparaTo，通过前面的学习我们知道必须是实现了Comparable的接口才能使用此方法。因此，T必须限制为实现了Comparable的接口。

	Class ArrayAlg{
   
		public static <T> T min(T[] a){
   
			if ...
			...
			if(smallest.compareTo(a[i]>0) smallest=a[i];
			return smallest;
		}
	}

所以，我们需要对类型变量进行限定！改写成下面的代码。
T和绑定类型可以是类、接口。一个类型变量也可以有多个限定(T extends Comparable & Serializable)

	Class ArrayAlg{
   
		public static <T extends Cpmparable> T min(T[] a){
   
			if ...
			...
			if(smallest.compareTo(a[i]>0) smallest=a[i];
			return smallest;
		}
	}

2.3) 方法调用：

public class PairTest2
{
   
    public static void main(String[] args)
    {
   
        GregorianCalendar[] birthdays =
        {
   
              new GregorianCalendar(1906, Calendar.DECEMBER, 9), // G. Hopper
              new GregorianCalendar(1815, Calendar.DECEMBER, 10), // A. Lovelace
              new GregorianCalendar(1903, Calendar.DECEMBER, 3)