回顾Java基本数据类型，浅谈基本类型包装类

目录

回顾基本数据类型

包装类介绍

概述:

包装类与基本类型：

思考1：

思考2：

包装类型与基本类型的异同

包装类的特点

包装类的使用

---

​​​​​​​

回顾基本数据类型

 

       Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。分别是：byte（位）、short（短整数）、int（整数）、long（长整数）、float（单精度）、double（双精度）、char（字符）和boolean（布尔值）。

byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
• 浮点数的默认类型为 double 类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；

• 例子：

  double   d1  = 7D ;
  double   d2  = 7.; 
  double   d3  =  8.0; 
  double   d4  =  8.D; 
  double   d5  =  12.9867; 

  7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

char：

• char 类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（十进制等效值为 0）；
• 最大值是 \uffff（即为 65535）；
• char 数据类型可以储存任何字符；
• 例子：char letter = 'A';。

包装类介绍

概述:

       所谓包装类，就是能够直接将简单类型的变量表示为一个类。

       数值型包装类都继承至Number，而字符型和布尔型继承至Object。

包装类与基本类型：

思考1：

为什么需要包装类？

       1.首先，Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，为基本数据类型设计一个对应的类进行代表，这种方式增强了Java面向对象的性质。

       2.基本数据类型，在实际使用时将存在很多的不便，很多地方都需要使用对象而不是基本数据类型。例如，在集合类中，我们是无法将int 、double等类型放进去的，因为集合的容器要求元素是Object类型。而包装类型的存在使得向集合中传入数值成为可能，包装类的存在弥补了基本数据类型的不足。

       3.包装类还为基本类型添加了属性和方法，丰富了基本类型的操作。如当我们想知道int取值范围的最小值，我们需要通过运算，如下面所示，但是有了包装类，我们可以直接使用Integer.MAX_VALUE即可。

思考2：

为什么要保留基本数据类型？

       我们都知道在Java语言中，用new关键字创建的对象是存储在堆里的，我们通过栈中的引用来使用这些对象，所以，对象本身来说是比较消耗资源的。对于经常用到的类型，如int等，如果我们每次使用这种变量的时候都需要new一个对象的话，就会比较笨重了。所以，Java提供了基本数据类型，这种数据的变量不需要使用new在堆上创建，而是直接在栈内存中存储，因此会更加高效。

包装类型与基本类型的异同

1. 在Java中，一切皆对象，但八大基本类型却不是对象
2. 声明方式的不同，基本类型无需通过new关键字来创建，而包装类型需new关键字
3. 存储方式及位置的不同，基本类型是直接存储变量的值保存在栈中能高效的存取，包装类型需要通过引用指向实例，具体的实例保存在堆中
4. 初始值的不同，包装类型的初始值为null，基本类型的的初始值视具体的类型而定，比如int类型的初始值为0
5. 使用方式的不同，比如与集合类合作使用时只能使用包装类型

包装类的特点

       所有包装类都是使用final修饰的，不能被继承，包装类是不可变类，包装类的对象被创建后，它所包含的基本类型数据就不能改变。其中数值型对应的包装类都是继承自Number类，而字符型和布尔型继承至Object类。

包装类的使用

1.与基本数据类型的转换

装箱：把基本数据类型转换成包装类，分为自动装箱和手动装箱
拆箱：把包装类转换成基本数据类型，分为自动拆箱和手动拆箱

示例代码如下：

/*
*
* @装箱：把基本类型转换为对应的包装类型
*
* @拆箱：把包装类型转换为对应的基本类型
*
* */
public class Boxing {
    public static void main(String[] args) {
//        装箱：把基本类型转换为对应的包装类型
//        调用方法实现
        Integer i = Integer.valueOf(100);

/*        自动装箱：
           基本类型自动转换为引用类型
             隐藏了中间的实现过程！       */
        Integer i1 = 100;

//        拆箱：把包装类型转换为对应的基本类型
//        ---->拆箱   i1.intValue()
        i1.intValue();
//        ---->自动拆箱 ：隐藏了拆卸操作
//                注意 ： 引用类型不能为空
        i1+=200;
//        此处为自动装箱
        i1=i1.intValue()+200;
    }
}

2.与字符串的转换   

基本类型转换为String类型 使用String的valueof（）方法或者使用 +""  这里就涉及到数据类型的自动提升。

String类型转换为基本类型使用包装类；

  public static void main(String[] args)
    {
//	基本类型转换为String类型 使用String类的valueof（）方法
        int I=100;
        long L=50;
        double db=20.55;
        String str=String.valueOf(I);
        System.out.println(I);
        
        String str2=String.valueOf(L);
        System.out.println(str2);
        
        String str1=String.valueOf(db);
        System.out.println(str1);
//	String类型转换为基本类型使用---包装类；

        db=Double.parseDouble(str1);
        System.out.println(db);
        
        I=Integer.parseInt(str);
        System.out.println(I);
    }

​​

3.基本类型包装类对象间的比较("==")

以Integer类为例子

示例：

public static void main(String[] args) {
        Integer one=new Integer(100);
        Integer two=new Integer(100);
        //false: 通过new关键字创建对象会开辟两块不同的内存空间
        System.out.println(one == two);

        Integer three = 100;
        //true: 与数值比较时会自动拆箱
        System.out.println(three == 100);

        Integer four = 100;
        //实际java执行的代码是：Integer four = Integer.valueOf(100);
        //为了提高运行效率，在Integer内部提供了一个缓冲区(对象池)，是一个静态内部类IntegerCache
        //当参数值在[-128,127]之间时，会从缓冲区去获取对应的Integer对象
        System.out.println(three == four); //true

        //超出范围[-128,127]所有是两个new的对象，而不是从缓冲区取
        Integer five = 200;
        System.out.println(five == 200); //true

        Integer six = 200;
        System.out.println(five==six);//false
    }