Java集合框架入门之泛型和包装类

目录

• 1. 预备知识-泛型（Generic）
• 1.1 泛型的引入
• 1.2 泛型的分类
• 1.3 泛型类的定义
• 1.4 泛型编译的机制
• 2. 预备知识-包装类（Wrapper Class）
• 2.1 基本数据类型和包装类的对应关系
• 2.2 包装类介绍
• 2.3 装箱（boxing）和拆箱（unboxing）
• 2.4 自动装箱（autoboxing）和自动拆箱（autounboxing）
• 2.5 包装类面试题

前言： 本章主要是为了后面学习集合框架所做的知识补充。补充了泛型以及包装类两个知识，但是该章泛型的讲解不够全面，主要是为了集合框架学习做铺垫。

1. 预备知识-泛型（Generic）

1.1 泛型的引入

我们之前实现过的顺序表，实现的是保存某一类型的元素（如 int 型）

示例代码：

public class MyArrayList{
    private int[] array;	  // 保存顺序表的元素，元素都为 int 类型
    private int size;		  // 保存顺序表内存数据个数
	public MyArrayList(){
        this.array=new int[10];
    }
    public void add(int val){
        // 尾插
        this.array[size]=val;
        this.size++;
    }
    public int get(int index){
        // 获取 index 位置的元素
        return this.array[index];
    }
    ...
}

但是这样写的话，这个顺序表就只能存储 int 类型的元素了

如果现在需要保存指向 Person 类型对象的引用的顺序表，该如何解决呢？如果又需要保存指向 Book 类型对象的引用呢？

• 首先，我们在学习多态的时了解到：基类的引用可以指向子类的对象
• 其次，我们也知道 Object 类是 Java 中所有所有类的祖先类

因此，要解决上述问题，我们可以这样做

将我们的顺序表的元素类型定义成 Object 类型，这样我们的 Object 类型的引用可以指向 Person 类型的对象或者指向 Book 类型的对象

示例代码：

public class MyArrayList{
    private Object[] array;	  // 保存顺序表的元素，即 Object 类型的引用
    private int size;		  // 保存顺序表内存数据个数
	public MyArrayList(){
        this.array=new Object[10];
    }
    public void add(Object val){
        // 尾插
        this.array[size]=val;
        this.size++;
    }
    public Object get(int index){
        // 获取 index 位置的元素
        return this.array[index];
    }
    ...
}

这样，我们就可以很自由的存储指向任意类型的对象的引用到我们的顺序表了

示例代码：

MyArrayList books = new MyArrayList();
for(int i=0; i<10;i++){
    books.add(new Book());	// 插入10本书到顺序表
}

MyArrayList people = new MyArrayList();
for(int i=0; i<10; i++){
    people.add(new Person());	// 插入10个人到顺序表
}

遗留问题： 现在的 MyArrayList 虽然可以做到添加任意类型的引用到其中，但会遇到下面的问题

当我们使用这样的代码时，明知道存储的是哪种类型的元素，但还是要进行强制转换。如

MyArrayList books = new MyArrayList();
books.add(1);

// 将 Object 类型转换为 int 类型 （需要类型转换才能成功）
int val=(int)books.get(0);
System.out.println(val);
// 结果为：1

虽然知道返回的元素是 int 类型，但还是要进行强制类型转换

创建的一个 MyArrayList 中可以存放各种类型，形成了一个大杂烩。并且将 Object 类型（具体是 A 类型）转换为 B 类型时，即使强制转换，也会产生异常 ClassCastException

MyArrayList books = new MyArrayList();
books.add(new Book());
    
// 将 Object 类型转换为 Person （需要类型转换才能成功）
Person person = (Person)books.get(0);
// 但是虽然编译正确了，运行时还是会抛出异常 ClassCastException

因此 Java 针对这一问题就出现了泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

1.2 泛型的分类

泛型可以分为两类

• 泛型类
• 泛型方法

预备知识主要是为了学习、理解集合框架，所以这里只简单介绍泛型类，后面将会专门为泛型写一个章节。

1.3 泛型类的定义

规则：

• 在类名后面添加了类型参数声明
• 泛型类的类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符
• 泛型的泛型参数一定是类类型，如果是简单类型，那么必须是对应的包装类

这里直接将上面定义的 MyArrayList 类改写成泛型类

示例代码：

public class MyArrayList<T>{
    private T[] array;
    private int size;
	public MyArrayList(){
        this.array=(T[])new Object[10];
    }
    public void add(T val){
        this.array[size]=val;
        this.size++;
    }
    public T get(int index){
        return this.array[index];
    }
    ...
}

此时我们就将这个顺序表改写成了一个泛型类，接下来我们来使用它

示例代码：

MyArrayList<String> myArrayList = new MyArrayList<>();
myArrayList.add("Hello");
myArrayList.add("Goodbye");
String s = myArrayList.get(0);
System.out.println(s);
// 结果为：Hello

上述的 myArrayList 只能存放 String 类型的元素，并且不需要再添加强制类型转换

泛型的意义：

• 自动进行类型的检查
• 自动进行类型的转换

