【数据结构】包装类和泛型
🎉欢迎大家收看，请多多支持🌹
🥰关注小哇，和我一起成长🚀个人主页🚀
⭐在更专栏Java ⭐数据结构
⭐已更专栏有C语言、计算机网络⭐
👑目录
包装类🌙
⭐基本类型对应的包装类
⭐装箱与拆箱
🌈自动装箱和显式装箱
🚀自动装箱：
🚀显式装箱
🚀 Integer类的缓存机制：
🌈自动拆箱和显式拆箱
🚀自动拆箱
🚀显式拆箱
🌈相关面试题及知识点
泛型🌙
⭐语法
🌈基本泛型类定义：
🌈多类型参数的泛型类：
🌈泛型类继承自其它泛型类：
🌈泛型类继承自特定类型的泛型类：
🌈具体代码举例：
⭐泛型类的使用：
🌈语法：
🌈举例：
⭐裸类型（了解）：
⭐泛型的擦除机制（泛型如何编译）：
⭐泛型的上界
🌈语法：
🌈例子：
🌈复杂例子：
⭐泛型方法：
🌈方法示例：
🌈 使用方法示例：
🚀可以类型推导：
🚀不使用类型推导：
包装类🌙
Java中每个基本数据类型都对应了一个包装类，
除了int的包装类是Integer，char的包装类是Character，其他的基本类型对应的包装类都是将首字母大写。
| 基本数据类型 | 包装类 |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| boolean | Boolean |
| float | Float |
| double | Double |
Java中的泛型中，不能直接使用基本数据类型作为类型参数；
如果需要使用与基本数据类型相关的泛型，应该使用它们对应的包装类。
⭐装箱与拆箱
又叫装包或拆包。
🌈自动装箱和显式装箱
🚀自动装箱：
自动地将基本数据类型（如int、double等）转换为它们对应的包装类（如Integer、Double等）
int a = 6;//自动装箱Integer b = a;Integer b2 = (Integer)a;🚀显式装箱
int a = 6;//显式装箱,调用valueOf()方法Integer d = Integer.valueOf(888);Integer d2 = Integer.valueOf(a);Integer d3 = new Integer(a);//已弃用，避免使用🚀 Integer类的缓存机制：
这个缓存机制默认缓存 -128~127的所以Integer对象。
当你创建Integer类型的对象时，（使用.valueOf或自动装箱来创建对象，）
如果值在这个范围内，Java会直接从内存中返回已经存在的对象，而不是创建新对象。
因此在这个范围内的Integer变量可能指向同一个对象示例。
为什么是可能？
如果使用显式装箱new Integer(int value)来创建，那么即使值在 -128~127这个范围内，也不会从内存中调用已经存在的对象，而是创建一个新的对象示例。
🌈自动拆箱和显式拆箱
🚀自动拆箱
Integer a = 99;//自动拆箱int b = a;int b2 = (int)a;🚀显式拆箱
Integer a = 99;//显式拆箱int c = a.intValue();double d = a.doubleValue();🌈相关面试题及知识点
下面代码输出内容是什么？
public static void main(String[] args) {Integer aa = 128;Integer bb = 128;System.out.println(aa == bb);Integer a = 127;Integer b = 127;System.out.println(a == b);}答案是false和true
为什么呢？
这涉及两个知识点：Integer的缓存机制、引用类型的比较方式。
这里用自动装箱将int类型值转换为Integer对象，其中a和b为127，在 -128~127这个范围内，因此a和b都指向内存中返回的同一个对象。
而aa、bb值不在范围内，因此aa、bb各自创建一个新的对象。
另外，代码中是用 == 来比较的，在引用类型中，==比较的是实例对象的地址，.equals()比较的是对象的内容，.compareTo()比较的是内容大小。
a和b指向同一个对象，因此 a==b结果为true；
aa和bb指向的不是同一个对象，因此 aa==bb结果为false。
泛型🌙
通俗讲，泛型就是适用于许多类型。
从代码角度上看，泛型就是将类型参数化。编译时自动进行类型检查和转换
泛型的主要目的：
就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
⭐语法
🌈基本泛型类定义：
class 泛型类名称<类型形参列表> { // 这里可以使用类型参数
}这里的泛型类名称是类的名称就，<类型形参列表>是定义在尖括号中的类型参数列表，它们是占位符，用于在类的定义中指定不确定的类型。
例如
class Box<T> { private T t; public void set(T t) {this.t = t; } public T get() {return t; }
}🌈多类型参数的泛型类：
class ClassName<T1, T2, ..., Tn> {
}该类可以拥有多个类型参数。类型参数之间用逗号分隔。这样的类可以更加灵活，因为它可以同时处理多种类型的数据。
例如：
class Pair<K, V> { private K key; private V value; public void setKey(K key) {this.key = key; } public void setValue(V value) { this.value = value; } public K getKey() { return key;} public V getValue() { return value;}
}🌈泛型类继承自其它泛型类：
class 泛型类名称<类型形参列表> extends 继承类<这里可以使用类型参数> { // 这里可以使用类型参数
}当泛型类继承自另一个泛型类时，子类可以定义自己的类型参数列表，并且可以在继承时使用父类的类型参数。子类可以选择性地覆盖或保留父类的类型参数。
例如：
class GenericList<E> { // 假设这里有一些与E类型相关的操作
} class MyList<T> extends GenericList<T> { // 这里可以直接使用T，因为T被传递给了GenericList
}🌈泛型类继承自特定类型的泛型类：
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> { // 可以只使用部分类型参数
}🌈具体代码举例：
class MyArray<T> {public Object[] array = new Object[10];public T getPos(int pos) {return (T)this.array[pos];}public void setVal(int pos,T val) {this.array[pos] = val;}}public class TestDemo {public static void main(String[] args) {MyArray<Integer> myArray = new MyArray<>();//1myArray.setVal(0,10);myArray.setVal(1,12);int ret = myArray.getPos(1);//2System.out.println(ret);myArray.setVal(2,"Java");//3，此处报错}}
注释1处，类型后加入<Integer>指定当前类型。
注释2处不用再进行强制类型转换，因为在getpos()中返回值前就转换了。
注释3处报错，"Java"是String类型，但myArray已经指定了Integer类型，编译报错。编译器会在我们存放元素时进行类型检查。
类名后的<T>代表占位符，表示当前类是一个泛型类，< >中必须是引用类型，不能是基本数据类型。
类型形参一般用一个大写字母表示，常见的有：
T代表Type E代表Element K代表Key V代表Value
N代表Number S、U、V……第二、第三、第四个类型
⭐泛型类的使用：
🌈语法：
泛型类<类型参数> 变量名字； //定义一个泛型类引用
new 泛型类<类型实参> （构造方法实参); //实例化一个泛型类对象
🌈举例：
MyArray<Integer> arr = new MyArray<Integer>();
当编译器可根据上下文推导处类型参数的时候，可以省略< >中的类型参数
MyArray<Integer> arr = new MyArray<>();
⭐裸类型（了解）：
是一个泛型类，但是没有类型实参：
MyArray arr = new MyArray();
我们不需要自己去使用裸类型，它是为了兼容老版本的API保留的机制。
⭐泛型的擦除机制（泛型如何编译）：
在编译过程中将所有的T替换为Object，这种机制就是擦除机制。
当泛型类被类型擦除时，如果泛型类中的类型参数部分指定上限（如<T extends String>），则类型参数会被替换成类型上限。
Java的泛型机制是在编译级别实现的，因此编译器生成的字节码文件中不包含泛型的类型信息。
⭐泛型的上界
🌈语法：
class 泛型类名称<类型形参 extends 类型边界> {...}注意与继承了其它泛型类的泛型类区别
🌈例子：
public class MyArray<E extends Number> {...}这里只接收Number的子类作为类型参数
MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型
没有指定类型上界时，可视为<E extends Object>
🌈复杂例子：
public class MyArray<E extends Comparable<E>> {...}这里表示类型参数E必须是实现了Comparable<E>接口的任何类型，实现了这个接口后，
这个类的对象可以与其它同类型的对象进行比较。
⭐泛型方法：
方法限定符 返回值类型 方法名称(形参列表) { ... }
🌈方法示例：
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;}}🌈 使用方法示例：
🚀可以类型推导：
Integer[] a = { ... };swap(a, 0, 9);String[] b = { ... };swap(b, 0, 9);🚀不使用类型推导：
Integer[] a = { ... };Util.<Integer>swap(a, 0, 9);String[] b = { ... };Util.<String>swap(b, 0, 9)🎉🎉本次内容结束啦
🌹如有问题，欢迎评论区讨论~~🌹
感谢支持🥰
