Java：包装类简单认识泛型

一、包装类

包装类指的是基本数据类型（如int、double等）对应的类类型，我们可以通过包装类直接调用里面的方法！

基本数据类型                      包装类
byte                             Byte
short                            Short
int                              Integer
long                             Long 
float                            Float
double                           Double
char                             Character
boolean                          Boolean

除了Integer和Character，其余基本数据类型的包装类都是其对应基本数据类型的首字母大写！

二、装箱和拆箱

1、装箱：把一个基本类型转为包装类型

 //装箱
public class Test1 {public static void main(String[] args) {int a=0;Integer ii=Integer.valueOf(a);//显示装箱Integer ii2=a;//自动装箱（底层调用的也是valueOf方法）}
}

2、拆箱：把一个包装类型转换为基本类型

//拆箱
public class Test1 {public static void main(String[] args) {Integer ii=10;//自动装箱int a=ii.intValue();//手动拆箱int aa=ii;//自动拆箱（底层调用的也是intValue方法）}
}

一个问题：下面程序运行的结果是什么？

//程序运行的结果是什么？
public class Test1 {public static void main(String[] args) {Integer a=100;Integer b=100;System.out.println(a==b);//true or falseInteger c=200;Integer d=200;System.out.println(c==d);//true or false}
}

按照一般的逻辑，这个程序的运行结果要么都为true，要么都为false，那我们来看看实际过程中的结果到底是什么？

为什么会出现这样的结果？

让我们来分析一下这段代码：

1、首先，Integer a=100涉及的是装箱操作！这是我们上面所学的，而且我们知道这个装箱属于自动装箱！它的底层调用的是valueOf方法！

2、那么就需要进入Integer类中看看这个valueOf方法了!

如图：

这个方法是这样执行的，如果参数 i 的范围属于[IntegerCache.low，IntegerCache.high]之间，那么函数返回数组的一个元素！

否则新实例化一个Integer类！

问题的关键就在于这个范围：让我来告诉大家，这个范围就是 [-128,127]，因此才会出现截然相反的结果！

三、什么是泛型

泛型：简单来说，就是适用于许多许多类型！从代码上讲，就是对类型实现了参数化，使类型变得像参数一样可以作为一个数组的元素！

如果听不懂看，也没有问题，这个描述有点过于抽象，让我们看看实例加深对这段话的理解！

举个例子：实现一个类，类中包含一个数组成员，使得数组可以存放任何类型的数据！也可以根据成员方法返回数组中的某个元素！

因为Object是所有类的父类，任何子类都继承于Object类，因此使用Object类作为数组类型。

//实现MyArray类：这个类有一个数组成员myArray，可以存放任何类型的数据
class MyArray{//数组成员public Object[] myArray=new Object[10];//成员方法：可以给数组传入任何类型的参数（如int,double等)public void setValue(int pos,Object x){myArray[pos]=x;}//成员方法：可以获取数组中的元素public Object getValue(int pos){return myArray[pos];}
}public class Test1 {public static void main(String[] args) {MyArray myArray=new MyArray();//实例化一个MyArray类myArray.setValue(1,12);//给myArray[1]存入int类型的1myArray.setValue(2,"hello");//给myArray[2]存入String类的"hello"}
}

接下来我们进行一个操作，获取数组中的"hello"，并将其赋值给String类的str。

如图：

这样做的化需要强制类型转换，因为你getValue返回值的类型是Object类，你将其返回值赋值给String类时就需要将Object类强制转换为String类

如图：强制类型转换后，程序不会报错！

但是这里就有一个问题了，这个类只能接收任何类型的数据，但是每次取出数据的时候，我们都需要强制类型转换操作，才可以获取该数组元素！如果这个数组存储了许许多多的数据时，我们怎么知道要取出的元素是什么类型的呢？

答：这个时候，我们就需要对这个代码进行修改了，同时使用泛型语法！

泛型语法：

以下对代码的修改如下：

对类的修改：

1、在MyArray类的后面添加<T>: 这个T表示这个类是一个泛型

2、setValue方法的传入参数的数据类型修改为T

3、getValue方法的返回值类型改为T，同时进行强制类型转换！

使用该泛型类时的语句修改：

1、实例化该泛型类时，在类名后面添加<类型名>，这个类型名取决于你即将传入的数据类型，比如，你要传入int类型的数据，就填Integer，如果要传入字符串，就填写String

//对类的修改
class MyArray<T>{        //1、<T>:表示这是一个泛型类public Object[] myArray=new Object[10];public void setValue(int pos,T x){     //2、参数传入类型给为TmyArray[pos]=x;}public T getValue(int pos){//3、方法的返回值类型改为Treturn (T)myArray[pos];//返回值强制类型转换为T}
}//使用该泛型类时的语句修改
public class Test1 {public static void main(String[] args) {MyArray<Integer> myArray=new MyArray<Integer>();//1、<>里面填写类型名myArray.setValue(1,12);//此时无法给数组传入String类的数据,因为实例化MyArray时，指定了当前类型为整型myArray.setValue(2,"hello");//！！！这一句报错！}
}

这里要强调的是，看到上面代码我注释的报错语句没？如图：

此时无法给该数组出传入字符串，因为在前面实例化的时候指定了当前类型为int

它的具体原理如图：

这里解释一下我们要给数组传入的类型是int类型，为什么<>不填写int ，而是Integer，这是因为此时的<>只能填写类型名，不能填写基本数据类型（int、double之类）！因此得使用其基本类型的包装类代替！

注意：实例化的时候：以下为例：

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

也可简写为：

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

使用了泛型之后，当每次取出数据时，就不需要我们进行强制类型转换！

如图: 类名<T> 表示一个占位符，表示当前类是一个泛型类（并不是一定要填T）

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

E:表示Element
K:表示Key
V:表示Value
N:表示Number
T：表示Type

四、泛型的上界

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

语法：
class 泛型类名称<类型形参 extends 类型边界>{
//.......
}

举一个例子：


//它表示以后给MyArray传入的参数，要么是Number这个类，要么是Number的子类
class MyArray<E extends Number>{
//...
}MyArray<Integer>;//正常运行，因为Integer是Number的子类型
MyArray<String>;//编译错误，因为String不是Numberd的子类型

举另外一个相对复杂的例子：

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

实例：实现一个泛型类，可以找出数组中的最大值

//定义一个泛型类，找到数组当中的最大值：//这样做是为了限定边界，T一定是实现了Comparable接口的
class Alg<T extends Comparable<T>>{public T findMax(T[] array){T max=array[0];for(int i=0;i< array.length;i++){//此时的max是一个引用类型，引用类型之间无法直接比较,所以要使用compareTo方法if(array[i].compareTo(max)>0){max=array[i];}}return max;}}

接着就可以根据需要，求出任意类型数组中的最大值：

public static void main(String[] args) {//比较Integer类型数组Alg<Integer> alg=new Alg<>();Integer[]  array={1,2,3,4};Integer num=alg.findMax(array);System.out.println(num);//比较字符串数组Alg<String> alg1=new Alg<>();String[] array1={"abc","bcd","def"};String str=alg1.findMax(array1);System.out.println(str);}

运行结果：

五、泛型方法

泛型方法：顾名思义，就是适用于任何类的方法！

那么该如何写一个泛型类呢？


//泛型方法格式：
方法限定符 <类型形参列表> 返回值类型 方法名称 （形参列表）{}
class Alg2{//写一个泛型方法:找出数组中的最大值（任何类型的数组都适用）public <T extends Comparable<T>> T findMax(T[] array){T max =array[0];for (int i = 0; i < array.length; i++) {if (array[i].compareTo(max) > 0) {max = array[i];}}return max;}
}

使用泛型方法找出数组中最大值：

public static void main(String[] args) {//比较Integer类型的数组Alg2 alg2=new Alg2();Integer[] array={1,2,4,5};Integer max=alg2.findMax(array);//注意！System.out.println(max);//比较String类型的数组String[] array1={"abc","bcd","def"};String str =alg2.findMax(array1);System.out.println(str);}

有些伙伴可能会疑问，前面教学泛型类的时候，好歹在实例化泛型类的时候使用<>传入了类型名称（如 Alg<Integer> alg=new Alg<Integer>();）这样起码可以知道是你的T表示什么类型，但是使用泛型方法时却没有使用<>中传入类型名称。这是为什么？

答：其实是因为，上述代码语句：Integer max=alg2.findMax(array)已经可以推出T是Integer类型了。它类似于实例化泛型类时的语句：MyArray<Integer> myarray=new MyArray<>();

如果非要传入类型的话，也可以写成Integer max=alg2.<Integer>findMax(array)

程序运行：