包装类和认识泛型

Myth丶恋晨 2024-03-03 08:19 105阅读 0赞

**目录**

一、包装类

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

1.2 装箱和拆箱

1.3 自动装箱和自动拆箱

二、泛型概念及引出

2.1 泛型概念

2.2 泛型引出

三、泛型类的使用

四、裸类型（了解）

五、泛型如何编译

5.1 擦除机制

5.2 为什么不能实例化泛型类型的数组

六、泛型的上界

七、泛型方法

--------------------

## 一、包装类 ##

在Java中，基本数据类型不是继承Object，为了在泛型代码中支持基本数据类型，Java给每个基本数据类型都对应有一个包装类型。

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

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:226px;">基本数据类型</td> 
   <td style="width:272px;">包装类</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;byte</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Byte</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; short</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Short</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; int</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Integer</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; long</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Long</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; float</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Float</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; double</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Double</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; char</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Character</td> 
  </tr> 
  <tr> 
   <td style="width:226px;">&nbsp; &nbsp; &nbsp; &nbsp; boolean</td> 
   <td style="width:272px;">&nbsp; &nbsp; &nbsp; &nbsp; Boolean</td> 
  </tr> 
 </tbody> 
</table>

除了Integer和Character，其他基本数据类型的包装类都是首字母大写。

### 1.2 装箱和拆箱 ###

>     int i=10;
>     //装箱----新建一个Integer类型的对象，将i的值放入对象的某个属性中
>     Integer i1=Integer.valueOf(i);
>     Integer i2=new Integer(i);
>     //拆箱----将Integer对象中的值取出，放入一个基本数据类型中
>     int I=i1.intValue();

### 1.3 自动装箱和自动拆箱 ###

在使用过程中，装箱和拆箱会会使我们写不少得到代码量，为了减少开发者的负担，Java提供了自动机制，即自动装箱和自动拆箱。

>     int i=5;
>     //自动装箱
>     Integer i1=i;
>     Integer i2=(Integer) i;
>     //自动拆箱
>     int i3=i1;
>     int i4=(int) i1;

面试题：下面代码输出是什么？为什么？

>     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);
>     }

首先，Integer是包装类，==比较的是两个操作数存储的地址。

![f72a2b1f966d49fa90fcc890e887c8fa.png][]

其次，**Integer的范围在-128~127时，value返回一个对应数组下标的值，否则就会new一个新的Integer对象**。故a和b存储127不会new一个对象，指的是同一个地址，c和d存储128都会new一个对象，指的是不同的地址。

## 二、泛型概念及引出 ##

### 2.1 泛型概念 ###

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大，于是在JDK1.5引入新的语法——泛型：适用于许多类型，从代码上看，实现了类型的参数化。

### 2.2 泛型引出 ###

实现一个类，类中包含一个数组成员，使数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。

使用Object定义数组类型，使数组可以存任何类型的数据。

>     class MyArray{
>         private Object[] array=new Object[10];
>         public Object getValue(int pos){
>             return this.array[pos];
>         }
>         public void  setValue(int pos,Object obj){
>             this.array[pos]=obj;
>         }
>     }
>      public class MyArrayTextDemo {
>          public static void main(String[] args) {
>              MyArray myArray =new MyArray();
>              myArray.setValue(0,10);
>              myArray.setValue(1,"hello");
>              String ret=myArray.getValue(1);//编译报错
>              System.out.println(ret);
>          }
>     }

![48c506d136004fae8836554d78decc6f.png][]

由以上代码可以发现：任何数据类型都可以存放，但在获取下标对应数据时编译报错，需要强制类型转化。

![44bf391d956b4ddb88885db2f79ab029.png][]

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

语法

> class 泛型类名称<类型参数列表>\{
> 
> \}
> 
> class ClassName<T1,T2,T3,...,Tn>\{
> 
> \}
> 
> class 泛型类名称<类型形参列表> extends 继承类\{  
>   
> \}  
> class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> \{  
>   
> \}

改进上述代码：

>     class MyArray<T>{
>         private T[] array=(T[]) new Object[10]; //可以使用但不推荐
>         public T getValue(int pos){
>             return this.array[pos];
>         }
>         public void  setValue(int pos,T obj){
>             this.array[pos]=obj;
>         }
>     }
> 
>     class MyArray<T>{
>         private Object[] array= new Object[10];//推荐使用
>         public T getValue(int pos){
>             return (T) this.array[pos];
>         }
>         public void  setValue(int pos,T obj){
>             this.array[pos]=obj;
>         }
>     }
> 
>     public class MyArrayTextDemo {
>         public static void main(String[] args) {
>             MyArray<Integer> myArray =new MyArray();
>             myArray.setValue(0,10);
>             myArray.setValue(1,15);
>             int ret= myArray.getValue(1);//不用强制转化
>             System.out.println(ret);
>          }
>     }

