🎉欢迎大家收看，请多多支持🌹
🥰关注小哇，和我一起成长🚀个人主页🚀
👑目录
[🚀 Integer类的缓存机制：](#🚀 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等）
java
int a = 6;
//自动装箱
Integer b = a;
Integer b2 = (Integer)a;🚀显式装箱
java
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这个范围内，也不会从内存中调用已经存在的对象，而是创建一个新的对象示例。
🌈自动拆箱和显式拆箱
🚀自动拆箱
java
Integer a = 99;
//自动拆箱
int b = a;
int b2 = (int)a;
🚀显式拆箱
java
Integer a = 99;
//显式拆箱
int c = a.intValue();
double d = a.doubleValue();🌈相关面试题及知识点
下面代码输出内容是什么？
java
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。
泛型🌙
通俗讲，泛型就是适用于许多类型。
从代码角度上看，泛型就是将类型参数化。编译时自动进行类型检查和转换
泛型的主要目的：
就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
⭐语法
🌈基本泛型类定义：
java
class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}这里的泛型类名称是类的名称就，<类型形参列表>是定义在尖括号中的类型参数列表，它们是占位符，用于在类的定义中指定不确定的类型。
例如
java
class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
}🌈多类型参数的泛型类：
java
class ClassName<T1, T2, ..., Tn> {
}该类可以拥有多个类型参数。类型参数之间用逗号分隔。这样的类可以更加灵活，因为它可以同时处理多种类型的数据。
例如：
java
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;
}
}🌈泛型类继承自其它泛型类：
java
class 泛型类名称<类型形参列表> extends 继承类<这里可以使用类型参数> {
// 这里可以使用类型参数
}当泛型类继承自另一个泛型类时，子类可以定义自己的类型参数列表，并且可以在继承时使用父类的类型参数。子类可以选择性地覆盖或保留父类的类型参数。
例如：
java
class GenericList<E> {
// 假设这里有一些与E类型相关的操作
}
class MyList<T> extends GenericList<T> {
// 这里可以直接使用T，因为T被传递给了GenericList
}🌈泛型类继承自特定类型的泛型类：
java
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}🌈具体代码举例：
java
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<>();//1
myArray.setVal(0,10);
myArray.setVal(1,12);
int ret = myArray.getPos(1);//2
System.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的泛型机制是在编译级别实现的，因此编译器生成的字节码文件中不包含泛型的类型信息。
⭐泛型的上界
🌈语法：
java
class 泛型类名称<类型形参 extends 类型边界> {
...
}注意与继承了其它泛型类的泛型类区别
🌈例子：
java
public class MyArray<E extends Number> {
...
}这里只接收Number的子类作为类型参数
MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型
没有指定类型上界时，可视为<E extends Object>
🌈复杂例子：
java
public class MyArray<E extends Comparable<E>> {
...
}这里表示类型参数E必须是实现了Comparable<E>接口的任何类型，实现了这个接口后，
这个类的对象可以与其它同类型的对象进行比较。
⭐泛型方法：
方法限定符 返回值类型 方法名称(形参列表) { ... }
🌈方法示例：
java
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;
}
}🌈 使用方法示例：
🚀可以类型推导：
java
Integer[] a = { ... };
swap(a, 0, 9);
String[] b = { ... };
swap(b, 0, 9);🚀不使用类型推导：
java
Integer[] a = { ... };
Util.<Integer>swap(a, 0, 9);
String[] b = { ... };
Util.<String>swap(b, 0, 9)🎉🎉本次内容结束啦
🌹如有问题，欢迎评论区讨论~~🌹
感谢支持🥰
