认识泛型和包装类

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量574 收藏 16
点赞数 14
分类专栏： 数据结构 Java 文章标签： 开发语言 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76124988/article/details/142216039
版权

认识泛型和包装类

包装类

在java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，java给每个基本类型都对应了一个包装类型。

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

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean

除了Integer和Charater，其余基本类型的包装类都是大写字母。

装箱和拆箱

装箱：把基本数据类型变为包装类类型的过程叫做装箱
拆箱：把包装类类型变为基本数据类型的过程叫做拆箱

public class Test {
    public static void main(String[] args) {
        int i = 10;

        //装箱操作，新建一个Integer类型对象，将i的值放入对象的某个属性中
        Integer integer1 = Integer.valueOf(i);
        Integer integer2 = new Integer(i);

        //拆箱操作，将Integer对象中的值取出，放到一个基本的数据类型中
        int j = integer1.intValue();
    }
}

自动装箱和自动拆箱

装箱/装包：自动(隐式)装箱 显式装箱
拆箱/拆包：自动(隐式)拆箱 显式拆箱
在使用过程中，装箱和拆箱带来了不少代码量，为了减少开发者的负担，java提供了自动机制

public class Test {
    public static void main(String[] args) {
        int a = 10;

        Integer integer1 = Integer.valueOf(a);  //显式装箱
        Integer integer2 = a;                   //隐式装箱，底层帮我们调用了Integer.valueOf(a)

        int i = integer1.intValue();            //显式拆箱
        int j = integer1;                       //隐式拆箱，底层帮我们调用了integer1.intValue()
        
    }
}

接下来我们再来看一段代码：

public class Test {
    //下面代码输出什么，为什么？
    public static void main(String[] args) {
       Integer a = 100;
       Integer b = 100;

       Integer c = 200;
       Integer d = 200;

        System.out.println(a == b);
        System.out.println(c == d);
    }
    //结果为：
    //true
    //false
}

为什么是这种结果呢，这跟我们装箱中的valueOf(int i)这个方法有关系，我们来看源码：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

当 i 在 IntegerCache.low 和 IntegerCache.high之间返回数组中的值，若不是则创建新对象，所以我们再来看这个范围是什么
在这里插入图片描述
在这里插入图片描述
所以100在这个区域内，返回同一个数，所以输出true，而200不在，所以创建了两个新对象，所以输出false

什么是泛型

一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。------来源《java编程思想》对泛型的介绍
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型，从代码上讲，就是对类型实现了参数化。

引出泛型

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
思考：

  1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10];Strings[] strs = new String[10];
  2. 所有类的父类默认为Object类。数组是否可以创建为Object？
public class MyArray {
    public Object[] myArray = new Object[10];

    public Object getMyArray(int pos) {
        return myArray[pos];
    }

    public void setMyArray(int pos,Object value) {
        this.myArray[pos] = value;
    }
}

public class Test {

    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setMyArray(0,123);
        myArray.setMyArray(1,"onward");

        int num = (int)myArray.getMyArray(0);
        String str = (String)myArray.getMyArray(1);
        System.out.println(num);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

问题：

  • 任何数据都可以存放，存放太乱，什么类型都能存放
  • 数组1号下标本身就是字符串，但是编译报错，必须进行强转，什么类型都需要强转。

虽然在当前这种情况，数组确实可以存放任何类型数据都可以存放，但是，更多情况下，我们还是希望它只能够持有一种数据类型，而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象，让编译器去做检查，此时，就需要把类型作为参数传递，需要什么类型就传入什么类型。

语法

class 泛型类型名称<类型形参列表>{
	//这里可以使用类型参数
}

class ClassName<T1,T2,...,Tn>{

}
class 泛型类型名称<类型形参列表>extends 继承类/*这里可以使用类型参数*/{
	//这里可以使用类型参数
}
class ClassName<T1,T2,...,Tn>extends ParentClass<T1>{
	//可以只使用部分类型参数
}

我们可以对上面的代码进行改写

public class MyArray2 <T>{
    public Object[] myArray = new Object[10];

    public T getMyArray(int pos) {
        T value = (T)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, T value) {
        this.myArray[pos] = value;
    }
}


public class Test {

