认识泛型VS包装类

news2024/11/16 3:20:01

1.包装类

在 Java 中，由于基本类型不是继承自 Object ，为了在泛型代码中可以支持基本类型， Java 给每个基本类型都对应了一个包装类型。

ps:为什么需要包装类？说白了java就是面向对象编程的

比如：Java 的集合框架（如 ArrayList、 HashSet、 HashMap 等）只能存储对象，而不能直接存储基本数据类型

ArrayList<Integer> list = new ArrayList<>();

list.add(42); // 这里的 42 是 int 类型，自动转换为 Integer 对象

1.1 基本数据类型和对应的包装类

1.2 装箱和拆箱

int i = 10 ;

// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中

Integer ii = Integer . valueOf ( i );

Integer ij = new Integer ( i );

// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中

int j = ii . intValue ();

1.3 自动装箱和自动拆箱

int i = 10 ;

Integer ii = i ; // 自动装箱

Integer ij = ( Integer ) i ; // 自动装箱

int j = ii ; // 自动拆箱

int k = ( int ) ii ; // 自动拆箱

PS：一下代码的结果是什么呢？

public static void main ( String [] args ) {

Integer a = 127 ;

Integer b = 127 ;

Integer c = 128 ;

Integer d = 128 ;

System . out . println ( a == b );

System . out . println ( c == d );

}

结果：true false

Integer a = 127; Integer b = 127;：Java 的 Integer 类缓存了-128到127范围内的 Integer 对象。由于 127 在这个范围内，a 和 b 指向同一个对象，因此 a == b 为 true。
Integer c = 128; Integer d = 128;：超出缓存范围的 Integer 对象会被新创建，因此 c 和 d 指向不同的对象，因此 c == d 为 false。

2 什么是泛型

泛型： 就是适用于许多许多类型 。从代码上讲，就是对类型实现了参数化。

示例：

public class Test1 {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }

    public static void main(String[] args) {
        Test1 t = new Test1();
        t.setVal(0,10);
        t.setVal(1,"b");
        String s = (String) t.getPos(1);
        System.out.println(s);
    }
}

此时获取t的值的时候，会编译报错，因为他定义的是Object类型，此时赋值的是String，必须进行类型转换才可以。

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。 此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

2.1 语法

class 泛型类名称 < 类型形参列表 > {

// 这里可以使用类型参数

}

class ClassName < T1 , T2 , ..., Tn > {

}

class 泛型类名称 < 类型形参列表 > extends 继承类 /* 这里可以使用类型参数 */ {

// 这里可以使用类型参数

}

class ClassName < T1 , T2 , ..., Tn > extends ParentClass < T1 > {

// 可以只使用部分类型参数

}

//类名后的 <T> 代表占位符，表示当前类是一个泛型类

修改我们上面用到的示例

public class Test2<T> {
     public Object[] objects = new Object[10];
    public T getPos(int pos) {
        return (T) this.objects[pos];
    }
    public void setVal(int pos,T val) {
        this.objects[pos] = val;
    }

    public static void main(String[] args) {
        Test2<String> test2 = new Test2<String>();
        test2.setVal(1,"wer");
        String s = test2.getPos(1);
        System.out.println(s);
        Test2<Integer> t2 = new Test2<Integer>();
        t2.setVal(2,4);
        Integer i = t2.getPos(2);
        System.out.println(i);
    }

}

此时，就可以变换类型得到自己想要的值

ps:

public T[] array = new T[];

一般情况下不建议这种写法，数组在编译的时候需要一个具体的类型

虽然有擦除机制，会把这些类擦除为Object，但是并是把T替换为Object

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等 - 第二、第三、第四个类型

3.泛型类的使用

3.1语法

泛型类 < 类型实参 > 变量名 ; // 定义一个泛型类引用

new 泛型类 < 类型实参 > ( 构造方法实参 ); // 实例化一个泛型类对象

示例：

MyArray < Integer > list = new MyArray < Integer > ();

//后面的参数可以省略

MyArray < Integer > list = new MyArray <> ();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！ 、

3.2为什么需要泛型

初了上面介绍的，泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）
适用于多种数据类型执行相同的代码

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个add方法；通过泛型，我们可以复用为一个方法：

private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

3.3泛型类定义使用

class Point<T>{         // 此处可以随便写标识符号，T是type的简称  
    private T var ;     // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
}  
public class GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ;     // 里面的var类型为String类型  
        p.setVar("it") ;                            // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
}

多元泛型

class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
} 
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
}

4.泛型如何编译的

4.1擦除机制

通过命令： javap -c 查看字节码文件，所有的 T 都是 Object 。

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。（在上面的案列中我们也有提到）

推荐一篇文章有详细的介绍：Java泛型擦除机制之答疑解惑 - 知乎 (zhihu.com)

5.泛型的上界

5.1语法

class 泛型类名称 < 类型形参 extends 类型边界 > {

...

}

public class MyArray < E extends Number > {

...

}

只接受 Number 的子类型作为 E 的类型实参

MyArray < Integer > l1 ; // 正常，因为 Integer 是 Number 的子类型
MyArray < String > l2 ; // 编译错误，因为 String 不是 Number 的子类型

6.泛型方法

6.1定义

方法限定符 < 类型形参列表 > 返回值类型方法名称 ( 形参列表 ) { ... }

public class Util {

// 静态的泛型方法需要在 static 后用 <> 声明泛型类型参数

public static < E > void swap ( E [] array , int i , int j ) {

E t = array [ i ];

array [ i ] = array [ j ];

array [ j ] = t ;

}

}