认识泛型VS包装类
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 ;}}