    public static void main(String[] args) {
        MyArray2<Integer> myArray = new MyArray2<Integer>();    //指定当前类型为Integer
        myArray.setMyArray(0,123);  //自动类型强转
        //myArray.setMyArray(1,"onward");       //自动类型检查，编译报错
        myArray.setMyArray(1,12);
        int num = myArray.getMyArray(0);    //不用进行强制类型强转
        System.out.println(num);

        MyArray2<String> myArray2 = new MyArray2<String>();
        myArray2.setMyArray(0,"onward");
        myArray2.setMyArray(1,"forward");
        String str = myArray2.getMyArray(0);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

注意：

  • 类名后的 < T > 代表占位符，表示当前类是一个泛型类
    了解：【规范】类型形参一般使用一个大写字母表示，常用的名称有：
  • E 表示 Element
  • K 表示 Key
  • V 表示 Value
  • N 表示 Number
  • T 表示 Type
  • S、U、V等等表示第二、第三、第四个类型
  • 类型后加入< Integer >指定当前类型，编译器会在我们存放元素的时候进行类型检查。

泛型类的使用

语法

泛型类<类型实参> 变量名;		//定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参);		//实例化一个泛型类对象

示例

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型都必须使用包装类！

类型推导

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>();	//可以推导出实例化需要的类型实参为 Integer

裸类型(Raw Type)

说明

裸类型是一个泛型类但是没有带着类型实参，例如myArray就是一个裸类型

public class MyArray2 <T>{
    public Object[] myArray = new Object[10];

    public T getMyArray(int pos) {
        T value = (T)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, T value) {
        this.myArray[pos] = value;
    }
}

public class Test {

    public static void main(String[] args) {
        MyArray2 myArray = new MyArray2();    //裸类型
        myArray.setMyArray(0,12);
        myArray.setMyArray(1,"onward");
        int num = (int)myArray.getMyArray(0);
        String str = (String) myArray.getMyArray(1);
        System.out.println(num);
        System.out.println(str);
    }
    //结果为：
    //12
    //onward
}

注意：我们尽量不要去使用裸类型，裸类型是为了兼容老版本的API保留的机制
小结：

  • 泛型是将数据类型参数化，进行传递。
  • 使用< T >表示为当前类是一个泛型类。
  • 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

泛型如何编译的

擦除机制

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
java的泛型机制是在编译级别实现的，编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关擦除机制的文章介绍我们可以参考：链接: Java泛型擦除机制之答疑解惑

泛型的上界

在定义泛型类时，有时需对传入的类型变量做一定的约束，可以通过类型边界来约束。

语法

class 泛型类名称<类型实参 extends 类型边界>{
	...
}

示例

public class MyArray2 <E extends Number>{
    public Object[] myArray = new Object[10];

    public E getMyArray(int pos) {
        E value = (E)myArray[pos];
        return value;
    }

    public void setMyArray(int pos, E value) {
        this.myArray[pos] = value;
    }
}

只接受Number的子类型作为E的类型实参

public class Test {

    public static void main(String[] args) {
        MyArray2<Integer> myArray = new MyArray2<Integer>();
        //正常，因为Integer是Number的子类型   
        myArray.setMyArray(0,123);  
        myArray.setMyArray(1,12);
        int num = myArray.getMyArray(0);   
        System.out.println(num);

        MyArray2<String> myArray2 = new MyArray2<String>(); 
        //编译报错：java: 不兼容的类型: java.lang.String无法转换为java.lang.Number，因为String不是Number的子类型
        myArray2.setMyArray(0,"onward");
        myArray2.setMyArray(1,"forward");
        String str = myArray2.getMyArray(0);
        System.out.println(str);
    }
    //结果为：
    //123
    //onward
}

没有指定类型边界E，可以视为E extends Object

复杂示例

public class MyArray<E extends Comparable<E>>{
	...
}

E必须是实现了Comparable接口的

泛型方法

定义方法

方法限定符<类型形参列表> 返回值类型 方法名称(形参列表){...};

示例

需求：写一个泛型类。当中有个方法，可以求数组最大值

public class Alg <E>{
    public E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++) {
            if(array[i] > max){     //编译报错
                max = array[i];
            }
        }
        return max;
    }
}

上述代码会编译报错。由于擦除机制，在运行的时候类型E都会被擦除为Object类
类如果要比较大小，引用存的是地址，无法直接比较，要扩展Comparable接口，才能调用compareTo()方法。

public class Alg <E extends Comparable<E>>{
    public E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMax(array));
    }
}

使用类型推导和不用类型推导

上述代码还可以这样写将继承接口写在方法上

public class Alg2 <E>{
    public <E extends Comparable<E>>E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        Alg2<Integer> alg2 = new Alg2<>();
        System.out.println(alg2.findMax(array));    //可以前面不写，会自动检查，类型推导
        System.out.println(alg2.<Integer>findMax(array));   //不使用类型推导
    }
}

静态的泛型方法

public class Alg3 <E>{
    //静态的泛型方法 需要在static后用<>声明泛型类型参数
    public static <E extends Comparable<E>> E findMax(E[] array){
        E max = array[0];
        for (int i = 1; i < array.length - 1; i++)
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,33,67,8,99,4};
        System.out.println(Alg3.findMax(array));
    }
}

关于泛型和包装类我们先了解到这，对泛型的深入了解还需要一定时间的沉淀，才能对其有深刻的理解和掌握，道阻且长，我们一起努力！！！