Java 中泛型标记符： 类型形参一般使用一个大写字母表示，如：

• E — Element（在集合中使用，因为集合中存放的是元素）
• T — Type（Java 类）
• K — Key（键）
• V — Value（值）
• N — Number（数值类型）
• ? —表示不确定的 Java 类型

1.4 泛型编译的机制

如果不重写 toString 方法，输出某个类的实例化对象，如

代码示例：

// 假设创建了一个 Person 类
Person person = new Person();
System.out.println(person);

结果为：

如果用上述的泛型类，输出其实例化对象，如

代码示例：

MyArrayList<String> myArrayList1 = new MyArrayList<>();
System.out.println(myArrayList1);
MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
System.out.println(myArrayList2);
MyArrayList<Boolean> myArrayList3 = new MyArrayList<>();
System.out.println(myArrayList3);

结果为：

我们发现：

泛型类和非泛型类输出的样例格式都是一样的：类名@地址

为什么泛型类的实例化对象结果不是输出泛型类后面的泛型参数 < T > 呢？

这里就要了解泛型是怎么编译的

泛型的编译使用了一种机制：擦除机制

擦除机制只作用于编译期间，换句话说，泛型就是编译时期的一种机制，运行期间没有泛型的概念

解释：

• 当我们存放元素的时候，泛型就会根据 <T> 自动进行类型的检查。
• 但编译的时候，这些 <T> 就被擦除成了 Object

2. 预备知识-包装类（Wrapper Class）

Object 引用可以指向任意类型的对象，但有例外出现了，8 种基本数据类型不是对象，那岂不是刚才的泛型机制要失效了？

实际上也确实如此，为了解决这个问题，Java 中引入了一类特殊的类，即这 8 种基本数据类型的包装类。在使用过程中，会将类似 int 这样的值包装到一个对象中去。

2.1 基本数据类型和包装类的对应关系

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

2.2 包装类介绍

Java 是一个面向对象的语言，基本类型并不具有对象的性质，为了与其他对象“接轨”就出现了包装类型

既然包装类是一个类，那么就有它对应的成员变量和成员方法。打孔大家可以具体的去查看文档了解各个包装类

2.3 装箱（boxing）和拆箱（unboxing）

包装类中有两个重要的知识点，装箱和拆箱

• 装箱： 把基本数据类型转为对应的包装类型
• 拆箱： 把包装类型转换为基本数据类型

装箱示例代码：

// 方式一
Integer i1 = 10;
// 方式二
Integer i2 = Integer.valueOf(10);
// 方式三
Integer i3 = new Integer(10);

拆箱示例代码：

// 方式一
int i = i1;
// 方式二
int i = i1.intValue();

2.4 自动装箱（autoboxing）和自动拆箱（autounboxing）

那自动装箱又是什么呢？我们可以对下面这份代码进行反编译（反编译指令为 javap -c 类名）

代码示例：

public class TestDemo {
    public static void main(String[] args) {
        Integer i = 10;
        int j = i;
    }
}

通过反编译指令，得到了如下结果：

• 我们发现在底层中 10 是通过 Integer.valueOf 这个静态方法赋值给了 i，进行装箱操作
• 再将 i 通过 Integer.intValue 这个方法复制给了 j，进行拆箱操作

那么什么是手动装箱和手动拆箱呢？

就是和底层原理一样，通过 Integer.valueOf 和 Integer.intValue 方法进行的装箱和拆箱就是手动的

而不是通过这些方法进行的装箱和拆箱就是自动的

2.5 包装类面试题

思考下列代码结果：

Integer a = 120;
Integer b = 120;
System.out.println(a == b);

结果为：true

再看一个代码：

Integer a = 130;
Integer b = 130;
System.out.println(a == b);

结果为：false

这是为什么呢？

• 首先我们看到 a 和 b 都进行了装包操作，因此我们就要去了解装包的时候发生了什么
• 通过转到 Integer.valueOf 的定义我们看到

• 该定义意思就是：如果 i 大于等于 IntegerCache 的最小值，小于它的最大值，就返回 IntegerCache.cache[i + (-IntegerCache.low)] ，否则就返回 new Integer(i)
• 而 new 一个对象的话，相当于比较的就是地址的值了，所以是 false
• 因此我们要知道 IntegerCache 的最大值以及最小值是多少，此时我们转到它的定义

• 上图中我们了解到 low 为 -128、high为 127，而 cache 其实就是一个数组。我们知道数组的下标是从 0 开始的，而 i + (-IntegerCache.low) 表示的最小值正好就是 0，也就是说明数组下标为 0 时存储的值就为 -128，并且依次往后递推。
• 因此数值在 -128 到 127 之间时返回的就是和这个数相同的值，所以结果为 true

那为什么要专门创建一个数组呢？所有数字返回 new 的对象不就行了吗？

这是因为，这样做可以提高效率。实例化对象是需要消耗资源的。而数组其实就是一个对象，可以减少资源的消耗。

到此这篇关于Java集合框架入门之泛型和包装类的文章就介绍到这了,更多相关Java 泛型详解内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！