Java的基本类型和包装类基本类型和包装类基本类型Java提供了八种基本类型。int类型（整型）int数据类型是32位

基本类型和包装类

基本类型

Java提供了八种基本类型。

int类型 （整型）

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

short类型（短整型）

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

long类型（长整型）

long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；

byte类型（字节）

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
我们也经常使用它来对文件进行操作

char类型（字符型）

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；

float类型（单精度浮点型）

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
在Java中默认定义的常量为double类型如果需要使用float类型需要在后面添加“f”后缀。

double类型（双精度浮点型）

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

boolean****类型（布尔型）

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

想要有默认值是有条件的。

public class Demo {    
    static float demoB;   
    int demoA;   
    public static void main(String[] args) {
        Demo a = new Demo();   
        System.out.println(a.demoA);  
        System.out.println(Demo.demoB); 
        //以下会报错  
        //错误: 可能尚未初始化变量a  
        // int a;   
        // System.out.println(a);  
}}

输出

C:\program>java Demo
0
0.0

只有当基本类型是成员变量或则静态成员变量时才会进行初始化。

包装类

在 Java 的设计中提倡一种思想，即一切皆对象。但是从数据类型的划分中，我们知道 Java 中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够称为对象呢？于是 Java 为每种基本数据类型分别设计了对应的类，称之为包装类。

public class Demo {
    public static void main(String[] args) {

            // byte  
            System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
            System.out.println("包装类：java.lang.Byte");  
            System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
            System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);   

            // short  
            System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
            System.out.println("包装类：java.lang.Short");  
            System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
            System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
            System.out.println();

            // int  
            System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
            System.out.println("包装类：java.lang.Integer");  
            System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
            System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
            System.out.println();  

            // long  
            System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
            System.out.println("包装类：java.lang.Long");  
            System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
            System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
            System.out.println();  

            // float  
            System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
            System.out.println("包装类：java.lang.Float");  
            System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
            System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
            System.out.println();  

            // double  
            System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
            System.out.println("包装类：java.lang.Double");  
            System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
            System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
            System.out.println();  

            //booblean
            Boolean b1 = new Boolean(true);
            Boolean b2 = new Boolean("ok");
            Boolean b3 = new Boolean("true");
            System.out.println("b1 转换为 boolean 值是：" + b1);
            System.out.println("b2 转换为 boolean 值是：" + b2);
            System.out.println("b3 转换为 boolean 值是：" + b3);

            // char  
            System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
            System.out.println("包装类：java.lang.Character");  
            // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
            System.out.println("最小值：Character.MIN_VALUE="  
                    +  Character.MIN_VALUE);  
            // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
            System.out.println("最大值：Character.MAX_VALUE="  
                    +  Character.MAX_VALUE);  
    }
}

包装类与基本数据类型不同，包装类的本质是面向对象的。

在我们使用new Boolean()构造Boolean对象时，上面多了一条横线。

这是因为该方法已经被弃用，虽然还是可以使用但是，并不推荐，所以在正常开发的过程中我们基本不使用已经废弃的方法。

在我们要进行编译时也会弹出提示，并且我们编译时的命令多了一些参数javac Demo.java -encoding utf-8 -Xlint:deprecation这是因为Java 1.5 版本之后可以自动拆箱装箱。

基本数据类型转换为包装类的过程称为装箱，包装类变为基本数据类型的过程称为拆箱。

然后我们看看手动装箱拆箱有什么不同。

public class Demo {
    public static void main(String[] args) {

        //手动装箱
        int a = 1;
        Integer b = new Integer(a);
        System.out.println(b);

        //自动装箱
        Integer c = 3;
        System.out.println(c);

        //手动拆箱
        int d = b.intValue();

        //自动拆箱
        int e = c;

    }
}

实际上区别就是java1.5版本以后jdk会自动将Integer c = 3; 转换为 Integer c = new Integer(3);的区别。

类型转换

  System.out.println(String.valueOf(1.2));

这条语句可以将各种类型转换为String类型。

public class Demo {
    public static void main(String[] args) {

        System.out.println(String.valueOf(1.2));

        System.out.println(Double.parseDouble(String.valueOf(1.2)));

    }
}

然后我们可以使用Double.parseDouble(String.valueOf(1.2)) 将其转换为双精度浮点类型。

每个包装类都有可以转换类型的方法，只是类名与方法名不同。

public class Demo {
    public static void main(String[] args) {

        System.out.println(Double.parseDouble("1.234123423423423423424324234"));

    }
}

上面的字符串很明显已经超出了Double类型的长度范围。我们看看结果会怎么样。

结果被进行了四舍五入。

包装类的坑

public class Demo {
    public static void main(String[] args) {

        Integer a = 128;
        Integer b = 128;

        Integer c = 127;
        Integer d = 127;

        Integer e = -128;
        Integer f = -128;

        Integer g = -129;
        Integer h = -129;

        System.out.println(a==b);
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(g==h);

    }
}

猜一猜上面的四个输出都是什么？

在我刚刚开始学习Java的时候，理所应当的说出了四个“true”，相当的自信。

但是.....

这结果，实力打脸。

为什么会这样呢？

首先我们得包装类是一个对象并不是我们的基本数据类型，所以我们使用==号时比较的是在内存中的地址，并不是包装类中存储的数值。

但是想一想为什么在127到**-128**之间的数值是true，而其他的数都是false，正常来说我们每次都应该是创建了一个新的对象才对，那它们的内存地址应该也不会相等。

到这里引入一个知识点，对于Integer、Short、Byte、Character、Long 这些包装类，都有一个常量池，常量池的范围是-128~127之间。

JVM在运行是把这些对象都提前创建好了，放入了常量池中所以我们在使用127到-128时JVM不会创建新的对象，会直接把常量池中创建好的对象的引用赋给我们的变量。只有在常量池中没有能够使用的数值时才会创建新的对象。这就是原因。

总结，我们在使用包装类比较数值时不应该使用”==“号而是使用.equals()方法进行比较，这样就不会出现上面的这些问题。