注意：**类名后的<T>代表占位符，表示当前类是一个泛型类**。类型形参一般使用第一个大写字母表示，常用的名称有：E ——Element、K——Key、V——Value、N——Number、T——Type、S、U、V等；不能new泛型类型的数组；

> T\[\] arr = new T\[5\];//会报错

**在类型后加<Integer>指定当前存放数据的类型，编译器也会依此检查存放的元素类型是否有误**。

## 三、泛型类的使用 ##

语法

> 泛型类<类型实参> 变量名; //定义泛型类引用
> 
> new 泛型类<类型实参>(构造方法实参) //实例化一个泛型类对象

示例

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

泛型只能接受类，所有的基本数据类型必须使用包装类。

类型推导

编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写。

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

## 四、裸类型（了解） ##

裸类型是一个泛型类但没有带着类型实参，例如 MyArray list 就是一个裸类型。

> MyArray list=new MyArray();

注意：我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制。

**小结：泛型是将数据类型参数化，进行传递；使用<T>表示当前类是一个泛型类；泛型类的优点：数据类型参数化，编译时自动进行类型检查和转换。**

## 五、泛型如何编译 ##

### 5.1 擦除机制 ###

通过命令：javap -c 查看字节码文件

![740cc0a0d4bd4e44ab76ba9c2b67da12.png][]

可以发现所有的T都是Object，**在编译过程中，将所有T替换为Object这种机制，称为擦除机制，**Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间不包含泛型的类型信息。

### 5.2 为什么不能实例化泛型类型的数组 ###

> class MyArray<T> \{  
> public T\[\] array = (T\[\])new Object\[10\];
> 
>   
> public T getValue(int pos) \{  
> return this.array\[pos\];  
> \}  
> public void setValue(int pos,T val) \{  
> this.array\[pos\] = val;  
> \}  
> public T\[\] getArray() \{  
> return array;  
> \}  
> \}  
> public static void main(String\[\] args) \{  
> MyArray<Integer> myArray1 = new MyArray<>();  
> Integer\[\] str = myArray1.getArray();//报错  
> \}

原因：T替换为Object后将Object\[\]分配给Integer\[\]引用。通俗讲就是：返回的Object数组里，可能存放的是任何数据类型，可能是String，可能是Person，运行时，直接转给Integer类型的数组，编译器认为不安全。

## 六、泛型的上界 ##

定义泛型类时，有时需要对传入的类型变量做一定约束，可以通过类型边界来约束。  
语法

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

示例

> public class MyArray<E extends Number> \{  
> ...  
> \} //表示只接受 Number 的子类型作为 E 的类型实参

> MyArray<Integer> list1; // 编译通过， Integer 是 Number 的子类型  
> MyArray<String> list2; // 编译错误，String 不是 Number 的子类型

没有指定类型边界 E，可以看作 E extends Object。

复杂示例

> public class MyArray<E extends Comparable<E>> \{  
> ...  
> \} //E必须是实现了Comparable接口的

## 七、泛型方法 ##

语法

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

示例1

> public class Text\{
> 
> public static <E> void swap(E\[\] array, int i, int j) \{  
> E t = array\[i\];  
> array\[i\] = array\[j\];  
> array\[j\] = t;  
> \}
> 
> \}

使用示例1：可以类型推导

> Integer\[\] a = \{ ... \};  
> swap(a, 0, 9);  
> String\[\] b = \{ ... \};  
> swap(b, 0, 9);

使用示例2：不使用类型推导

> Integer\[\] a = \{ ... \};  
> Text.<Integer>swap(a, 0, 9);
> 
>   
> String\[\] b=\{ ... \};
> 
> Text.<String>swep(b,0,9);

[f72a2b1f966d49fa90fcc890e887c8fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/b766085c68ba4b4f8cc499743643f7e2.png
[48c506d136004fae8836554d78decc6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/70502153a10c48eab6ef6e46459bac2c.png
[44bf391d956b4ddb88885db2f79ab029.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/1503a1c34c3e4509858c945fb797a6ea.png
[740cc0a0d4bd4e44ab76ba9c2b67da12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/03/a23b4ebd0dbc4c44a56dddd7558bcaf3.png