【数据结构】包装类和泛型

 🎉欢迎大家收看，请多多支持🌹

🥰关注小哇，和我一起成长🚀个人主页🚀

⭐在更专栏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)

---

🎉🎉本次内容结束啦

🌹如有问题，欢迎评论区讨论~~🌹

感谢支持🥰