runing up that hill
关注
专栏目录
JAVA中的泛型
wenyusuran的专栏
10-15 1541
What      Java从1.0版本到现在的8，中间Java5中发生了一个很重要的变化，那就是泛型机制的引入。Java5引入了泛型，主要还是为了满足在1999年指定的最早Java规范之一。经过了5年左右的时间，专家组定义了一套泛型规范，实现后通过测试投入到使用。所以说泛型是Java5以后才有的，欲知详情，继续往下看。 Why      换个角度想，Java5引入泛型，必定是它能带来好处，
认识泛型VS包装类
qq_66333706的博客
08-23 598
class Point<T>{ // 此处可以随便写标识符号，T是type的简称// var的类型由T指定，即：由外部指定public T getVar(){ // 返回值的类型由外部决定return var;public void setVar(T var){ // 设置的类型也由外部决定// 里面的var类型为String类型// 设置字符串// 取得字符串的长度多元泛型class Notepad<K,V>{ // 此处指定了两个泛型类型// 此变量的类型由外部决定。
包装类&认识泛型
weixin_70564024的博客
02-14 525
方法限定符返回类型 方法名称 (形参列表){...
包装类和泛型
m0_61608447的博客
05-12 233
包装类和泛型的基础讲解和认识
包装类和认识泛型
m0_73999419的博客
09-14 144
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。方法限定符 返回值类型 方法名称(形参列表) { … }
Java 泛型，你了解类型擦除吗？
热门推荐
frank 的专栏
08-05 10万+
泛型，一个孤独的守门者。 大家可能会有疑问，我为什么叫做泛型是一个守门者。这其实是我个人的看法而已，我的意思是说泛型没有其看起来那么深不可测，它并不神秘与神奇。泛型是 Java 中一个很小巧的概念，但同时也是一个很容易让人迷惑的知识点，它让人迷惑的地方在于它的许多表现有点违反直觉。文章开始的地方，先给大家奉上一道经典的测试题。List&lt;String&gt; l1 = new ArrayList&lt;Stri
Java中的泛型
TheDevice的博客
03-30 259
泛型 通配符包装类(Wrapper Class)装箱和拆箱
【Java基础】包装类，Number类总结 包装类常用方法
wayne_lee_lwc的博客
02-25 615
总述 数据，是一个程序最基本的要素，它的最终形式一定是基本数据类型。java是一种面向对象的语言，不能创建基础数据类型对象，也不能在使用泛型时兼容基本类型。为了解决这个问题，将基本类型视作对象进行处理。Java给每一个基本类型提供了包装类，放在java.lang包下。 所有对应基本类型，其包装类共有八个： Integer (int) Long (long) Short (short) Doubl...
深入分析Java反射(三)-泛型
m0_67698950的博客
05-26 1114
前提# Java反射的API在JavaSE1.7的时候已经基本完善，但是本文编写的时候使用的是Oracle JDK11，因为JDK11对于sun包下的源码也上传了，可以直接通过IDE查看对应的源码和进行Debug。 本文主要介绍反射中一个比较难的问题-泛型。 泛型的简介# 泛型是在2004年JavaSE 5.0(JDK1.5)版本中添加到Java编程语言中的泛型编程工具。泛型的设计是为了应用在Java的类型系统，提供"用类型或者方法操作各种类型的对象从而提供编译期的类型安全功能(原文：a type
嵌入式鸿蒙系统开发语言与开发方法分析
嵌入式技术开发
09-10 1128
可复用的UI单元，可组合其它组件，如上述被@Component装饰的struct Hello。UI描述:声明式的方法来描述UI的结构，例如build()方法中的代码块。
Java-网络
2301_81543552的博客
09-14 348
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 346
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 432
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 595
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 408
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 441
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 598
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
weixin_48278764的博客
09-14 924
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
泛型类 和 包装类的区别
08-12
泛型类和包装类是Java语言中两个不同的概念： 1. **泛型类** (Generic Classes)： 泛型是一种将类型参数化的技术，它允许你在类、接口或方法声明中指定类型变量。比如，`List<String>`就是一种泛型类实例，表示一个只能存储字符串的对象列表。使用泛型可以避免因数据类型变化导致的类型转换异常，并提高代码的复用性和类型安全性。 2. **包装类** (Wrapper Classes): Java的原始类型如int、char等没有内置的封装机制，为了在需要引用原始类型的地方提供对象，就设计了对应的包装类，例如Integer、Character等。这些包装类提供了诸如equals()、hashCode()等方法，同时也实现了转型操作，使得它们可以与其他对象一起工作，如作为集合中的元素。包装类主要用于处理基本类型的自动装箱和拆箱。 两者的区别在于： - 泛型更关注方法的参数和返回值类型的统一，提供的是编译期的安全性。 - 包装类则专注于基础类型到引用类型之间的转换，以及对基本类型特性的增强。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值